iEPolyMod.h

Go to the documentation of this file.

/**********************************************************************
 *<
    FILE: iEPolyMod.h

    DESCRIPTION:   Interface for Edit Poly modifier.

    CREATED BY: Steve Anderson

    HISTORY: created March 2004

 *> Copyright (c) 2004, All Rights Reserved.
 **********************************************************************/

#pragma once

#include "iFnPub.h"
#include "mnmesh.h"
// forward declarations
class Modifier;
class IParamBlock2;
class IObjParam;

#define EPOLY_MOD_INTERFACE Interface_ID(0x405e217d, 0x49c2abc)
#define GetEPolyModInterface(cd) (EPolyMod *)(cd)->GetInterface(EPOLY_MOD_INTERFACE)

#define EPOLY_MOD13_INTERFACE Interface_ID(0x1a4cc8f2, 0x71682518)
#define GetEPolyMod13Interface(cd) (EPolyMod13 *)(cd)->GetInterface(EPOLY_MOD13_INTERFACE)

// Editable Poly Selection Levels
enum ePolyModSelLevel { EPM_SL_OBJECT, EPM_SL_VERTEX, EPM_SL_EDGE, 
    EPM_SL_BORDER, EPM_SL_FACE, EPM_SL_ELEMENT, EPM_SL_CURRENT };

// Relate EPolyMod selection levels to MNMesh selection levels:
const int meshSelLevel[] = { MNM_SL_OBJECT, MNM_SL_VERTEX, MNM_SL_EDGE, MNM_SL_EDGE,
    MNM_SL_FACE, MNM_SL_FACE, MNM_SL_CURRENT };

// Edit Poly Parameters:
enum epolyModParameters {

    epm_animation_mode,     // int - is the Edit Poly in modeling mode (0) or animation mode (1)
    epm_show_cage,          // BOOL - indicates if the Edit Poly is set to display the cage

    epm_by_vertex,          // BOOL - indicates if the Edit Poly is selecting by vertex.
    epm_ignore_backfacing,  // BOOL - indicates if the Edit Poly is ignoring backfacing when the user selects subobjects.
    epm_stack_selection,    // BOOL - indicates whether or not the Edit Poly is using the subobject selection from the stack below it.

    epm_ss_use,             // BOOL - Is the Edit Poly using soft selection?
    epm_ss_edist_use,       // BOOL - Is the Edit Poly soft selection using edge distances or not?
    epm_ss_edist,           // int - How many edges do we traverse in determining soft selection?  (Ignored if epm_ss_edist_use is set to false.)
    epm_ss_affect_back,     // BOOL - Should soft selection affect backfacing?
    epm_ss_falloff,         // float - soft selection falloff value
    epm_ss_pinch,           // float - soft selection pinch value
    epm_ss_bubble,          // float - soft selection bubble value

    epm_current_operation,  // int - indicates current operation, which should be one of the epolyModButtonOp enums.

    epm_world_to_object_transform, // Matrix3 - Worldspace to common Objectspace transform.  Used in combination with the local mod context tms, this can give us relative WS-to-OS transforms for each modifier instance.  See Edit Poly source for examples of use.

    epm_constrain_type,     // int - Represents the current vertex constraints.  0 for no constraints, 1 for constrain-to-edge, 2 for constrain-to-face, 3 for constrain-to-normal.

    epm_split,              // BOOL - indicates whether Cut and Slice (ep_op_cut, ep_op_slice, ep_op_slice_face) operations should split the mesh, or merely refine it.

    epm_ms_smoothness,      // float - Smoothness parameter for MeshSmooth operation (ep_op_meshsmooth)
    epm_ms_sep_smooth,      // BOOL - Separate-by-smoothing-groups parameter for MeshSmooth operation (ep_op_meshsmooth)
    epm_ms_sep_mat,         // BOOL - Separate-by-materials parameter for MeshSmooth operation (ep_op_meshsmooth)

    epm_tess_type,          // int - Type of Tessellation (ep_op_tessellate) - 0 for 
    epm_tess_tension,       // float - tension parameter for Tessellation operation (ep_op_tessellate)

    epm_bridge_taper,       // float - Taper parameter for Bridge operation (ep_op_bridge_border, ep_op_bridge_polygon)
    epm_bridge_bias,        // float - Bias parameter for Bridge operation (ep_op_bridge_border, ep_op_bridge_polygon)

    epm_align_type,         // int - whether to align to view (0) or construction plane (1) in future uses of ep_op_align
    epm_align_plane_normal, // Point3 - describes the plane normal currently used for alignment.
    epm_align_plane_offset, // float - describes the plane offset currently used for alignment.  (The normal and offset together describe a plane.)

    epm_delete_isolated_verts,  // BOOL - Indicates whether the Edit Poly deletes freshly isolated vertices when deleting faces.

    epm_weld_vertex_threshold,  // float - The threshold used when welding selected vertices (ep_op_weld_vertex)

    epm_chamfer_vertex,         // float - the "amount" parameter for the Chamfer Vertex operation (ep_op_chamfer_vertex)

    epm_extrude_vertex_width,   // float - the width of the extrusion for the Extrude Vertex operation (ep_op_extrude_vertex)
    epm_extrude_vertex_height,  // float - the height of the extrusion for the Extrude Vertex operation (ep_op_extrude_vertex)

    epm_connect_edge_segments,  // int - the number of segments to use when connecting edges (ep_op_conect_edge)

    epm_weld_edge_threshold,    // float - The threshold used when welding selected edges (ep_op_weld_edge)

    epm_extrude_edge_height,    // float - the height of the extrusion for the Extrude Edge operation (ep_op_extrude_edge)
    epm_extrude_edge_width,     // float - the width of the extrusion for the Extrude Edge operation (ep_op_extrude_edge)

    epm_chamfer_edge,           // float - the "amount" parameter for the Chamfer Edge operation (ep_op_chamfer_edge)

    epm_extrude_face_type,      // int - indicates the type of face extrusion - 0 for Group Normals, 1 for Local Normals, 2 for By Polygon (ep_op_extrude_face)
    epm_extrude_face_height,    // float - indicates the height of the face extrusion (ep_op_extrude_face)

    epm_bevel_type,             // int - indicates the type of face extrusion used in beveling - 0 for Group Normals, 1 for Local Normals, 2 for By Polygon (ep_op_bevel)
    epm_bevel_height,           // float - height of the face bevel (ep_op_bevel)
    epm_bevel_outline,          // float - "outline" amount (amount to move vertices in or out) in the Bevel operation (ep_op_bevel)

    epm_inset_type,             // int - indicates the type of face extrusion used in insetting - 0 for Group Normals, 1 for Local Normals, 2 for By Polygon (ep_op_inset)
    epm_inset,                  // float - the amount of the inset (ep_op_inset)

