155 lines
7.3 KiB
Plaintext
155 lines
7.3 KiB
Plaintext
|
|
CREATING NEW GROUPS in 3D
|
|
=================================
|
|
|
|
New Transformed Entity Types:
|
|
-----------------------------
|
|
New construction tools may require new transformations of entities - Points,
|
|
Normals, and Faces. A number of "Types" exist to transform an entity to a new
|
|
location. The term "Type" refers to the type of transformation an entity was
|
|
created from, and should not be confused with the 3 kinds of Entity (there are
|
|
other entities but they rely on others of the 3 base types for position and
|
|
orientation information, so they don't directly transform). A list of
|
|
Types is at the top of the EntityBase class definition:
|
|
|
|
enum class Type : uint32_t {
|
|
POINT_IN_3D = 2000,
|
|
POINT_IN_2D = 2001,
|
|
POINT_N_TRANS = 2010,
|
|
POINT_N_ROT_TRANS = 2011,
|
|
POINT_N_COPY = 2012,
|
|
POINT_N_ROT_AA = 2013,
|
|
POINT_N_ROT_AXIS_TRANS = 2014,
|
|
|
|
NORMAL_IN_3D = 3000,
|
|
NORMAL_IN_2D = 3001,
|
|
NORMAL_N_COPY = 3010,
|
|
NORMAL_N_ROT = 3011,
|
|
NORMAL_N_ROT_AA = 3012,
|
|
|
|
FACE_NORMAL_PT = 5000,
|
|
FACE_XPROD = 5001,
|
|
FACE_N_ROT_TRANS = 5002,
|
|
FACE_N_TRANS = 5003,
|
|
FACE_N_ROT_AA = 5004,
|
|
|
|
Some of the point definitions with _N_ in the name are points defined by
|
|
N application of a transformation. The number of times a particular entity
|
|
is transformed is given in the member variable "timesApplied". The following
|
|
is a dectription of the various transformation Types.
|
|
|
|
POINT_N_TRANS: Translates a point by a vector defined by param[0],param[1],param[2]
|
|
the vector is multiplied by timesApplied.
|
|
|
|
POINT_N_ROT_TRANS: Rotates a point via quaternion param[3],param[4],param[5],param[6]
|
|
and then translates it by vector param[0],param[1],param[2]
|
|
|
|
POINT_N_COPY: A non-transformed copy of a point - numeric copy?
|
|
|
|
POINT_N_ROT_AA: A point rotated arount point param[0],param[1],param[2] Where the
|
|
angle is given by param[3]*timesApplied (times 2?) and the axis
|
|
of rotation defined by param[4],param[5],param[6]
|
|
|
|
POINT_N_ROT_AXIS_TRANS: Same as POINT_N_ROT_AA but after rotation, the point is
|
|
translated along the rotation axis by distance param[7].
|
|
|
|
NORMAL_N_COPY A non-transformed copy of a normal - numeric copy?
|
|
|
|
NORMAL_N_ROT: A normal rotated by a quaternion defeined by param[0],param[1],param[2],param[3]
|
|
|
|
NORMAL_N_ROT_AA A normal rotated by timesApplied*param[0] around the axis
|
|
specified by param[1],param[2],parma[3]
|
|
|
|
FACE_N_ROT_TRANS A face rotated then translated. Rotation is defined by
|
|
quaternion param[3],param[4],param[5],param[6]. The translation
|
|
is defined by param[0],param[1],param[2].
|
|
|
|
FACE_N_TRANS: Translates a face by a vector defined by param[0],param[1],param[2]
|
|
faces are defined by a point and a normal, so this just moves the point.
|
|
|
|
FACE_N_ROT_AA Face rotated about point param[0],param[1],param[2]. The axis
|
|
is param[4],param[5],param[6]. Angle is timesApplied*param[3].
|
|
|
|
|
|
All entities are copied by the function Group::CopyEntity() which has a CopyAs
|
|
parameter to indicate which kind of copy is to be made. The mapping from CopyAs to
|
|
Entity Types can be found in that function. Most point types get copied the same
|
|
way depending on CopyAs. Several of the normals get copied to the same new
|
|
entity Type because they are unaffected by translation - you don't care if CopyAs
|
|
specified a translation with rotation or just a rotation, a normal is affected the
|
|
same in either case. The mapping from entity type to new entity type has to be
|
|
decoded from the cases and if-else logic in that function.
|
|
|
|
It is important that a transformation be properly applied to all three of the
|
|
fundamental entities - points, normals, and surfaces.
|
|
|
|
FUNCTIONS THAT MAY NEED TO BE EXTENDED when new entity types are defined:
|
|
|
|
These functions have default cases, so they only need to be extended to return True:
|
|
EntityBase::IsPoint()
|
|
EntityBase::IsNormal()
|
|
EntityBAse::IsFace()
|
|
|
|
For new normal transforms the following should be filled in:
|
|
Quaternion EntityBase::NormalGetNum()
|
|
void EntityBase::NormalForceTo(Quaternion q)
|
|
ExprQuaternion EntityBase::NormalGetExprs()
|
|
|
|
For points:
|
|
Vector EntityBase::PointGetNum()
|
|
void EntityBase::PointForceTo(Vector p)
|
|
ExprVector EntityBase::PointGetExprs()
|
|
|
|
For Faces:
|
|
ExprVector EntityBase::FaceGetNormalExprs()
|
|
Vector EntityBase::FaceGetNormalNum()
|
|
ExprVector EntityBase::FaceGetPointExprs()
|
|
Vector EntityBase::FaceGetPointNum()
|
|
|
|
The basic model for these transformed entities is that the group containing them
|
|
will have parameters that define the transformed entity in terms of the one it
|
|
was copied from. For example, in PointGetNum() under the case POINT_N_TRANS we see:
|
|
|
|
Vector trans = Vector::From(param[0], param[1], param[2]);
|
|
p = numPoint.Plus(trans.ScaledBy(timesApplied));
|
|
break;
|
|
|
|
This take the original "numPoint" and adds a vector created from 3 parameters and
|
|
multiplied by "timesApplied". This is used in the step-translating groups. It's also
|
|
used in extrude groups where there are constraints on the 3 parameters to keep the
|
|
vector perpendicular to the sketch it was extruded from. This function returns a
|
|
numerical version of the copied point, hence "GetNum" in the name.
|
|
|
|
Another function PointGetExprs() returns the same coordinates of the point but
|
|
returns an expression vector. When the user applies a constraint to a point, this
|
|
function is called to get algebraic expressions for the point that are suitable for
|
|
use in the solver. Most points will not be constrained directly, so expressions
|
|
are not needed for them. It is also notable that the expressions are not part of
|
|
the entity itself.
|
|
|
|
The ForceTo() functions are shortcuts for using the solver. They are passed the
|
|
desired location of a point (or orientation of a normal...) and have the opportunity
|
|
to back-calculate what the group parameters should be to place it there. This is
|
|
used for mouse dragging of copied entites. It is notable that the constraints will
|
|
still be applied afterward, but this is a good shortcut.
|
|
|
|
When creating a new entity transformation, the first thing to do is define the
|
|
numerical copy (xxxGetNum). That should allow display. Dragging will not work
|
|
until ForceTo is implemented, and user constraints will not work until GetExprs()
|
|
is completed. Most of these functions have an assert that will fire if the required
|
|
new case is missing. This is may not be a complete list of everything you need to
|
|
make new entity transformations.
|
|
|
|
One thing of note, parameters in both entities and groups are stored by their handle.
|
|
An entity can have up to 8 parameters to define how it is transformed from another
|
|
entity. By convention this array of parameter handles matches that of the group but
|
|
this is probably not strictly necessary.
|
|
|
|
ADDING GROUP CONSTRAINTS:
|
|
The example above where a point is copied via POINT_N_TRANS for both EXTRUDE and
|
|
STEP TRANSLATING groups is a good example here. For the EXTRUDE case, two constraint
|
|
equations are added to keep the offset vector perpendicular to the sketch. These
|
|
equations are created in Group::GenerateEquations() and are nothing more than an
|
|
expression which is implicitly set equal to zero in the solver.
|
|
|