Classes: MeshDataEdit

MeshDataEdit

Availability LightWave® 6.0
Component Modeler
Header lwmeshedt.h

Mesh edit plug-ins create and modify geometry at the point and polygon level. This class is a subset of the CommandSequence class, which provides access to both mesh editing and commands, and of the MeshEditTool class, an interactive version of MeshDataEdit.

Activation Function

   XCALL_( int ) MyMeshEdit( int version, GlobalFunc *global,
        MeshEditBegin *local, void *serverData );

The local argument to a mesh edit plug-in's activation function is a MeshEditBegin.

   typedef MeshEditOp *
        MeshEditBegin (int pntBuf, int polBuf, EltOpSelect);

This function returns a MeshEditOp structure containing the mesh editing functions. It can be called only once for each activation.

The MeshEditBegin function can allocate a user data buffer for each point and polygon. This is memory you can use to store per-point and per-polygon information during the edit. Modeler automatically frees these buffers when the edit is completed. The pntBuf and polBuf arguments set the sizes of the buffers.

EltOpSelect

When the edit begins, Modeler sets a selection flag for each point and polygon. The EltOpSelect code determines which geometry is flagged as selected, and it can be one of the following.

OPSEL_GLOBAL: All elements, whether or not they're selected by the user.
OPSEL_USER: Only those elements selected by the user. This includes the implicit selection of all elements when nothing is explicitly selected, and selections by volume.
OPSEL_DIRECT: Elements selected directly with the point or polygon selection tools. This applies to both points and polygons regardless of which is currently active in the interface.
OPSEL_MODIFY: This activates a special mesh edit mode that can change the selection state of specific points and polygons. The mesh editing functions for adding and changing geometry aren't available in this mode, but the query functions can be used. The selection state of a point or polygon is modified by calling the MeshEditOp pntSelect or polSelect functions, typically within a pointScan or polyScan callback. OPSEL_MODIFY must be combined with one of the other selection modes in the MeshEditBegin call.

EltOpLayer

Many of the MeshEditOp functions operate on a specific set of layers, and these are identified by an EltOpLayer code.

OPLYR_PRIMARY: The primary layer. This is the single active layer affected by mesh edits, normally the lowest numbered foreground layer.
OPLYR_FG: Foreground layers, which are active and displayed.
OPLYR_BG: Background layers, which are inactive but still displayed.
OPLYR_SELECT: Both foreground and background layers.
OPLYR_ALL: All layers in the Modeler system whether they contain data or not.
OPLYR_EMPTY: Empty layers are those that contain no geometry.
OPLYR_NONEMPTY: Non-empty layers are any layers which contain some data (the complement of OPLYR_EMPTY).
Individual Layers: In addition to the defined values, codes starting at 101 (for layer 1) can be used to select the individual layers by number.

Error Codes

Most of the mesh edit functions return an error state defined by one of the following codes. One of these is also passed to the MeshEditOp done function.

EDERR_NONE: Success.
EDERR_NOMEMORY: A memory allocation failed.
EDERR_BADLAYER: An operation was attempted in an invalid layer.
EDERR_BADSURF: The edit created an invalid surface name.
EDERR_USERABORT: The user (or the plug-in) ended the edit before it was completed.
EDERR_BADVMAP: The operation involved an invalid vertex map.
EDERR_BADARGS: The function failed for a reason not covered by the other error codes.

MeshEditOp

The MeshEditBegin function returns a MeshEditOp containing data and functions for performing mesh edits.