    epm_outline,                // float - the amount of outlining (ep_op_outline)

    epm_hinge_angle,            // float - the angle to use in Hinge from Edge (ep_op_hinge_from_edge)
    epm_hinge_base,             // Point3 - the base of the hinge (ep_op_hinge_from_edge)
    epm_hinge_dir,              // Point3 - the direction of the hinge - combine with epm_hinge_base to get a complete ray for the hinge (ep_op_hinge_from_edge)
    epm_hinge_segments,         // int - the number of segments to use on the sides of the Hinge from Edge extrusion (ep_op_hinge_from_edge)

    epm_extrude_spline_node,        // INode - the node of the spline to use in Extrude along Spline (ep_op_extrude_along_spline)
    epm_extrude_spline_segments,    // int - the number of segments in Extrude along Spline (ep_op_extrude_along_spline)
    epm_extrude_spline_taper,       // float - the amount of tapering to use in Extrude along Spline (ep_op_extrude_along_spline)
    epm_extrude_spline_taper_curve, // float - the taper curve for Extrude along Spline (ep_op_extrude_along_spline)
    epm_extrude_spline_twist,       // float - the amount of twist (in radians) for Extrude along Spline (ep_op_extrude_along_spline)
    epm_extrude_spline_rotation,    // float - the rotation (in radians) around the face normal for Extrude along Spline (ep_op_extrude_along_spline)
    epm_extrude_spline_align,       // BOOL - whether or not to try to align the extrusion spline to match the face normal (ep_op_extrude_along_spline)

    epm_autosmooth_threshold,   // float - the threshold for autosmoothing across edges, in radians (ep_op_autosmooth)
    epm_smooth_group_set,       // DWORD cast as an int - the set of smoothing groups to set (ep_op_smooth)
    epm_smooth_group_clear,     // DWORD cast as an int - the set of smoothing groups to clear (ep_op_smooth)

    epm_material,               // int - the material ID to set on selected faces (ep_op_set_material)

    epm_material_selby,         // int - the material ID to select faces by (ep_op_select_by_material)
    epm_material_selby_clear,   // BOOL - whether or not to clear the previous selection before selecting by material (ep_op_select_by_material)

    epm_smoother_selby,         // DWORD cast as an int - the set of smoothing groups to select faces by (ep_op_select_by_smooth)
    epm_smoother_selby_clear,   // BOOL - whether or not to clear the previous selection before selecting faces by smoothing group (ep_op_select_by_smooth)

    epm_clone_to_element,       // BOOL - whether to clone to an element or to a separate object.

    epm_bridge_segments,        // int - the number of segments for bridge operations
    epm_bridge_smooth_thresh,   // float - the smoothing threshold for successive bridge columns (in radians)
    epm_bridge_target_1,        // int - the first edge or face we're bridging between, in 1-based indexing.  (Value of 0 indicates not set yet.)
    epm_bridge_target_2,        // int - the second edge or face we're bridging between, in 1-based indexing.  (Value of 0 indicates not set yet.)
    epm_bridge_twist_1,         // int - the Twist amount for the first end of the bridge.
    epm_bridge_twist_2,         // int - the Twist amount for the second end of the bridge
    epm_bridge_selected,        // BOOL - false indicates we should bridge between the specific targets given in epm_bridge_target_1 and _2, true indicates we should bridge selected borders or polgyons.

    epm_preserve_maps,          // BOOL - Indicates whether map values should be "preserved" in geometric deformations such as subobject transforms.

    epm_relax_amount,           // float - the relax Amount parameter - range of 0 (no relaxing) to 1 (maximum relaxing), default of .5
    epm_relax_iters,            // int - the number of iterations of the relax algorithm to apply.
    epm_relax_hold_boundary,    // BOOL - Indicates whether or not to fix boundary points in place when relaxing
    epm_relax_hold_outer,       // BOOL - Indicates whether or not to fix "outer" points in place when relaxing.  (See the MNMeshUtilities::Relax declaration in MNMesh.h for further explanation.)

    epm_select_by_angle,        // BOOL - Indicates whether Polygon selections should be expanded depending on edge angles.
    epm_select_angle,           // float - Indicates the maximum angle used in expanding polygon selections.  (Ignored if epm_select_by_angle is false.)

    // Paint tools
    epm_ss_lock,
    epm_paintsel_value, epm_paintsel_size, epm_paintsel_strength,
    epm_paintdeform_value, epm_paintdeform_size, epm_paintdeform_strength,
    epm_paintdeform_axis,

    epm_reserved1,                  // obsolete -- SEE the #define epm_edge_chamfer_segments epm_reserved1
                                    // beneath this enum!
    epm_reserved2,                  // obsolete
    epm_reserved3,                  // obsolete
    epm_reserved4,                  // obsolete
    epm_reserved5,                  // obsolete
    
    epm_connect_edge_pinch,         // float    - distance between new edges created when connecting edges
    epm_connect_edge_slide,         // float    - start position for edge connection
    epm_loop_edge_sel,              // int      - loop spinner value
    epm_ring_edge_sel,              // int      - ring spinner value
    epm_remove_edge_ctrl,           // BOOOL    - is control key pressed when removing edges ? 
    epm_cage_color,                 // Point3   - the user supplied cage color 
    epm_selected_cage_color,        // Point3   - the user supplied cage color for selected objects
    epm_cage_color_changed,         // int      - has the cage color been changed 
    epm_selected_cage_color_changed,// int      - has the selected cage color been changed 
    epm_chamfer_vertex_open,        // BOOL     - is a vertex chamfer creating a hole ? 
    epm_chamfer_edge_open,          // BOOL     - is an edge chamfer creating a hole ? 
    epm_bridge_adjacent,            // float    - the angle limit used for bridging adjacent edges 
    epm_bridge_reverse_triangle,    // BOOL     - is a triangle to be reversed when bridging edges ?
    epm_break_vertex_distance,      // float    - the distance used for opening vertices

    epm_paintsel_mode,
    epm_paintdeform_mode,

    epm_select_mode,                // BOOL     -  the select mode that we are in, none, sub object, or multi.

    // new for 9.5
    //epm_edge_chamfer_segments  // int - the number of new edges to create per selected edge (ep_edge_chamfer_segments)
                                 // SEE #define BELOW!
};
// In order to preserve forward file IO compatibility with Makalu (Max 9), the new chamfer parameter
// for Velveeta (Max 9.5) has to take on the value of epm_reserved1. See the implementation of
// PolyOperation::LoadBasics (and PolyOperation::SaveBasics).
#define epm_edge_chamfer_segments epm_reserved1

