mesh_test.py

bl_info = {
    "name": "Test",
    "author": "Tester",
    "version": (0, 1),
    "blender": (2, 64, 0),
    "location": "View3D > Toolbar and View3D > Specials (W-key) > Test",
    "warning": "",
    "description": "A mesh tool to test some vertex translation stuff",
    "wiki_url": "http://wiki.blender.org/",
    "tracker_url": "",
    "category": "Mesh"}

import bpy
import blf
import bgl
import mathutils

g_sel_vert_idx = -100
g_sel_vert_pos = mathutils.Vector((0.0, 0.0, 0.0))
g_sel_vert_init_pos_saved = False


def draw_callback(s_e_l_f, context):
    # draw instructions
    font_id = 0
    txt = "[Enter] to finish, [ESC] to cancel"
    blf.size(font_id, 15, 72)
    dim = blf.dimensions(font_id, txt)
    w = context.region.width
    blf.position(font_id, w - dim[0] - 30, 20, 0)
    blf.draw(font_id, txt)

    obj = context.active_object
    bpy.ops.object.mode_set(mode='OBJECT')

    global g_sel_vert_idx
    global g_sel_vert_pos
    global g_sel_vert_init_pos_saved
    if not g_sel_vert_init_pos_saved:
        g_sel_vert_pos = obj.data.vertices[g_sel_vert_idx].co
        print("In draw_callback, saving co of the selected vertex " + str(g_sel_vert_idx) + ", co = " + str(g_sel_vert_pos))
        print("-"*20)
        g_sel_vert_init_pos_saved = True

    if g_sel_vert_idx >= 0 and obj.data.vertices[g_sel_vert_idx].co != g_sel_vert_pos:
        print("Selected vertex " + str(g_sel_vert_idx))
        print("Old coordinates: " + str(g_sel_vert_pos))
        print("New coordinates: " + str(obj.data.vertices[g_sel_vert_idx].co))

        # for v_idx in range(len(obj.data.vertices)):
        #     if v_idx != g_sel_vert_idx:
        #         obj.data.vertices[v_idx].co += (obj.data.vertices[g_sel_vert_idx].co - g_sel_vert_pos)

        g_sel_vert_pos = obj.data.vertices[g_sel_vert_idx].co
        print("Saved coordinates: " + str(g_sel_vert_pos))
        print("-"*20)

    bpy.ops.object.mode_set(mode='EDIT')


# --------------------------------------------------------------
class TestOp(bpy.types.Operator):
    bl_idname = "mesh.test_op"
    bl_label = "Test"
    bl_description = "Test"
    bl_options = {'REGISTER', 'UNDO'}

    def __init__(self):
        print("__init__")

    def __del__(self):
        print("__del__")

    def invoke(self, context, event):
        if context.area.type == 'VIEW_3D':
            print("-"*20)
            print("-"*20)
            print("invoke")
            context.window_manager.modal_handler_add(self)

            # Add the r3d OpenGL drawing callback
            # draw in view space with 'POST_VIEW' and 'PRE_VIEW'
            self._handle = context.region.callback_add(draw_callback, (self, context), 'POST_PIXEL')

            obj = context.active_object
            # bpy.ops.object.editmode_toggle()
            bpy.ops.object.mode_set(mode='OBJECT')

            for vert_idx in range(len(obj.data.vertices)):
                v = obj.data.vertices[vert_idx]
                if v.select:
                    global g_sel_vert_idx
                    global g_sel_vert_pos
                    print("Vertex " + str(vert_idx) + " is selected")
                    g_sel_vert_idx = vert_idx
                    g_sel_vert_pos = v.co
                    print("Saved position = " + str(g_sel_vert_pos))
                    print("-"*20)
                    break

            global g_sel_vert_init_pos_saved
            g_sel_vert_init_pos_saved = False

            # bpy.ops.object.editmode_toggle()
            bpy.ops.object.mode_set(mode='EDIT')

            return {'RUNNING_MODAL'}
        else:
            self.report({'WARNING'}, "view3d not found, cannot run operator (%s)" % context.area.type)
            return {'CANCELLED'}

    def modal(self, context, event):
        context.area.tag_redraw()

        if event.type in ('ESC'):
            context.region.callback_remove(self._handle)
            return {'CANCELLED'}
        elif event.type in ('NUMPAD_ENTER', 'RET'):
            context.region.callback_remove(self._handle)
            return {'FINISHED'}

        return {'PASS_THROUGH'}
#        return {'RUNNING_MODAL'}

    @classmethod
    def poll(cls, context):
        ob = context.active_object
        return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
# --------------------------------------------------------------


# registering and menu integration
def register():
    bpy.utils.register_class(TestOp)


# unregistering and removing menus
def unregister():
    bpy.utils.unregister_class(TestOp)


if __name__ == "__main__":
    register()