typedef struct st_MeshEditOp
{
    EDStateRef        state;
    int               layerNum;
    
    void            (*done)             (EDStateRef, EDError, int selm);
    
    int             (*pointCount)       (EDStateRef, EltOpLayer, int mode);
    EDError         (*edgeCount)        (EDStateRef, EltOpLayer, int mode);
    int             (*polyCount)        (EDStateRef, EltOpLayer, int mode);
    
    EDError         (*pointScan)        (EDStateRef, EDPointScanFunc *, void *, EltOpLayer);
    EDError         (*edgeScan)         (EDStateRef, EDEdgeScanFunc*, void*, EltOpLayer);
    EDError         (*polyScan)         (EDStateRef, EDPolyScanFunc *, void *, EltOpLayer);
    
    EDError         (*fastPointScan)    (EDStateRef, EDFastPointScanFunc*, void*, EltOpLayer, int);
    EDError         (*fastEdgeScan)     (EDStateRef, EDFastEdgeScanFunc*, void*, EltOpLayer, int);
    EDError         (*fastPolyScan)     (EDStateRef, EDFastPolyScanFunc*, void*, EltOpLayer, int);
    
    EDPointInfo *   (*pointInfo)        (EDStateRef, LWPntID);
    EDEdgeInfo *    (*edgeInfo)         (EDStateRef, LWEdgeID);
    EDPolygonInfo * (*polyInfo)         (EDStateRef, LWPolID);
    
    int             (*polyNormal)       (EDStateRef, LWPolID, double[3]);
    unsigned int    (*polyType)         (EDStateRef, LWPolID);
    int             (*polyPoints)       (EDStateRef, LWPolID, const LWPntID**);
    
    LWPntID         (*addPoint)         (EDStateRef, double *xyz);
    LWPolID         (*addFace)          (EDStateRef, const char *surf, int numPnt, const LWPntID *);
    LWPolID         (*addCurve)         (EDStateRef, const char *surf, int numPnt, const LWPntID *, int flags);
    EDError         (*addQuad)          (EDStateRef, LWPntID, LWPntID, LWPntID, LWPntID);
    EDError         (*addTri)           (EDStateRef, LWPntID, LWPntID, LWPntID);
    EDError         (*addPatch)         (EDStateRef, int nr, int nc, int lr, int lc,
                                                     EDBoundCv *r0, EDBoundCv *r1, EDBoundCv *c0, EDBoundCv *c1);
    
    EDError         (*remPoint)         (EDStateRef, LWPntID);
    EDError         (*remPoly)          (EDStateRef, LWPolID);
    
    EDError         (*pntMove)          (EDStateRef, LWPntID, const double *);
    EDError         (*polSurf)          (EDStateRef, LWPolID, const char *);
    EDError         (*polPnts)          (EDStateRef, LWPolID, int, const LWPntID *);
    EDError         (*polFlag)          (EDStateRef, LWPolID, int mask, int value);
    
    EDError         (*polTag)           (EDStateRef, LWPolID, LWID, const char *);
    EDError         (*pntVMap)          (EDStateRef, LWPntID, LWID, const char *, int, float *);
    
    LWPolID         (*addPoly)          (EDStateRef, LWID type, LWPolID, const char *surf, int numPnt, const LWPntID *);
    LWPntID         (*addIPnt)          (EDStateRef, double *xyz, int numPnt, const LWPntID *, const double *wt);
    EDError         (*initUV)           (EDStateRef, float *uv);
    
    void *          (*pointVSet)        (EDStateRef, void *, LWID, const char *);
    int             (*pointVGet)        (EDStateRef, LWPntID, float *);
    const char *    (*polyTag)          (EDStateRef, LWPolID, LWID);
    
    EDError         (*pntSelect)        (EDStateRef, LWPntID, int);
    EDError         (*edgeSelect)       (EDStateRef, LWEdgeID, int);
    EDError         (*polSelect)        (EDStateRef, LWPolID, int);
    
    int             (*pointVPGet)       (EDStateRef, LWPntID, LWPolID, float *);
    int             (*pointVEval)       (EDStateRef, LWPntID, LWPolID, float *);
    EDError         (*pntVPMap)         (EDStateRef, LWPntID, LWPolID, LWID, const char *, int, float *);
    
    int             (*edgePolys)        (EDStateRef, LWEdgeID, const LWPolID**);
    LWPntID         (*edgePoint1)       (EDStateRef, LWEdgeID);
    LWPntID         (*edgePoint2)       (EDStateRef, LWEdgeID);
    LWEdgeID        (*edgeFromPoints)   (EDStateRef, LWPntID, LWPntID);
    
    void            (*pointPos)         (EDStateRef, LWPntID, double[3]);
    int             (*pointEdges)       (EDStateRef, LWPntID, const LWEdgeID**);
    
    int             (*pointFlags)       (EDStateRef, LWPntID);
    int             (*edgeFlags)        (EDStateRef, LWEdgeID);
    int             (*polyFlags)        (EDStateRef, LWPolID);

    void *          (*vMapSelect)       (EDStateRef es, const char* name, LWID type, int dim);
    int             (*vMapExists)       (EDStateRef es, const char* name, LWID type);
    unsigned int    (*vMapGetDimension) (EDStateRef es);
    void            (*vMapSet)          (EDStateRef es, LWPntID point_id, const float *value);
    void            (*vMapPSet)         (EDStateRef es, LWPntID point_id, LWPolID polygon_id, const float *value);
    void            (*vMapSetIdeal)     (EDStateRef es, LWPntID point_id, LWPolID polygon_id, const float *value);
    void            (*vMapRemove)       (EDStateRef es);
    void            (*vMapRename)       (EDStateRef es, const char *new_name);

} MeshEditOp;

