PK_FACE_change_deform_o_t

struct PK_FACE_change_deform_o_s
    {
    int              o_t_version;     --- version number of option structure
    int              n_matched_edges; --- number of matched edges (0)
    const PK_EDGE_t *matched_edges;   --- matched edges (NULL)
    PK_deform_uv_t   deform_uv;       --- control evaluation range of deform
                                      --- (PK_deform_uv_face_box_c) [NF]
    PK_LOGICAL_t     thread_safe;     --- whether the external evaluator
                                      --- function is thread-safe
                                      --- (PK_LOGICAL_false)
    PK_EXPR_sf_t     eval_expr;       --- An expression evaluator to use
                                      --- instead of a callback function.
    };
typedef struct PK_FACE_change_deform_o_s PK_FACE_change_deform_o_t;


This structure contains deform-specific optional controls for PK_FACE_change.


Specific Errors:
    PK_ERROR_not_implemented   (MILD)    PK_deform_uv_on_face_c is not a
                                         supported value for 'deform_uv'.

    PK_ERROR_bad_combination   (MILD)    An expression is supplied (via the
                                         'root_expr' field of 'eval_expr'),
                                         and either:
                                           - 'thread_safe' is set to
                                             PK_LOGICAL_true,
                                           - 'eval_fn' in the deform parameters
                                             is non-NULL.

Used in:

PK_FACE_change_opts_t

Description of fields:


'n_matched_edges'    The number of matched edges.

'matched_edges'      An array of length 'n_matched_edges'. An edge should be
                     supplied in this array if the deform operation is such
                     that the edge will move identically with the operation on
                     the adjacent face, or in the case of no operation, that
                     the edge will not be moved.

                     The edges must be non-laminar edges belonging to a face
                     being deformed by this operation.

'deform_uv'          Specifies the method for determining the range of the
                     original surface that the deformation is evaluated on,
                     and whether any geometry may be shared.

'thread_safe'        Specifies whether the external evaluator function may be
                     called from more than one thread simultaneously. If set to
                     PK_LOGICAL_true, and SMP is enabled within Parasolid, then
                     the evaluator function may be called from multiple
                     threads, and it is the application's responsiblity to
                     ensure that the function is thread-safe. If set to
                     PK_LOGICAL_false, then Parasolid will ensure that the
                     evaluator function is not called from multiple threads,
                     even when SMP is switched on in Parasolid.

'eval_expr'          If an expression is supplied (by setting a non-NULL
                     'root_expr' field), then the expression will define the
                     evaluator function for this deform operation (as an
                     alternative to supplying a PK_FACE_change_deform_eval_f_t
                     callback function in 'eval_fn'), to describe how the
                     original face should be deformed.

                     The expression has the following variables available:
                         'position' (vector) - An input position located on the
                                               surface of the original 'face'.
                         'face' (PK_FACE_t)  - The face for the evaluation.

                     The expression should evaluate to the corresponding
                     deformed position (vector).

                     An example of an expression which translates the face 0.1
                     units along the x-axis is to supply the 'root_expr'
                     string:
                         position + vector(0.1, 0.0, 0.0)

                     If an expression is supplied, then:
                         'thread_safe' must be set to PK_LOGICAL_false.
                         'eval_fn' in the deform parameters must be set to
                         NULL.