MeshDataEdit NodeHandler Classes Table of Contents


Availability  LightWave® 6.0
Component  Modeler
Header  lwmodtool.h, lwtool.h

Mesh edit tools are interactive versions of MeshDataEdit plug-ins. For users they behave like Modeler's built-in tools. You supply callbacks for drawing the tool, for creating "handles" that can be manipulated by the user, and for generating the geometry the tool creates or modifies.

Activation Function

   XCALL_( int ) MyMETool( int version, GlobalFunc *global,
      LWMeshEditTool *local, void *serverData );
The local argument to a mesh edit plug-in's activation function is an LWMeshEditTool.
   typedef struct st_LWMeshEditTool {
      LWInstance   instance;
      LWToolFuncs *tool;
      int         (*test)  (LWInstance);
      LWError     (*build) (LWInstance, MeshEditOp *);
      void        (*end)   (LWInstance, int keep);
   } LWMeshEditTool;
Set this to point to your instance data. Typically this is a structure that holds all of the data your plug-in needs to perform its function. 

A set of tool callbacks you need to define. See below.

action = test( inst )
Returns a code for the edit action that should be performed. The action can be one of the following. 

Do nothing. The edit state remains unchanged.
Reapply the operation with new settings. The build function will be called.
Keep the last operation. The end callback is called with a nonzero keep value.
Discard the last operation. The end callback is called with a keep value of 0.
Keep the last operation and begin a new one. The end callback is called with a nonzero keep value, and then the build function is called again.

The return value can also encode a memory size that will be allocated for each point and each polygon. These user memory sizes would be passed to the begin function of the MeshEditOp structure passed to MeshDataEdit plug-ins. For MeshEditTool class plug-ins, they are encoded in the value returned from test using the LWT_VMEM and LWT_PMEM macros for vertex and polygon sizes respectively.

lwerr = build( inst, edit )
Perform the tool's mesh edit operation. A tool that creates a primitive would add the points and polygons of the primitive within this callback. The edit argument points to the same MeshEditOp structure passed to MeshDataEdit plug-ins.

end( inst, keep )
Clear the state when the last edit action is completed. This can be a result of a call to test, or it can be triggered by an external action.
Tool Functions

Your plug-in fills in an LWToolFuncs structure to tell Modeler where your tool callbacks are located.

   typedef struct st_LWToolFuncs {
      void         (*done)   (LWInstance);
      void         (*draw)   (LWInstance, LWWireDrawAccess *);
      const char * (*help)   (LWInstance, LWToolEvent *);
      int          (*dirty)  (LWInstance);
      int          (*count)  (LWInstance, LWToolEvent *);
      int          (*handle) (LWInstance, LWToolEvent *, int i,
                                LWDVector pos);
      int          (*start)  (LWInstance, LWToolEvent *);
      int          (*adjust) (LWInstance, LWToolEvent *, int i);
      int          (*down)   (LWInstance, LWToolEvent *);
      void         (*move)   (LWInstance, LWToolEvent *);
      void         (*up)     (LWInstance, LWToolEvent *);
      void         (*event)  (LWInstance, int code);
      LWXPanelID   (*panel)  (LWInstance);
   } LWToolFuncs;
done( instance )
Destroy the instance. Called when the user discards the tool. 

draw( instance, draw_access )
Display a wireframe representation of the tool in a 3D viewport using the drawing functions in the LWWireDrawAccess, described below. 

helptext = help( instance, eventinfo )
Returns a text string to be displayed as a help tip for this tool. 

dcode = dirty( instance )
Returns flag bits indicating whether the wireframe or the help string need to be refreshed. The bits are combined using bitwise-or. Return 0 if nothing needs to be refreshed, or any combination of the following. 


nhandles = count( instance, eventinfo )
Returns the number of handles. A "handle" is a component of the tool's wireframe that the user can move independently. If this returns 0, then the start callback is used to set the initial handle point. 

priority = handle( instance, eventinfo, hnum, pos )
Returns the 3D location and priority of handle hnum, or 0 if the handle is currently invalid. 

hnum = start( instance, eventinfo )
Take an initial mouse-down position and return the index of the handle that should be dragged. 

hdrag = adjust( instance, eventinfo, hnum )
Drag the handle to a new location. Returns the index of the handle that should continue being dragged (typically the same as hnum). 

domouse = down( instance, eventinfo )
Process a mouse-down event. If this function returns 0, handle processing will be done instead of raw mouse event processing. 

move( instance, eventinfo )
Process a mouse-move event. This will only be called if the down function returned a nonzero value. 

up( instance, eventinfo )
Process a mouse-up event. This will only be called if the down function returned a nonzero value. 

