Esempio n. 1
0
    def start(cls):
        if not cls.update_server_existed():
            cls.server_status = WAIT_RESPONSE
            cls.server_process = threading.Thread(target=create_server)
            cls.server_process.daemon = True

            try:
                cls.server_process.start()
            except BaseException as ex:
                cls.server_status = MAIN_THREAD_START_EXC
                cls.server_process = None
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT", message=get_translate(_("Server starting error: ")) + str(ex)
                )

            cls.wait_loop()

            if cls.server_status == SUB_THREAD_SERVER_EXC:
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT", message=get_translate(_("Server starting error: ")) + cls.error_message
                )
            if cls.server_status == SUB_THREAD_OTHER_EXC:
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT", message=get_translate(_("Could not start the server: ")) + cls.error_message
                )

            cls.panel_redraw()
Esempio n. 2
0
    def draw_constraint(self, context, cons):

        layout = self.layout

        if cons.type == "LOCKED_TRACK" and cons.name == "REFLECTION PLANE":
            box = layout.box()
            box.label(
                get_translate(_("LOCKED_TRACK constraint reserved for ")) +
                cons.name)

        elif (cons.type == "RIGID_BODY_JOINT" or cons.type == "COPY_LOCATION"
              or cons.type == "COPY_ROTATION" or cons.type == "COPY_TRANSFORMS"
              or cons.type == "TRACK_TO"):
            bpy.types.OBJECT_PT_constraints_new.draw_constraint(
                self, context, cons)

        else:
            obj = context.object
            box = layout.box()
            box.label(cons.name +
                      get_translate(_(" constraint is not supported.")),
                      icon="ERROR")
            box.operator("b4w.remove_constraint",
                         text=_("Remove"),
                         icon='PANEL_CLOSE').cons_name = cons.name
Esempio n. 3
0
    def start(cls):
        if not cls.update_server_existed():
            cls.server_status = WAIT_RESPONSE
            cls.server_process = threading.Thread(target=create_server)
            cls.server_process.daemon = True

            #for converting resources on MACOS
            if sys.platform == "darwin" and not ":/usr/local/bin" in os.environ["PATH"]:
                os.environ["PATH"] = os.environ["PATH"] + ":/usr/local/bin"

            try:
                cls.server_process.start()
            except BaseException as ex:
                cls.server_status = MAIN_THREAD_START_EXC
                cls.server_process = None
                bpy.ops.b4w.server_message("INVOKE_DEFAULT", 
                        message=get_translate(_("Server starting error: ")) + str(ex))

            cls.wait_loop()

            if cls.server_status == SUB_THREAD_SERVER_EXC:
                bpy.ops.b4w.server_message("INVOKE_DEFAULT", 
                        message=get_translate(_("Server starting error: ")) +  cls.error_message)
            if cls.server_status == SUB_THREAD_OTHER_EXC:
                bpy.ops.b4w.server_message("INVOKE_DEFAULT", 
                        message=get_translate(_("Could not start the server: ")) + cls.error_message)

            cls.panel_redraw()
Esempio n. 4
0
    def start(cls):
        if not cls.update_server_existed():
            cls.server_status = WAIT_RESPONSE
            cls.server_process = threading.Thread(target=create_server)
            cls.server_process.daemon = True

            try:
                cls.server_process.start()
            except BaseException as ex:
                cls.server_status = MAIN_THREAD_START_EXC
                cls.server_process = None
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT",
                    message=get_translate(_("Server starting error: ")) +
                    str(ex))

            cls.wait_loop()

            if cls.server_status == SUB_THREAD_SERVER_EXC:
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT",
                    message=get_translate(_("Server starting error: ")) +
                    cls.error_message)
            if cls.server_status == SUB_THREAD_OTHER_EXC:
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT",
                    message=get_translate(_("Could not start the server: ")) +
                    cls.error_message)

            cls.panel_redraw()