state

An opaque pointer to data used internally by Modeler during the mesh edit. Pass this as the first argument to all of the edit functions.

layerNum

Points and polygons may only be created or modified in the primary active layer, which is given by this layer number. The primary layer is the lowest numbered foreground layer.

done( state, error, selset )

Call this when the edit is complete. As changes are made during an edit, they are buffered through Modeler's undo mechanism, so they are not reflected in the data until done is called, and not at all if done sets the error argument.

In general, if one of the edit functions returns an error, you'll pass that error to done. If you just want the edit to stop or be discarded, possibly because the user pressed the Cancel button in a progress monitor, you'll pass EDERR_USERABORT. If an error occurs in your plug-in, you'll pass EDERR_NOMEMORY (for memory allocation errors) or EDERR_BADARGS (for everything else). And if the edit was successful, you'll use EDERR_NONE.

The selset argument tells Modeler how you want the selection to appear to the user after the edit has been applied. It contains flags combined using bitwise-or, and can include the following.

EDSELM_CLEARCURRENT: Deselect elements that were selected when the edit began.
EDSELM_SELECTNEW: Select elements created by the edit.
EDSELM_FORCEVRTS: Force selection of newly created vertices.
EDSELM_FORCEPOLS: Force selection of newly created polygons.

A value of 0 leaves all directly selected elements selected after the edit. The CLEARCURRENT and SELECTNEW flags are polite hints; they won't override selection settings made by the user. The force flags will always force direct selection of the points or polygons created by the edit.

npoints = pointCount( state, oplayer, selmode )
npolygons = polyCount( state, oplayer, selmode )

Returns the number of points or polygons that meet the layer and selection criteria. The selection mode can be one of the following.

EDCOUNT_ALL: Both selected and unselected points or polygons.
EDCOUNT_SELECT: Only selected points or polygons.
EDCOUNT_DELETE: Only points or polygons flagged for deletion by this mesh edit.

err = pointScan( state, scanfunc, userdata, oplayer )
err = edgeScan( state, scanfunc, userdata, oplayer )
err = polyScan( state, scanfunc, userdata, oplayer )

Enumerate geometry in the specified layers. For each element, Modeler calls the callback function you supply. The callbacks are defined this way.

typedef EDError EDPointScanFunc (void *, const EDPointInfo *); typedef EDError EDEdgeScanFunc (void *, const EDEdgeInfo *) typedef EDError EDPolyScanFunc (void *, const EDPolygonInfo *)

The userdata pointer is passed as the first argument to your callbacks, and it can be whatever is useful to you. The point and polygon info structures passed as the second argument are described later. If your callback returns an error, the scan is stopped and the callback's error is returned.

Point and polygon scans will enumerate all of the geometry in the layers you request, regardless of what geometry is selected, even if you begin the edit with OPSEL_USER or OPSEL_DIRECT. To find out whether a given element is selected (as defined by your choice of EltOpSelect), you need to test the EDPointInfo or EDPolygonInfo flags field for the EDDF_SELECT bit. Similarly, if you've deleted geometry during the mesh edit, it will still be enumerated, but the flags field of the info structure will contain EDDF_DELETE.

err = fastPointScan( state, scanfunc, userdata, oplayer, selected_only )
err = fastEdgeScan( state, scanfunc, userdata, oplayer, selected_only )
err = fastPolyScan( state, scanfunc, userdata, oplayer, selected_only )

These are like the above versions, but do not provide complete info structures at every iteration. Instead, the callbacks are supplied element IDs from which the necessary data can be extracted. There is also a selected_only parameter which can be specified to true, in which case the scan function is only applied for the selected elements only. This is more efficient than checking for the EDDF_SELECT flag at every scan iteration. The callbacks are defined like so:

typedef EDError EDPointScanFunc (void *, LWPntID); typedef EDError EDEdgeScanFunc (void *, LWEdgeID) typedef EDError EDPolyScanFunc (void *, LWPolID)

info = pointInfo( state, point )
info = edgeInfo( state, edge )
info = polyInfo( state, polygon )

