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

141 lines
4.3 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
//-----------------------------------------------------------------------------
// An expression in our symbolic algebra system, used to write, linearize,
// and solve our constraint equations.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
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_EXPR_H
#define SOLVESPACE_EXPR_H
Check in some SolveSpace stuff, even though I didn't make much progress. I want to change the sketch.h stuff fairly significantly, I think, before proceeding. [git-p4: depot-paths = "//depot/solvespace/": change = 1657]
2008-04-08 12:54:53 +00:00
class Expr {
public:
Now I can display the edit control in the graphics window, and edit the label associated with a constraint. And that even works, changes the length of the line. [git-p4: depot-paths = "//depot/solvespace/": change = 1678]
2008-04-21 10:12:04 +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 Op : uint32_t {
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// A parameter, by the hParam handle
PARAM = 0,
// A parameter, by a pointer straight in to the param table (faster,
// if we know that the param table won't move around)
PARAM_PTR = 1,
Check in some SolveSpace stuff, even though I didn't make much progress. I want to change the sketch.h stuff fairly significantly, I think, before proceeding. [git-p4: depot-paths = "//depot/solvespace/": change = 1657]
2008-04-08 12:54:53 +00:00
Refactor expression parsing. The new expression parser is significantly simpler, more robust and easier to understand; it also doesn't use longjmp or pollutes Expr::Op anymore.
2016-11-19 04:27:37 +00:00
// Operands
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
CONSTANT = 20,
Refactor expression parsing. The new expression parser is significantly simpler, more robust and easier to understand; it also doesn't use longjmp or pollutes Expr::Op anymore.
2016-11-19 04:27:37 +00:00
VARIABLE = 21,
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
Refactor expression parsing. The new expression parser is significantly simpler, more robust and easier to understand; it also doesn't use longjmp or pollutes Expr::Op anymore.
2016-11-19 04:27:37 +00:00
// Binary ops
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
PLUS = 100,
MINUS = 101,
TIMES = 102,
DIV = 103,
Refactor expression parsing. The new expression parser is significantly simpler, more robust and easier to understand; it also doesn't use longjmp or pollutes Expr::Op anymore.
2016-11-19 04:27:37 +00:00
// Unary ops
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
NEGATE = 104,
SQRT = 105,
SQUARE = 106,
SIN = 107,
COS = 108,
ASIN = 109,
ACOS = 110,
};
Add a little parser, that takes a string and generates and Expr * syntax tree. That's what I'll used for entered dimensions, and algebraic constraints and such. Needs to be extended to handle stuff like points and entities, but I think that it can be. [git-p4: depot-paths = "//depot/solvespace/": change = 1669]
2008-04-17 06:42:32 +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
Op op;
Check in some SolveSpace stuff, even though I didn't make much progress. I want to change the sketch.h stuff fairly significantly, I think, before proceeding. [git-p4: depot-paths = "//depot/solvespace/": change = 1657]
2008-04-08 12:54:53 +00:00
Expr *a;
union {
Make the points locked in 2d csys (expressed as two parameters, for the plane basis vectors) work, easy. Tweak the text window a bit, for cosmetics, and start to add the symbolic expression code. [git-p4: depot-paths = "//depot/solvespace/": change = 1667]
2008-04-13 14:28:35 +00:00
double v;
Check in some SolveSpace stuff, even though I didn't make much progress. I want to change the sketch.h stuff fairly significantly, I think, before proceeding. [git-p4: depot-paths = "//depot/solvespace/": change = 1657]
2008-04-08 12:54:53 +00:00
hParam parh;
Make the points locked in 2d csys (expressed as two parameters, for the plane basis vectors) work, easy. Tweak the text window a bit, for cosmetics, and start to add the symbolic expression code. [git-p4: depot-paths = "//depot/solvespace/": change = 1667]
2008-04-13 14:28:35 +00:00
Param *parp;
Simplify layout of Expr. Make the union anonymous so that its elements can be addressed directly. Then, move the Expr *b field into the union, as it already is never used at the same time as any of the union members.
2016-01-09 11:36:32 +00:00
Expr *b;
};
Make the points locked in 2d csys (expressed as two parameters, for the plane basis vectors) work, easy. Tweak the text window a bit, for cosmetics, and start to add the symbolic expression code. [git-p4: depot-paths = "//depot/solvespace/": change = 1667]
2008-04-13 14:28:35 +00:00
Clean up virtual, override, default, and void params. NFC. Found by clang-tidy.
2019-09-10 17:47:34 +00:00
Expr() = default;
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
Expr(double val) : op(Op::CONSTANT) { v = val; }
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
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 inline Expr *AllocExpr()
Add a function to combine vertices while tesselating the polygon, so that OpenGL can fill self-intersecting polygons. [git-p4: depot-paths = "//depot/solvespace/": change = 1688]
2008-04-25 10:11:29 +00:00
{ return (Expr *)AllocTemporary(sizeof(Expr)); }
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
static Expr *From(hParam p);
static Expr *From(double v);
Make the points locked in 2d csys (expressed as two parameters, for the plane basis vectors) work, easy. Tweak the text window a bit, for cosmetics, and start to add the symbolic expression code. [git-p4: depot-paths = "//depot/solvespace/": change = 1667]
2008-04-13 14:28:35 +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
Expr *AnyOp(Op op, Expr *b);
inline Expr *Plus (Expr *b_) { return AnyOp(Op::PLUS, b_); }
inline Expr *Minus(Expr *b_) { return AnyOp(Op::MINUS, b_); }
inline Expr *Times(Expr *b_) { return AnyOp(Op::TIMES, b_); }
inline Expr *Div (Expr *b_) { return AnyOp(Op::DIV, b_); }
inline Expr *Negate() { return AnyOp(Op::NEGATE, NULL); }
inline Expr *Sqrt () { return AnyOp(Op::SQRT, NULL); }
inline Expr *Square() { return AnyOp(Op::SQUARE, NULL); }
inline Expr *Sin () { return AnyOp(Op::SIN, NULL); }
inline Expr *Cos () { return AnyOp(Op::COS, NULL); }
inline Expr *ASin () { return AnyOp(Op::ASIN, NULL); }
inline Expr *ACos () { return AnyOp(Op::ACOS, NULL); }
Make the points locked in 2d csys (expressed as two parameters, for the plane basis vectors) work, easy. Tweak the text window a bit, for cosmetics, and start to add the symbolic expression code. [git-p4: depot-paths = "//depot/solvespace/": change = 1667]
2008-04-13 14:28:35 +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
Expr *PartialWrt(hParam p) const;
double Eval() const;
uint64_t ParamsUsed() const;
bool DependsOn(hParam p) const;
A ~10x speedup in the solver. Simplify equations before evaluating or taking partials (constant folding). Also keep a little hash table to mark with params are used in each equation, in order to quickly discard trivial partial derivatives. This is solving a 64x64 system in <20 ms. I suspect this is now much faster than Sketchflat. Slightly fake situation, though, since substitution solver has not yet been written, and no partitioning. I'll do those next. [git-p4: depot-paths = "//depot/solvespace/": change = 1698]
2008-04-30 04:52:34 +00:00
static bool Tol(double a, double b);
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
Expr *FoldConstants();
Add the substitution solver. That speeds things up a bit, and improves the quality of assumptions. [git-p4: depot-paths = "//depot/solvespace/": change = 1709]
2008-05-07 07:10:20 +00:00
void Substitute(hParam oldh, hParam newh);
Make the points locked in 2d csys (expressed as two parameters, for the plane basis vectors) work, easy. Tweak the text window a bit, for cosmetics, and start to add the symbolic expression code. [git-p4: depot-paths = "//depot/solvespace/": change = 1667]
2008-04-13 14:28:35 +00:00
If any equations are soluble in a single variable, then handle them separately, even before doing the rank test. In some cases, that's a huge speedup. [git-p4: depot-paths = "//depot/solvespace/": change = 1811]
2008-06-26 09:34:26 +00:00
static const hParam NO_PARAMS, MULTIPLE_PARAMS;
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
hParam ReferencedParams(ParamList *pl) const;
If any equations are soluble in a single variable, then handle them separately, even before doing the rank test. In some cases, that's a huge speedup. [git-p4: depot-paths = "//depot/solvespace/": change = 1811]
2008-06-26 09:34:26 +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 ParamsToPointers();
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +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
std::string Print() const;
Add a little parser, that takes a string and generates and Expr * syntax tree. That's what I'll used for entered dimensions, and algebraic constraints and such. Needs to be extended to handle stuff like points and entities, but I think that it can be. [git-p4: depot-paths = "//depot/solvespace/": change = 1669]
2008-04-17 06:42:32 +00:00
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
// number of child nodes: 0 (e.g. constant), 1 (sqrt), or 2 (+)
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 Children() const;
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
// total number of nodes in the tree
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 Nodes() const;
Add a little parser, that takes a string and generates and Expr * syntax tree. That's what I'll used for entered dimensions, and algebraic constraints and such. Needs to be extended to handle stuff like points and entities, but I think that it can be. [git-p4: depot-paths = "//depot/solvespace/": change = 1669]
2008-04-17 06:42:32 +00:00
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
// Make a simple copy
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
Expr *DeepCopy() const;
Start to add some constraint stuff. I now have point-coincident, and point-in-plane. These work, but the equation is still stupid, solving everything at once and not substituting trivial equations. [git-p4: depot-paths = "//depot/solvespace/": change = 1677]
2008-04-21 08:16:38 +00:00
// Make a copy, with the parameters (usually referenced by hParam)
// resolved to pointers to the actual value. This speeds things up
// considerably.
Expr *DeepCopyWithParamsAsPointers(IdList<Param,hParam> *firstTry,
Refactor expression parsing. The new expression parser is significantly simpler, more robust and easier to understand; it also doesn't use longjmp or pollutes Expr::Op anymore.
2016-11-19 04:27:37 +00:00
IdList<Param,hParam> *thenTry) const;
Start to add some constraint stuff. I now have point-coincident, and point-in-plane. These work, but the equation is still stupid, solving everything at once and not substituting trivial equations. [git-p4: depot-paths = "//depot/solvespace/": change = 1677]
2008-04-21 08:16:38 +00:00
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
static Expr *Parse(const std::string &input, std::string *error);
static Expr *From(const std::string &input, bool popUpError);
Check in some SolveSpace stuff, even though I didn't make much progress. I want to change the sketch.h stuff fairly significantly, I think, before proceeding. [git-p4: depot-paths = "//depot/solvespace/": change = 1657]
2008-04-08 12:54:53 +00:00
};
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +00:00
class ExprVector {
public:
Expr *x, *y, *z;
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
static ExprVector From(Expr *x, Expr *y, Expr *z);
static ExprVector From(Vector vn);
static ExprVector From(hParam x, hParam y, hParam z);
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
static ExprVector From(double x, double y, double z);
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +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
ExprVector Plus(ExprVector b) const;
ExprVector Minus(ExprVector b) const;
Expr *Dot(ExprVector b) const;
ExprVector Cross(ExprVector b) const;
ExprVector ScaledBy(Expr *s) const;
ExprVector WithMagnitude(Expr *s) const;
Expr *Magnitude() const;
Add parallel and same orientation constraints, that work on line segments and normals. [git-p4: depot-paths = "//depot/solvespace/": change = 1713]
2008-05-09 05:33:23 +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 Eval() const;
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +00:00
};
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
class ExprQuaternion {
public:
Expr *w, *vx, *vy, *vz;
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
static ExprQuaternion From(Expr *w, Expr *vx, Expr *vy, Expr *vz);
static ExprQuaternion From(Quaternion qn);
More use of ::From functions to simplify code. [git-p4: depot-paths = "//depot/solvespace/": change = 1764]
2008-06-01 08:57:16 +00:00
static ExprQuaternion From(hParam w, hParam vx, hParam vy, hParam vz);
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
Add 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
ExprVector RotationU() const;
ExprVector RotationV() const;
ExprVector RotationN() const;
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +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
ExprVector Rotate(ExprVector p) const;
ExprQuaternion Times(ExprQuaternion b) const;
Add transformed points and normals with a rotation (as well as a translation; or equivalently, rotation about an arbitrary axis). Those will be important for step and repeats, and for imported parts. Also fix a terrible memory corruption bug: I was freeing the remap list after I loaded it from the file, but the code that put that into the SS.group list made only a shallow copy. [git-p4: depot-paths = "//depot/solvespace/": change = 1715]
2008-05-11 06:09:46 +00:00
Add 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
Expr *Magnitude() const;
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
};
Check in some SolveSpace stuff, even though I didn't make much progress. I want to change the sketch.h stuff fairly significantly, I think, before proceeding. [git-p4: depot-paths = "//depot/solvespace/": change = 1657]
2008-04-08 12:54:53 +00:00
#endif