Esempio n. 5
0
    def start(cls):
        if not cls.update_server_existed():
            root = cls.get_root()
            port = bpy.context.user_preferences.addons[
                __package__].preferences.b4w_port_number
            allow_ext_requests = bpy.context.user_preferences.addons[
                __package__].preferences.b4w_enable_ext_requests

            python_path = cls.get_python_binary(["5", "4"])
            if not python_path:
                print("Python3 not found", file=sys.stderr)
                return

            blender_path = bpy.app.binary_path

            proj_serv = cls.get_proj_serv()

            cls.server_status = WAIT_RESPONSE
            cls.server_process = threading.Thread(
                target=proj_serv.create_server,
                args=(root, port, allow_ext_requests, python_path,
                      blender_path, B4WLocalServer))
            cls.server_process.daemon = True

            #for converting resources on MACOS
            if sys.platform == "darwin" and not ":/usr/local/bin" in os.environ[
                    "PATH"]:
                os.environ["PATH"] = os.environ["PATH"] + ":/usr/local/bin"

            try:
                cls.server_process.start()
            except BaseException as ex:
                cls.server_status = MAIN_THREAD_START_EXC
                cls.server_process = None
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT",
                    message=get_translate(_("Server starting error: ")) +
                    str(ex))

            cls.wait_loop()

            if cls.server_status == SUB_THREAD_SERVER_EXC:
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT",
                    message=get_translate(_("Server starting error: ")) +
                    cls.error_message)
            if cls.server_status == SUB_THREAD_OTHER_EXC:
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT",
                    message=get_translate(_("Could not start the server: ")) +
                    cls.error_message)

            cls.panel_redraw()
Esempio n. 6
0
def open_browser(url):
    try:
        webbrowser.open(url)
    except BaseException as ex:
        bpy.ops.b4w.server_message(
            "INVOKE_DEFAULT",
            message=get_translate(_("Could not open browser: ")) + str(ex))
Esempio n. 7
0
    def start(cls):
        if not cls.update_server_existed():
            root = cls.get_root()
            port = bpy.context.user_preferences.addons[__package__].preferences.b4w_port_number
            allow_ext_requests = bpy.context.user_preferences.addons[__package__].preferences.b4w_enable_ext_requests

            python_path = cls.get_python_binary(["5", "4"])
            if not python_path:
                print("Python3 not found", file=sys.stderr)
                return

            blender_path = bpy.app.binary_path

            proj_serv = cls.get_proj_serv()

            cls.server_status = WAIT_RESPONSE
            cls.server_process = threading.Thread(
                target=proj_serv.create_server,
                args=(root, port, allow_ext_requests, python_path, blender_path, B4WLocalServer),
            )
            cls.server_process.daemon = True

            # for converting resources on MACOS
            if sys.platform == "darwin" and not ":/usr/local/bin" in os.environ["PATH"]:
                os.environ["PATH"] = os.environ["PATH"] + ":/usr/local/bin"

            try:
                cls.server_process.start()
            except BaseException as ex:
                cls.server_status = MAIN_THREAD_START_EXC
                cls.server_process = None
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT", message=get_translate(_("Server starting error: ")) + str(ex)
                )

            cls.wait_loop()

            if cls.server_status == SUB_THREAD_SERVER_EXC:
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT", message=get_translate(_("Server starting error: ")) + cls.error_message
                )
            if cls.server_status == SUB_THREAD_OTHER_EXC:
                bpy.ops.b4w.server_message(
                    "INVOKE_DEFAULT", message=get_translate(_("Could not start the server: ")) + cls.error_message
                )

            cls.panel_redraw()
Esempio n. 8
0
    def draw(self, context):
        global _shore_bake_error

        print(_shore_bake_error)

        row = self.layout.row()
        row.alignment = "CENTER"
        row.label(_("=== BLEND4WEB: SHORE BAKE ERROR ==="))

        if _shore_bake_error.component is not None:
            row = self.layout.row()
            row.label(get_translate(_("COMPONENT: ")) + _shore_bake_error.component.rna_type.name.upper())
            row = self.layout.row()
            row.label(get_translate(_("NAME: ")) + _shore_bake_error.component.name)

        row = self.layout.row()
        row.label(get_translate(_("ERROR: ")) + _shore_bake_error.message)
Esempio n. 9
0
    def draw(self, context):
        global _shore_bake_error

        print(_shore_bake_error)

        row = self.layout.row()
        row.alignment = "CENTER"
        row.label(_("=== BLEND4WEB: SHORE BAKE ERROR ==="))

        if _shore_bake_error.component is not None:
            row = self.layout.row()
            row.label(get_translate(_("COMPONENT: ")) + _shore_bake_error.component.rna_type.name.upper())
            row = self.layout.row()
            row.label(get_translate(_("NAME: ")) + _shore_bake_error.component.name)

        row = self.layout.row()
        row.label(get_translate(_("ERROR: ")) + _shore_bake_error.message)