Returns information about a point, edge, or polygon. These return the same EDPointInfo, EDEdgeInfo, and EDPolygonInfo structures that are passed to the scan callbacks.

ok = polyNormal( state, polygon, norm )

Get a polygon's normal. The normal is a unit vector perpendicular to the plane defined by the first, second and last vertex of the polygon. If the polygon has fewer than three vertices, or is somehow degenerate, norm isn't changed and the function returns 0. Otherwise it returns 1 and norm receives the normal.

point = addPoint( state, pos )

Create a point.

polygon = addFace( state, surfname, npoints, point_array )

Create a polygon. If the surface name is NULL, the polygon will be assigned the current default surface. The vertices are defined by an array of point IDs listed in clockwise order. The polygon normal will be inferred from the first, second and last points.

polygon = addCurve( state, surfname, npoints, point_array, flags )

Create a curve (a polygon of type LWPOLTYPE_CURV). The EDPF_CCSTART and EDPF_CCEND flags specify that the first and last points in the point array should serve as control points and not be included in the curve itself. To create a closed curve, both of these flags must be set, and the first and last point must overlap.

err = addQuad( state, v1, v2, v3, v4 )
err = addTri( state, v1, v2, v3 )

Create a quadrangle or a triangle with the current default surface. These two functions respect the user's settings for new geometry. Two collocated polygons with opposite normals will be created if the user has set the double-sided option, and quads will be split into two triangles if the user has set the triangles-only option.

err = addPatch( state, nr, nc, lr, lc, r0, r1, c0, c1 )

Create a polygonal patch defined by three or four bounding curves. The first two arguments (after the EditStateRef) give the number of patch divisions in the R (row) and C (column) directions. The second two arguments are booleans; if 0, the divisions are equally spaced along the curve, and if 1, the spacing is determined by the positions of the curve knots. The last four arguments are the bounding curves, each defined by an EDBoundCV structure.

typedef struct st_EDBoundCv 
{
    LWPolID curve;
    int     start, end;
} EDBoundCv;

The start and end indexes are the points on the curve that should be used as endpoints for patching. The first and second curves define the R boundaries. The third and optional fourth curve define the C boundaries.

err = remPoint( state, point )

Delete the point. Modeler will flag the point as deleted, but will actually remove it from the database only after done is called.

err = remPoly( state, polygon )

Delete the polygon.

err = pntMove( state, point, pos )

Put a point in a new position.

err = polSurf( state, polygon, surfname )

Change the surface assigned to a polygon.

err = polPnts( state, polygon, npoints, point_array )

Replace the point list of a polygon.

err = polFlag( state, polygon, mask, value )

Set polygon flags. The mask contains 1 bits for each flag you want to change, and the value contains the new flag settings (0 or 1 for each 1 bit in the mask). Currently, the flags that can be changed are the EDPF_START and EDPF_END flags for curves.

err = polTag( state, polygon, tagtype, tag )

Add a polygon tag to a polygon, or change an existing tag. If the tag type is LWPTAG_SURF, the tag is the surface name. If the tag type is LWPTAG_PART, the tag is the part (or group) name. For anything other than surface tags, passing a NULL tag will remove an existing tag of the specified type.

err = pntVMap( state, point, type, name, nvalues, val_array )

Add a vmap vector to a point. The vmap type can be one of the following, or something else.

LWVMAP_PICK - selection set
LWVMAP_WGHT - weight map
LWVMAP_MNVW - subpatch weight map
LWVMAP_TXUV - texture UV coordinates
LWVMAP_MORF - relative vertex displacement (morph)
LWVMAP_SPOT - absolute vertex displacement (morph)
LWVMAP_RGB, LWVMAP_RGBA - vertex color
LWVMAP_NORM - vertex normals

Pass a NULL val_array to remove a vmap vector from the point.

polygon = addPoly( state, type, template, surf, npoints, point_array )

Create a polygon. If a template polygon is supplied, Modeler copies the polygon tags for the new polygon from the template. If the surface name is NULL, the surface will be that of the template, or the current default surface if the template is NULL. The vertices of the new polygon are listed in clockwise order, and the normal will be inferred from the first, second and last vertex.

point = addIPnt( state, pos, npoints, point_array, weight_array )

Create an "interpolated" point. The new point's vmap values are calculated as a weighted average of the vmaps of the points in the points array. If pos is NULL, the position is also computed as a weighted average. If the weight array is NULL, the averaging over the point list is uniform. The weights are renormalized to sum to 1.0.