// Edit Poly Operations:
enum epolyModButtonOp { ep_op_null,
    ep_op_hide_vertex, ep_op_hide_face,
    ep_op_unhide_vertex, ep_op_unhide_face,
    ep_op_hide_unsel_vertex, ep_op_hide_unsel_face,
    ep_op_ns_copy, ep_op_ns_paste, ep_op_cap,
    ep_op_delete_vertex, ep_op_delete_face, ep_op_detach_vertex, ep_op_detach_face,
    ep_op_split, ep_op_break, ep_op_collapse_vertex, ep_op_collapse_edge,
    ep_op_collapse_face, ep_op_reset_plane, ep_op_slice, ep_op_slice_face,
    ep_op_weld_vertex, ep_op_weld_edge, ep_op_create_shape, ep_op_make_planar, ep_op_remove_iso_verts,
    ep_op_meshsmooth, ep_op_tessellate, ep_op_retriangulate,
    ep_op_flip_face, ep_op_flip_element, ep_op_bevel, ep_op_chamfer_vertex,
    ep_op_chamfer_edge, ep_op_cut,
    ep_op_sel_grow, ep_op_sel_shrink, ep_op_inset, ep_op_extrude_vertex,
    ep_op_extrude_edge, ep_op_extrude_face,
    ep_op_extrude_along_spline, ep_op_connect_edge, ep_op_connect_vertex,
    ep_op_hinge_from_edge, ep_op_select_ring, ep_op_select_loop,
    ep_op_remove_iso_map_verts, ep_op_remove_vertex, ep_op_remove_edge, ep_op_outline,
    ep_op_toggle_shaded_faces,
    ep_op_transform, ep_op_delete_edge, ep_op_unused,
    ep_op_create, ep_op_align,
    ep_op_attach, ep_op_target_weld_vertex, ep_op_target_weld_edge,
    ep_op_edit_triangulation, ep_op_create_edge,
    ep_op_clone_vertex, ep_op_clone_edge, ep_op_clone_face,
    ep_op_insert_vertex_edge, ep_op_insert_vertex_face,
    ep_op_autosmooth, ep_op_smooth, ep_op_set_material,
    ep_op_select_by_smooth, ep_op_select_by_material, ep_op_get_stack_selection,
    ep_op_bridge_border, ep_op_bridge_polygon, ep_op_make_planar_x, ep_op_make_planar_y,
    ep_op_make_planar_z, ep_op_turn_edge, ep_op_relax, ep_op_paint_deform,
    ep_op_bridge_edge, ep_op_preserve_uv_settings
};

// Edit Poly Command modes:
enum epolyModCommandMode { ep_mode_create_vertex, ep_mode_create_edge,
    ep_mode_create_face, ep_mode_divide_edge, ep_mode_divide_face,
    ep_mode_extrude_vertex, ep_mode_extrude_edge, ep_mode_extrude_face,
    ep_mode_chamfer_vertex, ep_mode_chamfer_edge, ep_mode_bevel,
    ep_mode_sliceplane, ep_mode_cut, ep_mode_weld, ep_mode_edit_tri,
    ep_mode_inset_face, ep_mode_quickslice, ep_mode_hinge_from_edge,
    ep_mode_pick_hinge, ep_mode_outline, ep_mode_bridge_border,
    ep_mode_bridge_polygon, ep_mode_pick_bridge_1, ep_mode_pick_bridge_2,
    ep_mode_turn_edge,  ep_mode_bridge_edge,
        ep_mode_edit_ss
};

// Edit Poly Pick modes:
enum epolyModPickMode { ep_mode_attach, ep_mode_pick_shape };

// Edit Poly methods - for use in function-publishing (for Maxscript access).
enum epolyModMethods {
    epmod_get_sel_level, epmod_get_mn_sel_level, epmod_set_sel_level,
    epmod_get_operation, epmod_set_operation, epmod_local_data_changed,
    epmod_refresh_screen, epmod_commit, epmod_commit_unless_animating,
    epmod_commit_and_repeat, epmod_cancel_operation, epmod_convert_selection, epmod_get_selection,
    epmod_set_selection, epmod_select, epmod_set_primary_node,
    epmod_toggle_command_mode, epmod_enter_command_mode, epmod_enter_pick_mode,
    epmod_get_command_mode, epmod_get_pick_mode,
    epmod_popup_dialog, epmod_button_op, epmod_repeat_last, epmod_in_slice_mode,
    epmod_reset_slice_plane, epmod_get_slice_plane_tm, epmod_get_slice_plane, epmod_set_slice_plane,
    epmod_create_vertex, epmod_create_face, epmod_create_edge, epmod_set_diagonal,
    epmod_cut, epmod_target_weld_vertex, epmod_target_weld_edge, epmod_attach_node,
    epmod_attach_nodes, epmod_detach_to_object, epmod_create_shape,
    epmod_bridge_borders, epmod_bridge_polygons, epmod_set_bridge_node, epmod_get_bridge_node,
    epmod_ready_to_bridge_selected,epmod_get_preserve_map, epmod_set_preserve_map,
    epmod_turn_diagonal,

    // Access to information about mesh:
    epmod_get_num_vertices, epmod_get_vertex, epmod_get_vertex_face_count, epmod_get_vertex_face,
    epmod_get_vertex_edge_count, epmod_get_vertex_edge, epmod_get_num_edges, epmod_get_edge_vertex,
    epmod_get_edge_face, epmod_get_num_faces, epmod_get_face_degree, epmod_get_face_vertex,
    epmod_get_face_edge, epmod_get_face_diagonal, epmod_get_face_material, epmod_get_face_smoothing_group,
    epmod_get_num_map_channels, epmod_get_map_channel_active,
    epmod_get_num_map_vertices, epmod_get_map_vertex, epmod_get_map_face_vertex,

    epmod_get_face_normal, epmod_get_face_center, epmod_get_face_area, epmod_get_open_edges,
    epmod_get_verts_by_flag, epmod_get_edges_by_flag, epmod_get_faces_by_flag,
    epmod_set_vertex_flags, epmod_set_edge_flags, epmod_set_face_flags,
    epmod_get_vertex_flags, epmod_get_edge_flags, epmod_get_face_flags,
    epmod_get_verts_using_edge, epmod_get_edges_using_vert, epmod_get_faces_using_edge,
    epmod_get_elements_using_face, epmod_get_faces_using_vert, epmod_get_verts_using_face,
    epmod_set_vert,

    epmod_move_selection, epmod_move_slicer, epmod_rotate_selection, epmod_rotate_slicer,
    epmod_scale_selection, epmod_scale_slicer,

    epmod_list_operations, epmod_set_hinge_edge, epmod_get_hinge_edge,
    epmod_bridge_edges,

    epmod_in_slice, epmod_show_operation_dialog, epmod_showing_operation_dialog, 
    epmod_close_operation_dialog, epmod_get_primary_node, epmod_get_node_tm, epmod_set_cut_end, 
    epmod_get_last_cut_end, epmod_clear_last_cut_end, epmod_cut_cancel, epmod_divide_edge, 
    epmod_divide_face,epmod_ring_sel, epmod_loop_sel,epmod_convert_selection_to_border,
    epmod_paintdeform_commit, epmod_paintdeform_cancel,