Esempio n. 10
0
    def draw_constraint(self, context, cons):

        layout = self.layout

        if cons.type == "LOCKED_TRACK" and cons.name == "REFLECTION PLANE":
            box = layout.box()
            box.label(get_translate(_("LOCKED_TRACK constraint reserved for ")) + cons.name)

        elif (cons.type == "RIGID_BODY_JOINT" or cons.type == "COPY_LOCATION"
                    or cons.type == "COPY_ROTATION" or cons.type == "COPY_TRANSFORMS"
                    or cons.type == "TRACK_TO"):
            bpy.types.OBJECT_PT_constraints_new.draw_constraint(self, context, cons)

        else:
            obj = context.object
            box = layout.box()
            box.label(cons.name + get_translate(_(" constraint is not supported.")), icon="ERROR")
            box.operator("b4w.remove_constraint", text=_("Remove"), icon='PANEL_CLOSE').cons_name = cons.name
Esempio n. 11
0
    def draw_constraint(self, context, con):

        if con.type == "LOCKED_TRACK":

            layout = self.layout
            box = layout.box()

            box.label(get_translate(_("LOCKED_TRACK constraint reserved for ")) + con.name)

        else:
            bpy.types.OBJECT_PT_constraints_new.draw_constraint(self, context, con)
Esempio n. 12
0
    def draw_constraint(self, context, con):

        if con.type == "LOCKED_TRACK":

            layout = self.layout
            box = layout.box()

            box.label(get_translate(_("LOCKED_TRACK constraint reserved for ")) + con.name)

        else:
            bpy.types.OBJECT_PT_constraints_new.draw_constraint(self, context, con)
Esempio n. 13
0
    def draw_constraint(self, context, cons):

        layout = self.layout

        if cons.type == 'COPY_TRANSFORMS':
            bpy.types.BONE_PT_constraints_new.draw_constraint(self, context, cons)

        else:
            obj = context.object
            box = layout.box()
            box.label(cons.name + get_translate(_(" constraint is not supported.")), icon="ERROR")
            box.operator("b4w.remove_constraint", text=_("Remove"), icon='PANEL_CLOSE').cons_name = cons.name
Esempio n. 14
0
    def draw_constraint(self, context, cons):

        layout = self.layout

        if cons.type == 'COPY_TRANSFORMS':
            bpy.types.BONE_PT_constraints_new.draw_constraint(self, context, cons)

        else:
            obj = context.object
            box = layout.box()
            box.label(cons.name + get_translate(_(" constraint is not supported.")), icon="ERROR")
            box.operator("b4w.remove_constraint", text=_("Remove"), icon='PANEL_CLOSE').cons_name = cons.name
Esempio n. 15
0
    def shutdown(cls):
        if cls.server_process is not None:
            cls.server_status = WAIT_RESPONSE
            cls.waiting_for_shutdown = True
            try:
                if cls.server is not None:
                    cls.server.stop()
                    tornado.ioloop.IOLoop.instance().stop()
                cls.server_process = None
                cls.server = None
                cls.wait_loop()
            except BaseException as ex:
                cls.waiting_for_shutdown = False
                bpy.ops.b4w.server_message("INVOKE_DEFAULT", 
                        message=get_translate(_("Server stopping error: ")) + str(ex))
                cls.server_status = MAIN_THREAD_STOP_EXC

            cls.panel_redraw()