err = initUV( state, uv )

Set the texture UV for a point or polygon you're about to create. If a texture map is selected in Modeler's interface, the UVs will be assigned to that map as points or polygons are created. You'll typically want to give the user the option of whether or not to create UVs for new points and polygons.

When creating points, pass initUV an array of two floats and then call any of the functions that create a point. The two floats will be used as the U and V for the point, after which the initUV state will be cleared so that subsequent points have no UV unless the function is called again.

To initialize per-polygon, or discontinuous, UVs, call initUV with a pointer to 2n floats before creating a polygon with n vertices. For each vertex, if the point's continuous UV value is different from the UV in the array, then a polygon-specific UV is set for the vertex. If the point has no continuous UV, then the continuous value for the point is set to the polygon UV.

Any combination of these two methods can be used to assign UVs to new data. If only polygon UVs are specified, continuous UVs will still be created where polygons share UV values. Alternately, plug-ins can assign UVs to points and only specify polygon UVs along seam polygons.

vmapID = pointVSet( state, vmapID, vmaptype, vmapname )

Select a vmap for reading vectors. Returns an opaque pointer that can be used to select the same vmap in later calls to this function. The first time this is called for a given vmap, the pointer can be NULL, and Modeler will locate and select the vmap using the type and name arguments.

ismapped = pointVGet( state, point, val )

Read the vmap vector for a point. The vector is read from the vmap selected by a previous call to pointVSet. If the point is mapped (has a vmap value in the selected vmap), the val array is filled with the vmap vector for the point, and pointVGet returns true. If you don't already know the dimension of the vmap (the number of values per point, and therefore the required size of the val array), you can use the scene objects global or use the vMapGetDimension call to find out.

See also pointVPGet and pointVEval. pointVGet is equivalent to reading values from a VMAP chunk in an object file. It returns the continuous, or per-point, vector. For the raw discontinuous, or per-polygon-vertex value, use pointVPGet, and for the combined value accounting for both sources, use pointVEval.

tag = polyTag( state, polygon, tagtype )

Returns a tag string associated with the polygon. For the LWPTAG_SURF tag type, the surface name is returned.

err = pntSelect( state, point, setsel )
err = polSelect( state, polygon, setsel )

Set the selection state of a point or polygon. These can only be called during OPSEL_MODIFY mesh edits. The element is selected if setsel is true and deselected if it's false.

ismapped = pointVPGet( state, point, polygon, val )

Read the vmap vector for a polygon vertex. This is like pointVGet, but it returns the discontinuous vmap value, equivalent to reading entries in a VMAD chunk.

ismapped = pointVEval( state, point, polygon, val )

Read the vmap vector for a point, accounting for both continuous and discontinuous values. Generally, if a discontinuous value exists for the point, that value will be returned. Otherwise the continuous value is used.

err = pntVPMap( state, point, polygon, type, name, dim, val )

Add a discontinuous vmap vector to a polygon vertex. This is the vector returned by pointVPGet. See pntVMap for a partial list of vmap types.

pointPos( state, point, out_position )

Copies the position of the specified point into out_position.

pointEdges( state, point, out_edges )

Returns the edges surrounding the specified point.

const LWEdgeID* edges;
int num_edges = edit->pointEdges(state, point, &edges);
// do something with edges

edgePolys( state, edge, out_polys )

Returns the polygons surrounding the specified edge.

const LWPolID* polys;
int num_polys = edit->edgePolys(state, edge, &polys);
// do something with polys

polyPoints( state, poly, out_points )

Returns the vertices making up the specified polygon.

const LWPntID* points;
int num_points = edit->polyPoints(state, poly, &points);
// do something with points

p1 = edgePoint1( state, edge )
p2 = edgePoint2( state, edge )

Returns the points making up an edge.

edge = edgeFromPoints( state, p1, p2 )

Returns the edge between p1 and p2 if such an edge exists. Otherwise, the function returns NULL.

flags = pointFlags( state, point )
flags = edgeFlags( state, edge )
flags = polyFlags( state, polygon )

Returns the flags associated with the specified element. These are the same values as the flags fields found in the ED*Info structures.

selected_vmap = vMapSelect( state, vmap_name, vmap_type, vmap_dimension)