    epmod_matid_floater,epmod_matid_floatervisible,
    epmod_smgrp_floater,epmod_smgrp_floatervisible

};



#pragma warning(push)
#pragma warning(disable:4100)
class EPolyMod : public FPMixinInterface {
public:
    #pragma warning(push)
    #pragma warning(disable:4238)
    BEGIN_FUNCTION_MAP
        FN_0(epmod_get_sel_level, TYPE_ENUM, GetEPolySelLevel);
        FN_0(epmod_get_mn_sel_level, TYPE_ENUM, GetMNSelLevel);
        VFN_1(epmod_set_sel_level, SetEPolySelLevel, TYPE_ENUM);

        FN_3(epmod_convert_selection, TYPE_INT, EpModConvertSelection, TYPE_ENUM, TYPE_ENUM, TYPE_bool);

        FN_0(epmod_get_operation, TYPE_ENUM, GetPolyOperationID);
        VFN_1(epmod_set_operation, EpModSetOperation, TYPE_ENUM);
        VFN_1(epmod_popup_dialog, EpModPopupDialog, TYPE_ENUM);
        VFN_1(epmod_button_op, EpModButtonOp, TYPE_ENUM);
        VFN_0(epmod_repeat_last, EpModRepeatLast);

        VFNT_0(epmod_commit, EpModCommit);
        VFNT_0(epmod_commit_unless_animating, EpModCommitUnlessAnimating);
        VFNT_0(epmod_commit_and_repeat, EpModCommitAndRepeat);
        VFN_0(epmod_cancel_operation, EpModCancel);

        FN_2(epmod_get_selection, TYPE_BITARRAY, EpModGetSelection, TYPE_ENUM, TYPE_INODE);
        FN_3(epmod_set_selection, TYPE_bool, EpModSetSelection, TYPE_ENUM, TYPE_BITARRAY_BR, TYPE_INODE);
        FN_5(epmod_select, TYPE_bool, EpModSelect, TYPE_ENUM, TYPE_BITARRAY_BR, TYPE_bool, TYPE_bool, TYPE_INODE);

        VFN_1(epmod_set_primary_node, EpModSetPrimaryNode, TYPE_INODE);

        VFN_1(epmod_toggle_command_mode, EpModToggleCommandMode, TYPE_ENUM);
        VFN_1(epmod_enter_command_mode, EpModEnterCommandMode, TYPE_ENUM);
        FN_0(epmod_get_command_mode, TYPE_ENUM, EpModGetCommandMode);
        VFN_1(epmod_enter_pick_mode, EpModEnterPickMode, TYPE_ENUM);
        FN_0(epmod_get_pick_mode, TYPE_ENUM, EpModGetPickMode);

        // Transforms:
        VFNT_4(epmod_move_selection, EpModMoveSelection, TYPE_POINT3_BR, TYPE_MATRIX3_BR, TYPE_MATRIX3_BR, TYPE_BOOL);
        VFNT_4(epmod_rotate_selection, EpModRotateSelection, TYPE_QUAT_BR, TYPE_MATRIX3_BR, TYPE_MATRIX3_BR, TYPE_BOOL);
        VFNT_4(epmod_scale_selection, EpModScaleSelection, TYPE_POINT3_BR, TYPE_MATRIX3_BR, TYPE_MATRIX3_BR, TYPE_BOOL);

        VFNT_3(epmod_move_slicer, EpModMoveSlicePlane, TYPE_POINT3_BR, TYPE_MATRIX3_BR, TYPE_MATRIX3_BR);
        VFNT_4(epmod_rotate_slicer, EpModRotateSlicePlane, TYPE_QUAT_BR, TYPE_MATRIX3_BR, TYPE_MATRIX3_BR, TYPE_BOOL);
        VFNT_4(epmod_scale_slicer, EpModScaleSlicePlane, TYPE_POINT3_BR, TYPE_MATRIX3_BR, TYPE_MATRIX3_BR, TYPE_BOOL);

        // Access to slice plane:
        FN_0(epmod_in_slice_mode, TYPE_bool, EpInSliceMode);
        VFN_0(epmod_reset_slice_plane, EpResetSlicePlane);
        FNT_0(epmod_get_slice_plane_tm, TYPE_MATRIX3_BV, EpGetSlicePlaneTM);
        VFNT_2(epmod_get_slice_plane, EpGetSlicePlane, TYPE_POINT3_BR, TYPE_POINT3_BR);
        VFNT_2(epmod_set_slice_plane, EpSetSlicePlane, TYPE_POINT3_BR, TYPE_POINT3_BR);