def run():

    max_shore_dist = bpy.context.window_manager.b4w_max_shore_distance
    texture_size = bpy.context.window_manager.b4w_shoremap_texure_size

    # escape from edit mode
    if bpy.context.mode == "EDIT_MESH":
        bpy.ops.object.mode_set(mode="OBJECT")

    if len(bpy.context.selected_editable_objects) == 0:
        raise BakeError(get_translate(_("No objects selected")))

    if len(bpy.context.selected_editable_objects) == 1:
        raise BakeError(get_translate(_("Source object is not selected.")))

    objects = bpy.data.objects

    # destination object
    obj_dst_name = bpy.context.object.name
    obj_dst = objects.get(obj_dst_name)

    if len(obj_dst.material_slots) == 0:
        raise BakeError(
            obj_dst.name + get_translate(_(" doesn't have a material.")),
            obj_dst)

    mesh_dst = obj_dst.data
    dst_ver_list = mesh_dst.vertices

    # old destination obj vertices positions
    old_dst_co_list = [0] * 3 * len(dst_ver_list)
    for i in range(len(dst_ver_list)):
        old_dst_co_list[i * 3] = dst_ver_list[i].co[0]
        old_dst_co_list[i * 3 + 1] = dst_ver_list[i].co[1]
        old_dst_co_list[i * 3 + 2] = dst_ver_list[i].co[2]

    # transform dst vertices to the world space
    for vert_dst in dst_ver_list:
        vert_dst.co = obj_dst.matrix_world * vert_dst.co

    # source objects
    objs_src = []
    objs_src_ver_list = []
    old_objs_src_co_list = []
    for obj in bpy.context.selected_editable_objects:
        if obj.name != obj_dst_name:

            if obj.type != "MESH":
                raise BakeError(
                    get_translate(_("Source object is not \"Mesh\".")), obj)

            objs_src.append(obj)
            src_ver_list = obj.data.vertices
            objs_src_ver_list.append(src_ver_list)

            # old source obj vertices positions
            old_src_co_list = [0] * 3 * len(src_ver_list)
            for i in range(len(src_ver_list)):
                old_src_co_list[i * 3] = src_ver_list[i].co[0]
                old_src_co_list[i * 3 + 1] = src_ver_list[i].co[1]
                old_src_co_list[i * 3 + 2] = src_ver_list[i].co[2]

            old_objs_src_co_list.append(old_src_co_list)

            # transform src vertices to the world space
            for vert_src in src_ver_list:
                vert_src.co = obj.matrix_world * vert_src.co

    # set water level to the z coord of destination object
    level = obj_dst.location[2]

    # set starting search values
    minx = 1000000.0
    maxx = -1000000.0
    miny = 1000000.0
    maxy = -1000000.0

    # generate list consisting only from vertices wich z is close to the level
    src_ver_selected = []
    for src_ver_list in objs_src_ver_list:
        for vert_src in src_ver_list:
            v_src_z = vert_src.co[2]
            if v_src_z >= level - 0.2 and v_src_z < level + 1:
                src_ver_selected.append(vert_src)
                # set search rectangle dimensions
                minx = min(vert_src.co[0], minx)
                maxx = max(vert_src.co[0], maxx)
                miny = min(vert_src.co[1], miny)
                maxy = max(vert_src.co[1], maxy)

    # generate tiled structure for the source mesh
    # num_tiles has to be around 0.4 of src_ver_selected (experimental number)
    xy_appr_product = 0.4 * len(src_ver_selected)

    x_size = (maxx - minx)
    y_size = (maxy - miny)

    if y_size != 0 and x_size != 0:
        xy_ratio = x_size / y_size
    else:
        xy_ratio = 1

    if x_size == 0:
        num_x_tiles = 1
    else:
        num_x_tiles = round(math.sqrt(xy_appr_product * xy_ratio))
        num_x_tiles = max(num_x_tiles, 1)

    if y_size == 0:
        num_y_tiles = 1
    else:
        num_y_tiles = round(num_x_tiles / xy_ratio)
        num_y_tiles = max(num_y_tiles, 1)

    tile_x_length = x_size / num_x_tiles
    tile_y_length = y_size / num_y_tiles

    num_tiles = num_x_tiles * num_y_tiles

    # initialize array of tiles
    tiles = [[] for i in range(num_tiles)]

    for vert_src in src_ver_selected:
        v_src_x = vert_src.co[0]
        v_src_y = vert_src.co[1]
        if x_size != 0:
            x_coord = math.floor((v_src_x - minx) / tile_x_length)
        else:
            x_coord = 0

        if y_size != 0:
            y_coord = math.floor((v_src_y - miny) / tile_y_length)
        else:
            y_coord = 0

        if x_coord == num_x_tiles:
            x_coord = num_x_tiles - 1
        if y_coord == num_y_tiles:
            y_coord = num_y_tiles - 1

        tiles[y_coord * num_x_tiles + x_coord].append(vert_src)

    x_max = maxx + max_shore_dist
    x_min = minx - max_shore_dist
    y_max = maxy + max_shore_dist
    y_min = miny - max_shore_dist

    data_length = 4 * texture_size * texture_size

    # list of distance values
    if check_win():
        dist_list = process_pixels(None, minx, maxx, miny, maxy,
                                   max_shore_dist, texture_size, tiles,
                                   num_x_tiles, tile_x_length, tile_y_length,
                                   data_length, 0, level)
    else:
        # break calculations into several processes
        dist_list = [] * data_length

        q = multiprocessing.Queue()
        part_length = data_length // NUM_PROC
        proc_list = []
        for i in range(NUM_PROC):
            p = multiprocessing.Process(
                target=process_pixels,
                args=(q, minx, maxx, miny, maxy, max_shore_dist, texture_size,
                      tiles, num_x_tiles, tile_x_length, tile_y_length,
                      part_length, i, level))
            proc_list.append(p)
            p.start()

        requests = []
        for i in range(NUM_PROC):
            r = q.get()
            requests.append(r)

        for p in proc_list:
            p.join()

        for i in range(NUM_PROC):
            for r in requests:
                if r[0] == i:
                    dist_list.extend(r[1])

    store_to_texture(dist_list, x_max, x_min, y_max, y_min, max_shore_dist,
                     texture_size, obj_dst)

    # reset destination mesh's vertices positions
    for vert_dst in dst_ver_list:
        vert_dst.co[0] = old_dst_co_list[vert_dst.index * 3]
        vert_dst.co[1] = old_dst_co_list[vert_dst.index * 3 + 1]
        vert_dst.co[2] = old_dst_co_list[vert_dst.index * 3 + 2]

    # reset source mesh's vertices positions
    for i in range(len(objs_src_ver_list)):
        src_ver_list = objs_src_ver_list[i]
        old_src_co_list = old_objs_src_co_list[i]
        for vert_src in src_ver_list:
            vert_src.co[0] = old_src_co_list[vert_src.index * 3]
            vert_src.co[1] = old_src_co_list[vert_src.index * 3 + 1]
            vert_src.co[2] = old_src_co_list[vert_src.index * 3 + 2]

    # show results in viewport
    mesh_dst.update()