Selects a vertex map having the given name, type, and dimension. If the vertex map does not exist, one is created. Once a vertex map is selected, it becomes part of the state and is used in other vertex map operations. The returned selected_vmap can be used in subsequent calls to pointVSet() to make the selection process faster. 0 (NULL) is returned if the requested vertex map could not be selected.

exists = vMapExists( state, vmap_name, vmap_type)

Tests is the given vertex map name and type already exists. Returns 1 if so, else 0.

dimension = vMapGetDimension( state)

Obtains the dimension count of the state's current vertex map. A value of (0) indicates no vertex map is selected.

vMapSet( state, point_id, polygon_id, value)

Sets a mapping of a value vector and a point (optionally a vertex of a polygon). When a polygon_id is not specified, the mapping will be continuous (associated strictly with the vertex). When a polygon_id is specified, the mapping will be discontinuous (associated with a vertex in a particular polygon). An existing mapping will be overwritten with the provided value vector. Providing a value vector of 0 (NULL) will remove the mapping. The dimension of the value vector is assumed to be compatible with the currently selected vertex map. To get the value vector of a particular mapping, use the pointVPGet(), pointVEval(), and pointVGet() routines. vMapSet() shares some functionality with pntVMap() and is faster because it does not need to select the vertex map for each call. vMapSelect() must be called to select a vertex map first.

vMapSetIdeal( state, point_id, polygon_id, value)

Appropriately sets the 'ideal' mapping of a value vector with a point and polygon. If the continuous mapping is not yet set, it will be set to the given value vector. If a continuous mapping is already set and the given value vector differs from the existing one, a discontinuous mapping is added with the given value vector. If a continuous mapping exists and its value is the same as provided, then it is overwritten and any existing discontinuous mapping is removed.

vMapRename( state, new_name)

Renames the state's currently selected vertex map to the provided new_name.

vMapRemove( state)

Removes the state's currently selected vertex map. All existing mappings are removed in the process.

Point and Polygon Info

The info and scan functions use EDPointInfo and EDPolygonInfo structures to provide information about points and polygons. Modeler maintains only one of each of these. It overwrites the structure each time data for a different point or polygon is required, so if you need to keep data for multiple points or polygons, you must copy it from the structure and store it locally.

typedef struct st_EDPointInfo {
    LWPntID    pnt;
    void      *userData;
    int        layer;
    int        flags;
    double     position[3];
    float     *vmapVec;
} EDPointInfo;

pnt: The ID of the point.
userData: Your per-point data buffer, allocated by the MeshEditBegin call.
layer: The layer in which the point resides.
flags: Flags for the point. The EDDF_SELECT bit is set if the selection state of the point matches the EltOpSelect passed to the MeshEditBegin function. The EDDF_DELETE bit is set if the point has been deleted during this mesh edit.
position: The point's position.
vmapVec: The vmap values associated with the point.

typedef struct st_EDPolygonInfo
{
    LWPolID        pol;
    void          *userData;
    int            layer;
    int            flags;
    int            numPnts;
    const LWPntID *points;
    const char    *surface;
    unsigned int   type;
    int            typeFlags;
} EDPolygonInfo;

pol: The polygon ID.
userData: Your per-polygon data buffer, allocated by the MeshEditBegin call.
layer: The layer in which the polygon resides.
flags: Flags for the polygon. These include the EDPF_CCSTART and EDDF_CCEND bits for curves.
numPnts: The number of vertices in the polygon.
points: An array of point IDs for the vertices of the polygon.
surface: The polygon's surface.
type: The polygon type, which will usually be one of the following.
LWPOLTYPE_FACE - face
LWPOLTYPE_CURV - higher order curve
LWPOLTYPE_PTCH - subdivision control cage polygon
LWPOLTYPE_MBAL - metaball
LWPOLTYPE_BONE - bone
Note that the number of polygon types may be expanded by plugins or future versions of LightWave®. Do not limit functionality to particular polygon types, unless there is a very good reason to. The typeFlags value is usually a better indicator of what the polygon can be used for.
typeFlags: The flags for the polygon type. These are the LWGPTF_* flags for the polygon type as defined in lwpolygon.h

Example

The zfacing sample demonstrates OPSEL_MODIFY edits. This method of altering the selection is especially useful in CommandSequence plug-ins, so zfacing.c contains both edit and command versions of the activation function. The vidscape sample uses mesh editing to enumerate the geometry of an object before exporting it to a VideoScape format file. Many former mesh edit sample plug-ins, notably superq and spikey, have been converted to interactive mesh edit tools.