event( instance, code )
Process a general event indicated by one of the following codes. 

The tool has been dropped. The user has clicked on an empty area of the interface, or pressed the spacebar, or selected another tool.
The user has requested that the tool return to its initial state. Numeric parameters should be reset to their default values.
The tool has been activated.

xpanel = panel( instance )
Create an LWXP_VIEW xpanel for the tool instance.
Event Information

Most of the tool functions take an LWToolEvent as an argument.

   typedef struct st_LWToolEvent {
      LWDVector posRaw, posSnap;
      LWDVector deltaRaw, deltaSnap;
      LWDVector axis;
      LWDVector ax, ay, az;
      double    pxRaw, pxSnap;
      double    pyRaw, pySnap;
      int       dx, dy;
      int       portAxis;
      int       flags;
      int       viewnumber;
   } LWToolEvent;
posRaw, posSnap
The event position in 3D space. The snap vector is the raw vector after quantizing to the nearest grid intersection in 3D.

deltaRaw, deltaSnap
The vector from the initial mouse-down event to the current event location. This is just the difference between the initial and current positions.

The event axis. All the points under the mouse location are along this axis through pos.

ax, ay, az
Screen coordinate system. ax points to the right, ay points up and az points into the screen. Movement by 1.0 along each vector corresponds to approximately one pixel of screen space movement.

pxRaw, pxSnap
pyRaw, pySnap
Parametric translation values. These are the mouse offsets converted to values in model space. They provide a method for computing abstract distance measures from left/right and up/down mouse movement roughly scaled to the magnification of the viewport..

dx, dy
Screen movement in pixels. This is the total raw mouse offset from the starting position.

The view type. 0, 1 or 2 for orthogonal views, or -1 for perspective views.

This contains flag bits assembled using bitwise-or. It can be some combination of the following. 

The action of the tool is constrained. Activated by a standard key or mouse combination.

The direction of constraint for orthogonal moves. Initially neither bit is set, but as the user moves enough to select a primary direction, one or the other will be set.
Alternate mouse button event, usually the right button.
Multiple mouse click event.

viewnumber (LW8.0+)
Each viewport available has an index ranging from 0 to 3 to make identification possible.
Draw Access

The draw callback is given an LWWireDrawAccess containing a set of drawing functions for rendering the visual representation of the tool in the interface.

   typedef struct st_LWWireDrawAccess {
      void  *data;
      void  (*moveTo) (void *, LWFVector, int);
      void  (*lineTo) (void *, LWFVector, int);
      void  (*spline) (void *, LWFVector, LWFVector, LWFVector, int);
      void  (*circle) (void *, double, int);
      int    axis;
      void  (*text)   (void *, const char *, int);
      double pxScale;
   } LWWireDrawAccess;
An opaque pointer to data used by Modeler. Pass this as the first argument to the drawing functions.

moveTo( data, pos, line_style )
Move the drawing point to the new position. Use this to set one endpoint of a line or a spline or the center of a circle. The third argument sets the line style for the drawing functions and can be one of the following. 


lineTo( data, pos, coord_type )
Draw a line segment from the current drawing point to the given position. The coordinate type can be one of the following. 

Absolute coordinates in model space.
Relative coordinates in model space. The pos argument is an offset from the current drawing point, which is the most recent position specified in a previous call to a drawing function.
Relative coordinates in screen space. A distance of 1.0 in this coordinate system corresponds to about 20 pixels. Tool handles will typically be drawn in screen space, so that they remain the same displayed size regardless of the zoom level of the view.

spline( data, LWFVector, LWFVector, LWFVector, coord_type )
Draw a curve from the current drawing point. The vectors are Bezier control points, with the current drawing point acting as the first of the required four points. When using relative coordinates, each position vector is an offset from the previous one.

circle( data, radius, coord_type )
Draw a circle centered at the current drawing point.

The view in which you're drawing. This can be 0, 1 or 2 for the x, y and z axis views, or -1 for a perspective view.

text( data, textline, justify )
Draw a single line of text. The justify argument positions the text relative to the current drawing point and can be one of the following.
The approximate size of a pixel in the current view.

In LightWave® 7.0, the text function and the pxScale field were added to LWWireDrawAccess, but LWMESHEDITTOOL_VERSION was not incremented. If your activation accepts a version of 4, use the Product Info global to determine whether these items are available.


The boxes/box4 sample is a simple example of a mesh edit tool. It's described in the Boxes tutorial. The mesh edit tool samples also include capsule, which creates a capsule shaped primitive, superq for making ellipsoidal and toroidal superquadrics, and spikeytool for adding spikes during subdivision.