Esempio n. 17
0
def open_browser(url):
    try:
        webbrowser.open(url)
    except BaseException as ex:
        bpy.ops.b4w.server_message("INVOKE_DEFAULT",
                message=get_translate(_("Could not open browser: ")) + str(ex))
Esempio n. 18
0
def run():

    max_shore_dist = bpy.context.window_manager.b4w_max_shore_distance
    texture_size = bpy.context.window_manager.b4w_shoremap_texure_size

    # escape from edit mode
    if bpy.context.mode == "EDIT_MESH":
        bpy.ops.object.mode_set(mode="OBJECT")

    if len(bpy.context.selected_editable_objects) == 0:
        raise BakeError(get_translate(_("No objects selected")))

    if len(bpy.context.selected_editable_objects) == 1:
        raise BakeError(get_translate(_("Source object is not selected.")))

    objects = bpy.data.objects

    # destination object
    obj_dst_name = bpy.context.object.name
    obj_dst = objects.get(obj_dst_name)

    if len(obj_dst.material_slots) == 0:
        raise BakeError(obj_dst.name + get_translate(_(" doesn't have material.")), obj_dst)

    mesh_dst = obj_dst.data
    dst_ver_list = mesh_dst.vertices

    # old destination obj vertices positions
    old_dst_co_list = [0] * 3 * len(dst_ver_list)
    for i in range(len(dst_ver_list)):
        old_dst_co_list[i * 3]     = dst_ver_list[i].co[0]
        old_dst_co_list[i * 3 + 1] = dst_ver_list[i].co[1]
        old_dst_co_list[i * 3 + 2] = dst_ver_list[i].co[2]

    # transform dst vertices to world space
    for vert_dst in dst_ver_list:
        vert_dst.co = obj_dst.matrix_world * vert_dst.co

    # source objects
    objs_src = []
    objs_src_ver_list = []
    old_objs_src_co_list = []
    for obj in bpy.context.selected_editable_objects:
        if obj.name != obj_dst_name:

            objs_src.append(obj)
            src_ver_list = obj.data.vertices
            objs_src_ver_list.append(src_ver_list);

            # old source obj vertices positions
            old_src_co_list = [0] * 3 * len(src_ver_list)
            for i in range(len(src_ver_list)):
                old_src_co_list[i * 3]     = src_ver_list[i].co[0]
                old_src_co_list[i * 3 + 1] = src_ver_list[i].co[1]
                old_src_co_list[i * 3 + 2] = src_ver_list[i].co[2]

            old_objs_src_co_list.append(old_src_co_list)

            # transform src vertices to world space
            for vert_src in src_ver_list:
                vert_src.co = obj.matrix_world * vert_src.co

    # set water level to z coord of destination object
    level = obj_dst.location[2]

    # set starting search values
    minx =  1000000.0
    maxx = -1000000.0
    miny =  1000000.0
    maxy = -1000000.0

    # generate list consisting only from vertices wich z is close to level
    src_ver_selected = []
    for src_ver_list in objs_src_ver_list:
        for vert_src in src_ver_list:
            v_src_z = vert_src.co[2]
            if v_src_z >= level - 0.2 and v_src_z < level + 1:
                src_ver_selected.append(vert_src)
                # set search rectangle dimensions
                minx = min(vert_src.co[0], minx)
                maxx = max(vert_src.co[0], maxx)
                miny = min(vert_src.co[1], miny)
                maxy = max(vert_src.co[1], maxy)

    # generate tiled structure for the source mesh
    # num_tiles had to be around 0.4 of src_ver_selected (experimental number)
    xy_appr_product = 0.4 * len(src_ver_selected)

    x_size = (maxx - minx)
    y_size = (maxy - miny)

    if y_size != 0 and x_size != 0:
        xy_ratio = x_size / y_size
    else:
        xy_ratio = 1

    if x_size == 0:
        num_x_tiles = 1
    else:
        num_x_tiles = round(math.sqrt(xy_appr_product * xy_ratio))
        num_x_tiles = max(num_x_tiles, 1)

    if y_size == 0:
        num_y_tiles = 1
    else:
        num_y_tiles = round(num_x_tiles / xy_ratio)
        num_y_tiles = max(num_y_tiles, 1)

    tile_x_length = x_size / num_x_tiles
    tile_y_length = y_size / num_y_tiles

    num_tiles = num_x_tiles * num_y_tiles

    # initialize array of tiles
    tiles = [ [] for i in range(num_tiles) ]

    for vert_src in src_ver_selected:
        v_src_x = vert_src.co[0]
        v_src_y = vert_src.co[1]
        if x_size != 0:
            x_coord = math.floor( (v_src_x - minx) / tile_x_length )
        else:
            x_coord = 0

        if y_size != 0:
            y_coord = math.floor( (v_src_y - miny) / tile_y_length )
        else:
            y_coord = 0

        if x_coord == num_x_tiles:
            x_coord = num_x_tiles - 1
        if y_coord == num_y_tiles:
            y_coord = num_y_tiles - 1

        tiles[y_coord * num_x_tiles + x_coord].append(vert_src)

    x_max = maxx + max_shore_dist
    x_min = minx - max_shore_dist
    y_max = maxy + max_shore_dist
    y_min = miny - max_shore_dist

    data_length = 4 * texture_size * texture_size

    # list of distance values
    if check_win():
        dist_list = process_pixels(None, minx, maxx, miny, maxy, max_shore_dist,
                           texture_size, tiles, num_x_tiles, tile_x_length,
                           tile_y_length, data_length, 0, level)
    else:
        # break calculations into several processes
        dist_list = [] * data_length

        q = multiprocessing.Queue();
        part_length = data_length // NUM_PROC;
        proc_list = []
        for i in range(NUM_PROC):
            p = multiprocessing.Process(target = process_pixels,
                         args=(q, minx, maxx, miny, maxy, max_shore_dist,
                               texture_size, tiles, num_x_tiles, tile_x_length,
                               tile_y_length, part_length, i, level)
                        )
            proc_list.append(p)
            p.start()

        requests = []
        for i in range(NUM_PROC):
            r = q.get()
            requests.append(r)

        for p in proc_list:
            p.join()

        for i in range(NUM_PROC):
            for r in requests:
                if r[0] == i:
                    dist_list.extend(r[1])

    store_to_texture(dist_list, x_max, x_min, y_max, y_min, max_shore_dist,
                     texture_size, obj_dst)

    # reset destination mesh's vertices positions
    for vert_dst in dst_ver_list:
        vert_dst.co[0] = old_dst_co_list[vert_dst.index * 3]
        vert_dst.co[1] = old_dst_co_list[vert_dst.index * 3 + 1]
        vert_dst.co[2] = old_dst_co_list[vert_dst.index * 3 + 2]

    # reset source mesh's vertices positions
    for i in range(len(objs_src_ver_list)):
        src_ver_list = objs_src_ver_list[i]
        old_src_co_list = old_objs_src_co_list[i]
        for vert_src in src_ver_list:
            vert_src.co[0] = old_src_co_list[vert_src.index * 3]
            vert_src.co[1] = old_src_co_list[vert_src.index * 3 + 1]
            vert_src.co[2] = old_src_co_list[vert_src.index * 3 + 2]

    # show results in viewport
    mesh_dst.update()