        FN_2(epmod_create_vertex, TYPE_INDEX, EpModCreateVertex, TYPE_POINT3, TYPE_INODE);
        FN_2(epmod_create_face, TYPE_INDEX, EpModCreateFace, TYPE_INDEX_TAB, TYPE_INODE);
        FN_3(epmod_create_edge, TYPE_INDEX, EpModCreateEdge, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        VFN_3(epmod_set_diagonal, EpModSetDiagonal, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        VFN_5(epmod_cut, EpModCut, TYPE_ENUM, TYPE_INDEX, TYPE_POINT3, TYPE_POINT3, TYPE_INODE);
        VFN_3(epmod_target_weld_vertex, EpModWeldVerts, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        VFN_3(epmod_target_weld_edge, EpModWeldEdges, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);

        VFNT_2(epmod_attach_node, EpModAttach, TYPE_INODE, TYPE_INODE);
        VFNT_2(epmod_attach_nodes, EpModMultiAttach, TYPE_INODE_TAB_BR, TYPE_INODE);

        VFNT_1(epmod_detach_to_object, EpModDetachToObject, TYPE_TSTR_BR);
        VFNT_1(epmod_create_shape, EpModCreateShape, TYPE_TSTR_BR);

        VFN_3(epmod_set_hinge_edge, EpModSetHingeEdge, TYPE_INDEX, TYPE_MATRIX3, TYPE_INODE);
        FN_1 (epmod_get_hinge_edge, TYPE_INDEX, EpModGetHingeEdge, TYPE_INODE);
        VFN_3(epmod_bridge_borders, EpModBridgeBorders, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        VFN_3(epmod_bridge_polygons, EpModBridgePolygons, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        FN_0(epmod_get_bridge_node, TYPE_INODE, EpModGetBridgeNode);
        VFN_1(epmod_set_bridge_node, EpModSetBridgeNode, TYPE_INODE);
        FN_0(epmod_ready_to_bridge_selected, TYPE_bool, EpModReadyToBridgeSelected);

        FN_1(epmod_get_preserve_map, TYPE_bool, EpModGetPreserveMap, TYPE_INT);
        VFN_2(epmod_set_preserve_map, EpModSetPreserveMap, TYPE_INT, TYPE_bool);

        //VFN_2(epmod_turn_edge, EpModTurnEdge, TYPE_INDEX, TYPE_INODE);
        VFN_3(epmod_turn_diagonal, EpModTurnDiagonal, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);

        // Mesh access methods:
        FN_1 (epmod_get_num_vertices, TYPE_INT, EpMeshGetNumVertices, TYPE_INODE);
        FN_2 (epmod_get_vertex, TYPE_POINT3_BV, EpMeshGetVertex, TYPE_INDEX, TYPE_INODE);
        FN_2 (epmod_get_vertex_face_count, TYPE_INT, EpMeshGetVertexFaceCount, TYPE_INDEX, TYPE_INODE);
        FN_3 (epmod_get_vertex_face, TYPE_INDEX, EpMeshGetVertexFace, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        FN_2 (epmod_get_vertex_edge_count, TYPE_INT, EpMeshGetVertexEdgeCount, TYPE_INDEX, TYPE_INODE);
        FN_3 (epmod_get_vertex_edge, TYPE_INDEX, EpMeshGetVertexEdge, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);

        FN_1 (epmod_get_num_edges, TYPE_INT, EpMeshGetNumEdges, TYPE_INODE);
        FN_3 (epmod_get_edge_vertex, TYPE_INDEX, EpMeshGetEdgeVertex, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        FN_3 (epmod_get_edge_face, TYPE_INDEX, EpMeshGetEdgeFace, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);

        FN_1 (epmod_get_num_faces, TYPE_INT, EpMeshGetNumFaces, TYPE_INODE);
        FN_2 (epmod_get_face_degree, TYPE_INT, EpMeshGetFaceDegree, TYPE_INDEX, TYPE_INODE);
        FN_3 (epmod_get_face_vertex, TYPE_INDEX, EpMeshGetFaceVertex, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        FN_3 (epmod_get_face_edge, TYPE_INDEX, EpMeshGetFaceEdge, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        FN_4 (epmod_get_face_diagonal, TYPE_INDEX, EpMeshGetFaceDiagonal, TYPE_INDEX, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        FN_2 (epmod_get_face_material, TYPE_INDEX, EpMeshGetFaceMaterial, TYPE_INDEX, TYPE_INODE);
        FN_2 (epmod_get_face_smoothing_group, TYPE_DWORD, EpMeshGetFaceSmoothingGroup, TYPE_INDEX, TYPE_INODE);

        FN_1 (epmod_get_num_map_channels, TYPE_INT, EpMeshGetNumMapChannels, TYPE_INODE);
        FN_2 (epmod_get_map_channel_active, TYPE_bool, EpMeshGetMapChannelActive, TYPE_INT, TYPE_INODE);
        FN_2 (epmod_get_num_map_vertices, TYPE_INT, EpMeshGetNumMapVertices, TYPE_INT, TYPE_INODE);
        FN_3 (epmod_get_map_vertex, TYPE_POINT3_BV, EpMeshGetMapVertex, TYPE_INT, TYPE_INDEX, TYPE_INODE);
        FN_4 (epmod_get_map_face_vertex, TYPE_INDEX, EpMeshGetMapFaceVertex, TYPE_INT, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);

        VFN_1 (epmod_list_operations, EpModListOperations, TYPE_INODE);

        VFN_1 (epmod_local_data_changed, EpModLocalDataChanged, TYPE_DWORD);
        VFN_0 (epmod_refresh_screen, EpModRefreshScreen);
        FN_0 (epmod_in_slice, TYPE_bool, EpInSlice);
        FN_0 (epmod_show_operation_dialog, TYPE_bool, EpModShowOperationDialog);
        FN_0 (epmod_showing_operation_dialog, TYPE_bool, EpModShowingOperationDialog);
        VFN_0 (epmod_close_operation_dialog, EpModCloseOperationDialog);
        FN_0(epmod_get_primary_node, TYPE_INODE, EpModGetPrimaryNode);
        FNT_1(epmod_get_node_tm, TYPE_MATRIX3_BV, EpModGetNodeTM_FPS, TYPE_INODE);
        VFN_2(epmod_set_cut_end, EpModSetCutEnd, TYPE_POINT3, TYPE_INODE);
        FN_0 (epmod_get_last_cut_end, TYPE_INDEX, EpModGetLastCutEnd);
        VFN_0 (epmod_clear_last_cut_end, EpModClearLastCutEnd);
        VFN_1 (epmod_cut_cancel, EpModCutCancel, TYPE_INODE);
        VFN_3 (epmod_divide_edge, EpModDivideEdge, TYPE_INDEX, TYPE_FLOAT, TYPE_INODE);
        VFN_3 (epmod_divide_face, EpModDivideFace, TYPE_INDEX, TYPE_FLOAT_TAB, TYPE_INODE);

        //Bridge methods introduced in Max 8 - (Moved from EPolyMod8 to here)
        VFN_3(epmod_bridge_edges, EpModBridgeEdges, TYPE_INDEX, TYPE_INDEX, TYPE_INODE);
        VFN_3(epmod_ring_sel, EpModSetRingShift, TYPE_INT, TYPE_bool, TYPE_bool);
        VFN_3(epmod_loop_sel, EpModSetLoopShift, TYPE_INT, TYPE_bool, TYPE_bool);
        FN_2(epmod_convert_selection_to_border, TYPE_INT, EpModConvertSelectionToBorder, TYPE_ENUM, TYPE_ENUM);
        VFN_0(epmod_paintdeform_commit,EpModPaintDeformCommit);
        VFN_0(epmod_paintdeform_cancel,EpModPaintDeformCancel);

        //Functionality added to match editable poly - (Added in Max 9)
        FN_2 ( epmod_get_face_normal, TYPE_POINT3_BV, EPMeshGetFaceNormal, TYPE_INDEX, TYPE_INODE );
        FN_2 ( epmod_get_face_center, TYPE_POINT3_BV, EPMeshGetFaceCenter, TYPE_INDEX, TYPE_INODE );
        FN_2 ( epmod_get_face_area, TYPE_FLOAT, EPMeshGetFaceArea, TYPE_INDEX, TYPE_INODE );
        FN_1 ( epmod_get_open_edges, TYPE_BITARRAY, EPMeshGetOpenEdges, TYPE_INODE );
        FN_4 ( epmod_get_verts_by_flag, TYPE_bool, EPMeshGetVertsByFlag, TYPE_BITARRAY_BR, TYPE_DWORD, TYPE_DWORD, TYPE_INODE );
        FN_4 ( epmod_get_edges_by_flag, TYPE_bool, EPMeshGetEdgesByFlag, TYPE_BITARRAY_BR, TYPE_DWORD, TYPE_DWORD, TYPE_INODE );
        FN_4 ( epmod_get_faces_by_flag, TYPE_bool, EPMeshGetFacesByFlag, TYPE_BITARRAY_BR, TYPE_DWORD, TYPE_DWORD, TYPE_INODE );
        VFN_5 ( epmod_set_vertex_flags, EPMeshSetVertexFlags, TYPE_BITARRAY_BR, TYPE_DWORD, TYPE_DWORD, TYPE_bool, TYPE_INODE );
        VFN_5 ( epmod_set_edge_flags, EPMeshSetEdgeFlags, TYPE_BITARRAY_BR, TYPE_DWORD, TYPE_DWORD, TYPE_bool, TYPE_INODE );
        VFN_5 ( epmod_set_face_flags, EPMeshSetFaceFlags, TYPE_BITARRAY_BR, TYPE_DWORD, TYPE_DWORD, TYPE_bool, TYPE_INODE );
        FN_2 ( epmod_get_vertex_flags, TYPE_INT, EPMeshGetVertexFlags, TYPE_INDEX, TYPE_INODE );
        FN_2 ( epmod_get_edge_flags, TYPE_INT, EPMeshGetEdgeFlags, TYPE_INDEX, TYPE_INODE );
        FN_2 ( epmod_get_face_flags, TYPE_INT, EPMeshGetFaceFlags, TYPE_INDEX, TYPE_INODE );
        VFN_3 ( epmod_get_verts_using_edge, EPMeshGetVertsUsingEdge, TYPE_BITARRAY_BR, TYPE_BITARRAY_BR, TYPE_INODE );
        VFN_3 ( epmod_get_edges_using_vert, EPMeshGetEdgesUsingVert, TYPE_BITARRAY_BR, TYPE_BITARRAY_BR, TYPE_INODE );
        VFN_3 ( epmod_get_faces_using_edge, EPMeshGetFacesUsingEdge, TYPE_BITARRAY_BR, TYPE_BITARRAY_BR, TYPE_INODE );
        VFN_4 ( epmod_get_elements_using_face, EPMeshGetElementsUsingFace, TYPE_BITARRAY_BR, TYPE_BITARRAY_BR, TYPE_BITARRAY_BR, TYPE_INODE );
        VFN_3 ( epmod_get_faces_using_vert, EPMeshGetFacesUsingVert, TYPE_BITARRAY_BR, TYPE_BITARRAY_BR, TYPE_INODE );
        VFN_3 ( epmod_get_verts_using_face, EPMeshGetVertsUsingFace, TYPE_BITARRAY_BR, TYPE_BITARRAY_BR, TYPE_INODE );
        VFN_3 ( epmod_set_vert, EPMeshSetVert, TYPE_BITARRAY_BR, TYPE_POINT3_BR, TYPE_INODE );

        VFN_0(epmod_smgrp_floater, SmGrpFloater);
        FN_0(epmod_smgrp_floatervisible,TYPE_BOOL, SmGrpFloaterVisible);

        VFN_0(epmod_matid_floater, MatIDFloater);
        FN_0(epmod_matid_floatervisible,TYPE_BOOL, MatIDFloaterVisible);

    END_FUNCTION_MAP
    #pragma warning(pop)

    FPInterfaceDesc *GetDesc ();

    virtual int GetEPolySelLevel()=0;

    virtual int GetMNSelLevel()=0;

    virtual void SetEPolySelLevel (int sl)=0;

    virtual int EpModConvertSelection (int epSelLevelFrom, int epSelLevelTo, bool requireAll) { return 0; }

    virtual int GetPolyOperationID () { return ep_op_null; }

    virtual IParamBlock2 *getParamBlock () { return NULL; }

    virtual MapBitArray GetPreserveMapSettings () const { return MapBitArray(true, false); }

    virtual void SetPreserveMapSettings (const MapBitArray & mapSettings) { }

    virtual void EpModSetPreserveMap (int mapChannel, bool preserve) { }

    virtual bool EpModGetPreserveMap (int mapChannel) { return (mapChannel>0); }

    virtual void InvalidateDistanceCache () { }

    virtual void InvalidateSoftSelectionCache () { }

    virtual void EpModSetOperation (int opcode) { }

    virtual void EpModPopupDialog (int opcode) { EpModSetOperation (opcode); EpModShowOperationDialog(); }

    virtual void EpModButtonOp (int opcode) { }

    virtual void EpModLocalDataChanged (DWORD parts) { }

    virtual void EpModRefreshScreen () { }

    virtual void EpModCommitUnlessAnimating (TimeValue t) { }

    virtual void EpModCommit (TimeValue t) { }

    virtual void EpModCommitAndRepeat (TimeValue t) { }

    virtual void EpModCancel () { }

    virtual void EpModToggleCommandMode (int mode) { }

    virtual void EpModEnterCommandMode (int mode) { }

    virtual void EpModEnterPickMode (int mode) { }

    virtual int EpModGetCommandMode () { return -1; }

    virtual int EpModGetPickMode () { return -1; }

    virtual BitArray *EpModGetSelection (int meshSelLevel, INode *pNode=NULL) { return NULL; }

    virtual bool EpModSetSelection (int meshSelLevel, BitArray & selection, INode *pNode=NULL) { return false; }

    virtual bool EpModSelect (int meshSelLevel, BitArray & selection, bool invert=false, bool select=true, INode *pNode=NULL) { return false; }

    virtual void SetHitLevelOverride (DWORD hlo) { }

    virtual void ClearHitLevelOverride () { }

    virtual DWORD GetHitLevelOverride () { return 0x0; }

    virtual DWORD CurrentHitLevel (int *selByVert=NULL) { return 0x0; }

    virtual void SetHitTestResult (bool ignoreNew=false) { }

    virtual void ClearHitTestResult () { }

    virtual void SetDisplayLevelOverride (DWORD dlo) { }

    virtual void ClearDisplayLevelOverride () { }

    virtual DWORD GetDisplayLevelOverride () { return 0x0; }

    virtual void ForceIgnoreBackfacing (bool force) { }

    virtual bool GetForceIgnoreBackfacing () { return false; }

    virtual void EpModMoveSelection (Point3 &val, Matrix3 &partm, Matrix3 &tmAxis, BOOL localOrigin, TimeValue t) { }

    virtual void EpModRotateSelection (Quat &val, Matrix3 &partm, Matrix3 &tmAxis, BOOL localOrigin, TimeValue t) { }

    virtual void EpModScaleSelection (Point3 &val, Matrix3 &partm, Matrix3 &tmAxis, BOOL localOrigin, TimeValue t) { }

    virtual void EpModMoveSlicePlane (Point3 &val, Matrix3 &partm, Matrix3 &tmAxis, TimeValue t) { }

    virtual void EpModRotateSlicePlane (Quat &val, Matrix3 &partm, Matrix3 &tmAxis, BOOL localOrigin, TimeValue t) { }

    virtual void EpModScaleSlicePlane (Point3 &val, Matrix3 &partm, Matrix3 &tmAxis, BOOL localOrigin, TimeValue t) { }

    virtual void EpResetSlicePlane () { }

    virtual Matrix3 EpGetSlicePlaneTM (TimeValue t) { return Matrix3(true); }

    virtual void EpGetSlicePlane (Point3 & planeNormal, Point3 & planeCenter, TimeValue t) { }

    virtual void EpSetSlicePlane (Point3 & planeNormal, Point3 & planeCenter, TimeValue t) { }

    virtual bool EpInSliceMode () { return false; }

    virtual bool EpInSlice () { return false; }

    virtual Modifier* GetModifier ()=0;

    virtual IObjParam* EpModGetIP() { return NULL; }

    virtual HWND GetDlgHandle(int paramPanelID) { return NULL; }

    virtual void UpdateAlignParameters (TimeValue t) { }

    virtual void UpdateCache(TimeValue t) { }

    virtual bool EpModShowOperationDialog () { return false; }

    virtual bool EpModShowingOperationDialog () { return false; }

    virtual void EpModCloseOperationDialog () { }

    virtual void EpModRepeatLast () { }

    virtual INode *EpModGetPrimaryNode () { return NULL; }

    virtual void EpModSetPrimaryNode (INode *node) { }

    virtual Matrix3 EpModGetNodeTM (TimeValue t, INode *node=NULL) { return Matrix3(1); }

    //  \brief 
    // Retrieve the transform of the Edit Poly's node.
    // This method is used by the FPS exposure to expose the EpModGetNodeTM method. The FPS 
    // exposure requires that the time parameter be the last argument.
    // 
    Matrix3 EpModGetNodeTM_FPS (INode *node=NULL, TimeValue t=0) { return EpModGetNodeTM(t,node); }

    virtual int EpModCreateVertex (Point3 p, INode *pNode=NULL) { return 0; }

    virtual int EpModCreateFace (Tab<int> *vertex, INode *pNode=NULL) { return 0; }

    virtual int EpModCreateEdge (int v1, int v2, INode *pNode=NULL) { return 0; }

    virtual void EpModSetDiagonal (int v1, int v2, INode *pNode=NULL) { }

    virtual void EpModCut (int startLevel, int startIndex, Point3 startPoint, Point3 normal, INode *pNode=NULL) { }

    virtual void EpModSetCutEnd (Point3 endPoint, INode *pNode=NULL) { }

    virtual int EpModGetLastCutEnd () { return -1; }

    virtual void EpModClearLastCutEnd () { }

    virtual void EpModCutCancel (INode *pNode=NULL) { }

    virtual void EpModDivideEdge (int edge, float prop, INode *pNode=NULL) { }

    virtual void EpModDivideFace (int face, Tab<float> *bary, INode *pNode=NULL) { }

    virtual void EpModWeldVerts (int v1, int v2, INode *pNode=NULL) { }

    virtual void EpModWeldEdges (int e1, int e2, INode *pNode=NULL) { }

    virtual void EpModAttach (INode *node, INode *pNode=NULL, TimeValue t=0) { }

    virtual void EpModMultiAttach (Tab<INode *> & nodeTab, INode *pNode=NULL, TimeValue t=0) { }

    virtual void EpModDetachToObject (MSTR & newObjectName, TimeValue t) { }

    virtual void EpModCreateShape (MSTR & shapeObjectName, TimeValue t) { }

    virtual void EpModSetHingeEdge (int edge, Matrix3 modContextTM, INode *pNode=NULL) { }

    virtual int EpModGetHingeEdge (INode *pNode) { return -1; }

    virtual void EpModBridgeBorders (int edge1, int edge2, INode *pNode=NULL) { }

    virtual void EpModBridgePolygons (int face1, int face2, INode *pNode=NULL) { }

    virtual void EpModSetBridgeNode (INode *pNode) { }

    virtual INode *EpModGetBridgeNode () { return NULL; }

    virtual bool EpModReadyToBridgeSelected () { return false; }

    virtual void EpModTurnDiagonal (int face, int diag, INode *pNode=NULL) { }


    virtual void EpModListOperations (INode *pNode=NULL) { }


    virtual MNMesh *EpModGetMesh (INode *pNode=NULL) { return NULL; }

    virtual MNMesh *EpModGetOutputMesh (INode *pNode=NULL) { return NULL; }

    virtual int EpMeshGetNumVertices (INode *pNode=NULL) { return 0; }

    virtual Point3 EpMeshGetVertex (int vertIndex, INode *pNode=NULL) { return Point3(0,0,0); }

    virtual int EpMeshGetVertexFaceCount (int vertIndex, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetVertexFace (int vertIndex, int whichFace, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetVertexEdgeCount (int vertIndex, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetVertexEdge (int vertIndex, int whichEdge, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetNumEdges (INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetEdgeVertex (int edgeIndex, int end, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetEdgeFace (int edgeIndex, int side, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetNumFaces(INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetFaceDegree (int faceIndex, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetFaceVertex (int faceIndex, int corner, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetFaceEdge (int faceIndex, int side, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetFaceDiagonal (int faceIndex, int diagonal, int end, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetFaceMaterial (int faceIndex, INode *pNode=NULL) { return 0; }

    virtual DWORD EpMeshGetFaceSmoothingGroup (int faceIndex, INode *pNode=NULL) { return 0; }

    virtual int EpMeshGetNumMapChannels (INode *pNode=NULL) { return 0; }

    virtual bool EpMeshGetMapChannelActive (int mapChannel, INode *pNode=NULL) { return false; }

    virtual int EpMeshGetNumMapVertices (int mapChannel, INode *pNode=NULL) { return 0; }

    virtual UVVert EpMeshGetMapVertex (int mapChannel, int vertIndex, INode *pNode=NULL) { return UVVert(0,0,0); }

    virtual int EpMeshGetMapFaceVertex (int mapChannel, int faceIndex, int corner, INode *pNode=NULL) { return 0; }

    //----------------------------------------------------------------------
    //Bridge related methods - removed from EPolyMod8 and joined to EPolyMod
    //----------------------------------------------------------------------


    virtual void EpModBridgeEdges (const int in_edge1,  const int in_edge2, INode *in_pNode=NULL) { }

    // \param[in] in_val: Specifies which way the current edge selection is changed. it can take the values :   
    // \li RING_UP: Moves the selection one edge up in the ring direction
    // \li LOOP_UP: Moves the selection one edge up in the loop direction
    // \li RING_DOWN: Moves the selection one edge down in the ring direction
    // \li LOOP_DOWN: Moves the selection one edge up in the loop direction
    // \li RING_UP_ADD: Adds to the selection one edge in the up ring direction 
    // \li LOOP_UP_ADD: Adds to the selection one edge in the up loop direction 
    // \li RING_DOWN_ADD: Adds to the selection one edge in the down ring direction 
    // \li LOOP_DOWN_ADD: Adds to the selection one edge in the down loop direction 
    // \li RING_UP_SUBTRACT: Subtracts to the selection one edge in the up ring direction 
    // \li LOOP_UP_SUBTRACT: Subtracts to the selection one edge in the up loop direction 
    // \li RING_DOWN_SUBTRACT: Subtracts to the selection one edge in the down ring direction 
    // \li LOOP_DOWN_SUBTRACT: Subtracts to the selection one edge in the down loop direction 
    // \param[in] in_pNode: The node to which the bridge is applied

    virtual void    EpModUpdateRingEdgeSelection ( int in_val,  INode *in_pNode=NULL)   { }


    virtual void    EpModUpdateLoopEdgeSelection ( int in_val, INode *in_pNode=NULL) { }


    virtual void    EpModSetRingShift( int in_newPos, bool in_moveOnly, bool in_add) {}


    virtual void    EpModSetLoopShift( int in_newPos, bool in_moveOnly, bool in_add) {}


    virtual int     EpModConvertSelectionToBorder (int in_epSelLevelFrom, int in_epSelLevelTo) { return 0; }


    virtual void EpModPaintDeformCommit() {}


    virtual void EpModPaintDeformCancel() {}

    //----------------------------------------------------------------------
    //Methods that previously only existed in editable poly - added in Max 9
    //----------------------------------------------------------------------

    virtual Point3      EPMeshGetFaceNormal( const int in_faceIndex, INode *in_pNode = NULL ) { return Point3(0,0,0); }
    virtual Point3      EPMeshGetFaceCenter( const int in_faceIndex, INode *in_pNode = NULL ) { return Point3(0,0,0); }
    virtual float       EPMeshGetFaceArea( const int in_faceIndex, INode *in_pNode = NULL ) { return 0.0f; }
    virtual BitArray *  EPMeshGetOpenEdges( INode *in_pNode = NULL ) { return NULL; }











    virtual bool        EPMeshGetVertsByFlag( BitArray & out_vset, const DWORD in_flags, const DWORD in_fmask=0x0, INode *in_pNode = NULL ) { return false; }
    virtual bool        EPMeshGetEdgesByFlag( BitArray & out_eset, const DWORD in_flags, const DWORD in_fmask=0x0, INode *in_pNode = NULL ) { return false; }
    virtual bool        EPMeshGetFacesByFlag( BitArray & out_fset, const DWORD in_flags, const DWORD in_fmask=0x0, INode *in_pNode = NULL ) { return false; }










    virtual void        EPMeshSetVertexFlags( BitArray & in_vset, const DWORD in_flags, DWORD in_fmask=0x0, const bool in_undoable = true, INode *in_pNode = NULL ) { return; }
    virtual void        EPMeshSetEdgeFlags( BitArray & in_eset, const DWORD in_flags, DWORD in_fmask=0x0, const bool in_undoable = true, INode *in_pNode = NULL ) { return; }
    virtual void        EPMeshSetFaceFlags( BitArray & in_fset, const DWORD in_flags, DWORD in_fmask=0x0, const bool in_undoable = true, INode *in_pNode = NULL ) { return; }









    virtual int         EPMeshGetVertexFlags( const int in_vertexIndex, INode *in_pNode = NULL ) { return 0; }
    virtual int         EPMeshGetEdgeFlags( const int in_edgeIndex, INode *in_pNode = NULL ) { return 0; }
    virtual int         EPMeshGetFaceFlags( const int in_faceIndex, INode *in_pNode = NULL ) { return 0; }
        









    virtual void        EPMeshGetVertsUsingEdge( BitArray & out_vset, const BitArray & in_eset, INode *in_pNode = NULL ) { return; }
    virtual void        EPMeshGetEdgesUsingVert( BitArray & out_eset, BitArray & in_vset, INode *in_pNode = NULL ) { return; }
    virtual void        EPMeshGetFacesUsingEdge( BitArray & out_fset, BitArray & in_eset, INode *in_pNode = NULL ) { return; }
    virtual void        EPMeshGetElementsUsingFace( BitArray & out_eset, BitArray & in_fset, BitArray & in_fenceSet, INode *in_pNode = NULL ) { return; }
    virtual void        EPMeshGetFacesUsingVert( BitArray & out_fset, BitArray & in_vset, INode *in_pNode = NULL ) { return; }
    virtual void        EPMeshGetVertsUsingFace( BitArray & out_vset, BitArray & in_fset, INode *in_pNode = NULL ) { return; }

    virtual void        EPMeshSetVert( const BitArray & in_vset, const Point3 & in_point, INode *in_pNode = NULL ) { return; }

    virtual void        SmGrpFloater() = 0;
    virtual void        MatIDFloater() = 0;
    virtual BOOL        MatIDFloaterVisible() = 0;
    virtual BOOL        SmGrpFloaterVisible() = 0;

    virtual void CloseSmGrpFloater() {}
    //  \brief Closes the Material ID Floater Dialog
    virtual void CloseMatIDFloater() {}

    virtual HWND MatIDFloaterHWND() { return NULL; }

    virtual HWND SmGrpFloaterHWND() { return NULL; }
};

// Controls whether or not "inherently" nonanimatable operations are available in Animation mode.
#define EDIT_POLY_DISABLE_IN_ANIMATE

class EPolyManipulatorGrip_Imp;
class EPolyMod13 : public EPolyMod
{

    friend class EPolyManipulatorGrip_Imp;

public:
    //  \param[in] pNode - The node that is used by the modifier.
    virtual void EPMeshStartSetVertices(INode* pNode) { return; }

    //  calls to EPMeshStartSetVertices and EPMeshEndSetVertices.
    //  \param[in] vert - The vert to set.
    //  \param[in] in_point - The position to set, in the objects local coordinate space.
    //  \param[in] pNode - The node that is used by the modifier.
    virtual void EPMeshSetVert( const int vert, const Point3 & in_point, INode* pNode) { return; }

    //  \param[in] pNode - The node that is used by the modifier.
    virtual void EPMeshEndSetVertices(INode* pNode) { return; }


protected:

    enum ManipulateGrips
    {
        eSoftSelFalloff = 0,
        eSoftSelPinch,
        eSoftSelBubble,
        eSetFlow,
        eLoopShift,
        eRingShift

    };

    virtual void SetManipulateGrip(bool on, ManipulateGrips item) = 0;

    virtual bool GetManipulateGrip(ManipulateGrips item) = 0;
};
#pragma warning(pop)