feat: Timer for blender main thread

bl_types/bl_image.py

@@ -5,6 +5,23 @@ import os
 from .. import utils, environment
 from ..libs.replication.data import ReplicatedDatablock
 
+def dump_image(image):
+    pixels = None
+    if image.source == "GENERATED":
+        img_name = "{}.png".format(image.name)
+
+        image.filepath_raw = os.path.join(environment.CACHE_DIR, img_name)
+        image.file_format = "PNG"
+        image.save()
+
+    if image.source == "FILE":
+        image.save()
+        file = open(image.filepath_raw, "rb")
+        pixels = file.read()
+    else:
+        print("Image format not supported ")
+    return pixels
+
 class BlImage(ReplicatedDatablock):
     def __init__(self, *args, **kwargs):
         self.icon = 'IMAGE_DATA'
@@ -36,7 +53,7 @@ class BlImage(ReplicatedDatablock):
     def dump(self, pointer=None):
         assert(pointer)
         data = {}
-        data['pixels'] = utils.dump_image(pointer)
+        data['pixels'] = dump_image(pointer)
         utils.dump_datablock_attibutes(pointer, [], 2, data)
         data = utils.dump_datablock_attibutes(
             pointer, 

operators.py

@@ -13,7 +13,7 @@ import bpy
 import mathutils
 from bpy_extras.io_utils import ExportHelper
 
-from . import environment, presence, ui, utils
+from . import environment, presence, ui, utils, timer
 from .libs import umsgpack
 from .libs.replication.data import ReplicatedDataFactory
 from .libs.replication.interface import Client
@@ -149,7 +149,9 @@ class SessionStartOperator(bpy.types.Operator):
             supported_bl_types.append(_type.bl_id)
 
             if _type.bl_id == 'objects':#For testing
-                bpy_factory.register_type(_type.bl_class, _type.bl_rep_class, timer=2,automatic=True)
+                bpy_factory.register_type(_type.bl_class, _type.bl_rep_class, timer=0.16,automatic=True)
+                obj_timer = timer.ApplyTimer(timout=0.16,target_type=_type.bl_rep_class)
+                obj_timer.start()
             else:
                 bpy_factory.register_type(_type.bl_class, _type.bl_rep_class)
 

timer.py

@@ -0,0 +1,33 @@
+import bpy
+from .libs.replication.constants import *
+from . import operators
+
+class Timer():
+    def __init__(self, duration=1):
+        self._timeout = duration
+
+    def start(self):
+        bpy.app.timers.register(self.execute)
+
+    def execute(self):
+        return self._timeout
+
+    def stop(self):
+        bpy.app.timers.unregister(self.execute)
+
+class ApplyTimer(Timer):
+    def __init__(self, timout=1,target_type=None):
+        self._type = target_type
+        super().__init__(timout)
+
+    def execute(self):
+        if operators.client:
+            nodes = operators.client.list(filter=self._type)
+
+            for node in nodes:
+                node_ref = operators.client.get(node)
+
+                if node_ref.state == FETCHED:
+                    operators.client.apply(uuid=node)
+
+        return self._timeout

utils.py

@@ -82,9 +82,6 @@ def get_selected_objects(scene):
 
     return selected_objects
 
-
-#    LOAD HELPERS
-
 def load_dict(src_dict, target):
     try:
         for item in src_dict:
@@ -95,51 +92,6 @@ def load_dict(src_dict, target):
         logger.error(e)
         pass
 
-
-def load(key, value):
-    target = resolve_bpy_path(key)
-    target_type = key.split('/')[0]
-
-    logger.debug("load{}, {}".format(target_type, key))
-    if value == "None":
-        return
-
-    if target_type == 'Object':
-        load_object(target=target, data=value,
-                    create=True)
-    elif target_type == 'Image':
-        load_image(target=target, data=value)
-    elif target_type == 'Mesh':
-        load_mesh(target=target, data=value,
-                  create=True)
-    elif target_type == 'Collection':
-        load_collection(target=target, data=value,
-                        create=True)
-    elif target_type == 'Material':
-        load_material(target=target, data=value,
-                      create=True)
-    elif target_type == 'GreasePencil':
-        load_gpencil(target=target, data=value,
-                     create=True)
-    elif target_type == 'Scene':
-        load_scene(target=target, data=value,
-                   create=True)
-    elif 'Light' in target_type:
-        load_light(target=target, data=value,
-                   create=True)
-    elif target_type == 'Camera':
-        load_default(target=target, data=value,
-                     create=True, type=target_type)
-    elif target_type == 'Armature':
-        load_armature(target=target, data=value,
-                      create=True)
-    elif target_type == 'Curve':
-        load_curve(target=target, data=value,
-                   create=True)
-    elif target_type == 'Client':
-        load_client(key.split('/')[1], value)
-
-
 def resolve_bpy_path(path):
     """
     Get bpy property value from path
@@ -167,33 +119,6 @@ def load_client(client=None, data=None):
             draw.renderer.draw_client_selected_objects(data)
 
 
-def load_image(target=None, data=None):
-    try:
-        if not target:
-            image = bpy.data.images.new(
-                name=data['name'],
-                width=data['size'][0],
-                height=data['size'][1]
-            )
-        else:
-            image = target
-
-        img_name = "{}.png".format(image.name)
-
-        logger.info("updating {} cache file".format(image.name))
-        img_path = os.path.join(environment.CACHE_DIR, img_name)
-
-        file = open(img_path, 'wb')
-        file.write(data["pixels"])
-        file.close()
-
-        image.source = 'FILE'
-        image.filepath = img_path
-        # dump_anything.load(target, data)
-    except Exception as e:
-        logger.error(e)
-
-
 def load_armature(target=None, data=None, create=False):
     file = "cache_{}.json".format(data['name'])
     context = bpy.context
@@ -240,475 +165,6 @@ def load_armature(target=None, data=None, create=False):
             import os
             os.remove(file)
 
-
-def load_mesh(target=None, data=None, create=False):
-    import bmesh
-
-    if not target or not target.is_editmode:
-        # 1 - LOAD GEOMETRY
-        mesh_buffer = bmesh.new()
-
-        for i in data["verts"]:
-            v = mesh_buffer.verts.new(data["verts"][i]["co"])
-
-        mesh_buffer.verts.ensure_lookup_table()
-
-        for i in data["edges"]:
-            verts = mesh_buffer.verts
-            v1 = data["edges"][i]["verts"][0]
-            v2 = data["edges"][i]["verts"][1]
-            mesh_buffer.edges.new([verts[v1], verts[v2]])
-
-        for p in data["faces"]:
-            verts = []
-            for v in data["faces"][p]["verts"]:
-                verts.append(mesh_buffer.verts[v])
-
-            if len(verts) > 0:
-                f = mesh_buffer.faces.new(verts)
-
-                uv_layer = mesh_buffer.loops.layers.uv.verify()
-
-                f.material_index = data["faces"][p]['material_index']
-
-                # UV loading
-                for i, loop in enumerate(f.loops):
-                    loop_uv = loop[uv_layer]
-                    loop_uv.uv = data["faces"][p]["uv"][i]
-
-        if target is None and create:
-            target = bpy.data.meshes.new(data["name"])
-
-        mesh_buffer.to_mesh(target)
-
-        # mesh_buffer.from_mesh(target)
-
-        # 2 - LOAD METADATA
-
-        # uv's
-        for uv_layer in data['uv_layers']:
-            target.uv_layers.new(name=uv_layer)
-
-        bevel_layer = mesh_buffer.verts.layers.bevel_weight.verify()
-        skin_layer = mesh_buffer.verts.layers.skin.verify()
-
-        # for face in mesh_buffer.faces:
-
-        #     # Face metadata
-        #     for loop in face.loops:
-        #         loop_uv = loop[uv_layer]
-        #         loop_uv.uv = data['faces'][face.index]["uv"]
-
-        dump_anything.load(target, data)
-
-        # 3 - LOAD MATERIAL SLOTS
-        material_to_load = []
-        material_to_load = revers(data["materials"])
-        target.materials.clear()
-        # SLots
-        i = 0
-
-        for m in data["material_list"]:
-            target.materials.append(bpy.data.materials[m])
-
-        target.id = data['id']
-    else:
-        logger.error("Mesh can't be loaded")
-
-
-def load_object(target=None, data=None, create=False):
-    try:
-        if target is None and create:
-            pointer = None
-
-            # Object specific constructor...
-            if data["data"] in bpy.data.meshes.keys():
-                pointer = bpy.data.meshes[data["data"]]
-            elif data["data"] in bpy.data.lights.keys():
-                pointer = bpy.data.lights[data["data"]]
-            elif data["data"] in bpy.data.cameras.keys():
-                pointer = bpy.data.cameras[data["data"]]
-            elif data["data"] in bpy.data.curves.keys():
-                pointer = bpy.data.curves[data["data"]]
-            elif data["data"] in bpy.data.armatures.keys():
-                pointer = bpy.data.armatures[data["data"]]
-            elif data["data"] in bpy.data.grease_pencils.keys():
-                pointer = bpy.data.grease_pencils[data["data"]]
-            elif data["data"] in bpy.data.curves.keys():
-                pointer = bpy.data.curves[data["data"]]
-
-            target = bpy.data.objects.new(data["name"], pointer)
-
-        # Load other meshes metadata
-        # dump_anything.load(target, data)
-
-        target.matrix_world = mathutils.Matrix(data["matrix_world"])
-
-        target.id = data['id']
-
-        client = bpy.context.window_manager.session.username
-
-        # Load modifiers
-        if hasattr(target,'modifiers'):
-            for local_modifier in target.modifiers:
-                if local_modifier.name not in data['modifiers']:
-                    target.modifiers.remove(local_modifier)
-            for modifier in data['modifiers']:
-                target_modifier = target.modifiers.get(modifier)
-
-                if not target_modifier:
-                    target_modifier = target.modifiers.new(data['modifiers'][modifier]['name'],data['modifiers'][modifier]['type'])
-               
-                dump_anything.load(target_modifier, data['modifiers'][modifier])
-
-
-
-        if target.id == client or target.id == "Common":
-            target.hide_select = False
-        else:
-            target.hide_select = True
-
-    except Exception as e:
-        logger.error("Object {} loading error: {} ".format(data["name"], e))
-
-
-def load_curve(target=None, data=None, create=False):
-    try:
-        if target is None and create:
-            target = bpy.data.curves.new(data["name"], 'CURVE')
-
-        dump_anything.load(target, data)
-
-        target.splines.clear()
-        # load splines
-        for spline in data['splines']:
-            # Update existing..
-            # if spline in target.splines.keys():
-
-            new_spline = target.splines.new(data['splines'][spline]['type'])
-            dump_anything.load(new_spline, data['splines'][spline])
-
-            # Load curve geometry data
-            for bezier_point_index in data['splines'][spline]["bezier_points"]:
-                new_spline.bezier_points.add(1)
-                dump_anything.load(
-                    new_spline.bezier_points[bezier_point_index], data['splines'][spline]["bezier_points"][bezier_point_index])
-
-            for point_index in data['splines'][spline]["points"]:
-                new_spline.points.add(1)
-                dump_anything.load(
-                    new_spline.points[point_index], data['splines'][spline]["points"][point_index])
-        target.id = data['id']
-    except Exception as e:
-        logger.error("curve loading error: {}".format(e))
-
-
-def load_collection(target=None, data=None, create=False):
-    try:
-        if target is None and create:
-            target = bpy.data.collections.new(data["name"])
-
-        # Load other meshes metadata
-        # dump_anything.load(target, data)
-
-        # link objects
-        for object in data["objects"]:
-            if object not in target.objects.keys():
-                target.objects.link(bpy.data.objects[object])
-
-        for object in target.objects.keys():
-            if object not in data["objects"]:
-                target.objects.unlink(bpy.data.objects[object])
-
-        # Link childrens
-        for collection in data["children"]:
-            if collection not in target.children.keys():
-                if bpy.data.collections.find(collection) == -1:
-                    target.children.link(
-                        bpy.data.collections[collection])
-                else:
-                    logger.debug(target.name)
-
-        for collection in target.children.keys():
-            if collection not in data["children"]:
-                target.collection.children.unlink(
-                    bpy.data.collections[collection])
-
-        target.id = data['id']
-
-        client = bpy.context.window_manager.session.username
-
-        if target.id == client or target.id == "Common":
-            target.hide_select = False
-        else:
-            target.hide_select = True
-
-    except Exception as e:
-        logger.error("Collection loading error: {}".format(e))
-
-
-def load_scene(target=None, data=None, create=False):
-    try:
-        if target is None and create:
-            target = bpy.data.scenes.new(data["name"])
-
-        # Load other meshes metadata
-        dump_anything.load(target, data)
-
-        # Load master collection
-        for object in data["collection"]["objects"]:
-            if object not in target.collection.objects.keys():
-                target.collection.objects.link(bpy.data.objects[object])
-
-        for object in target.collection.objects.keys():
-            if object not in data["collection"]["objects"]:
-                target.collection.objects.unlink(bpy.data.objects[object])
-
-        # load collections
-        # TODO: Recursive link
-        logger.debug("check for scene childs")
-        for collection in data["collection"]["children"]:
-            logger.debug(collection)
-            if collection not in target.collection.children.keys():
-                target.collection.children.link(
-                    bpy.data.collections[collection])
-
-        logger.debug("check for scene child to remove")
-        for collection in target.collection.children.keys():
-            if collection not in data["collection"]["children"]:
-                target.collection.children.unlink(
-                    bpy.data.collections[collection])
-
-        target.id = data['id']
-        # Load annotation
-        # if data["grease_pencil"]:
-        #     target.grease_pencil = bpy.data.grease_pencils[data["grease_pencil"]["name"]]
-        # else:
-        #     target.grease_pencil = None
-
-    except Exception as e:
-        logger.error("Scene loading error: {}".format(e))
-
-
-def load_material(target=None, data=None, create=False):
-    try:
-        if target is None:
-            target = bpy.data.materials.new(data["name"])
-
-        if data['is_grease_pencil']:
-            if not target.is_grease_pencil:
-                bpy.data.materials.create_gpencil_data(target)
-
-            dump_anything.load(target.grease_pencil, data['grease_pencil'])
-
-            load_dict(data['grease_pencil'], target.grease_pencil)
-
-        elif data["use_nodes"]:
-            if target.node_tree is None:
-                target.use_nodes = True
-
-            target.node_tree.nodes.clear()
-
-            for node in data["node_tree"]["nodes"]:
-                # fix None node tree error
-
-                index = target.node_tree.nodes.find(node)
-
-                if index is -1:
-                    node_type = data["node_tree"]["nodes"][node]["bl_idname"]
-
-                    target.node_tree.nodes.new(type=node_type)
-
-                dump_anything.load(
-                    target.node_tree.nodes[index], data["node_tree"]["nodes"][node])
-
-                if data["node_tree"]["nodes"][node]['type'] == 'TEX_IMAGE':
-                    target.node_tree.nodes[index].image = bpy.data.images[data["node_tree"]
-                                                                          ["nodes"][node]['image']['name']]
-
-                for input in data["node_tree"]["nodes"][node]["inputs"]:
-
-                    try:
-                        if hasattr(target.node_tree.nodes[index].inputs[input], "default_value"):
-                            target.node_tree.nodes[index].inputs[input].default_value = data[
-                                "node_tree"]["nodes"][node]["inputs"][input]["default_value"]
-                    except Exception as e:
-                        logger.error("Fail loading {} node value from {} ({}) ".format(
-                            target.name, target.node_tree.nodes[index].inputs[input].default_value, e))
-                        continue
-
-            # Load nodes links
-            target.node_tree.links.clear()
-
-            for link in data["node_tree"]["links"]:
-                current_link = data["node_tree"]["links"][link]
-                input_socket = target.node_tree.nodes[current_link['to_node']
-                                                      ['name']].inputs[current_link['to_socket']['name']]
-                output_socket = target.node_tree.nodes[current_link['from_node']
-                                                       ['name']].outputs[current_link['from_socket']['name']]
-
-                target.node_tree.links.new(input_socket, output_socket)
-
-        # Load other meshes metadata
-        # dump_anything.load(target, data)
-
-        target.id = data['id']
-
-    except Exception as e:
-        logger.error("Material loading error: {}".format(e))
-
-
-def load_gpencil_layer(target=None, data=None, create=False):
-
-    dump_anything.load(target, data)
-
-    for frame in data["frames"]:
-        try:
-            tframe = target.frames[frame]
-        except:
-            tframe = target.frames.new(frame)
-        dump_anything.load(tframe, data["frames"][frame])
-        for stroke in data["frames"][frame]["strokes"]:
-            try:
-                tstroke = tframe.strokes[stroke]
-            except:
-                tstroke = tframe.strokes.new()
-            dump_anything.load(
-                tstroke, data["frames"][frame]["strokes"][stroke])
-
-            for point in data["frames"][frame]["strokes"][stroke]["points"]:
-                p = data["frames"][frame]["strokes"][stroke]["points"][point]
-
-                tstroke.points.add(1)
-                tpoint = tstroke.points[len(tstroke.points)-1]
-
-                dump_anything.load(tpoint, p)
-
-
-def load_gpencil(target=None, data=None, create=False):
-    try:
-        if target is None and create:
-            target = bpy.data.grease_pencils.new(data["name"])
-
-        for layer in target.layers:
-            target.layers.remove(layer)
-
-        if "layers" in data.keys():
-            for layer in data["layers"]:
-                if layer not in target.layers.keys():
-                    gp_layer = target.layers.new(data["layers"][layer]["info"])
-                else:
-                    gp_layer = target.layers[layer]
-                load_gpencil_layer(
-                    target=gp_layer, data=data["layers"][layer], create=create)
-
-        dump_anything.load(target, data)
-
-        target.materials.clear()
-        if "materials" in data.keys():
-            for mat in data['materials']:
-                target.materials.append(bpy.data.materials[mat])
-
-        target.id = data['id']
-    except:
-        logger.error("default loadi\ng error")
-
-
-def load_light(target=None, data=None, create=False, type=None):
-    try:
-        if target is None and create:
-            target = bpy.data.lights.new(data["name"], data["type"])
-
-        dump_anything.load(target, data)
-
-        target.id = data['id']
-
-        
-    except Exception as e:
-        logger.error("light loading error: {}".format(e))
-        pass
-
-
-def load_default(target=None, data=None, create=False, type=None):
-    try:
-        if target is None and create:
-            target = getattr(bpy.data, BPY_TYPES[type]).new(data["name"])
-
-        dump_anything.load(target, data)
-
-        target.id = data['id']
-    except Exception as e:
-        logger.error("default loading error {}".format(e))
-
-# DUMP HELPERS
-def dump(key):
-    target = resolve_bpy_path(key)
-    target_type = key.split('/')[0]
-    data = None
-
-    if target_type == 'Image':
-        data = {}
-        data['pixels'] = dump_image(target)
-        dump_datablock_attibutes(target, [], 2, data)
-        data = dump_datablock_attibutes(
-            target, 
-            ["name", 'size', 'height', 'alpha', 'float_buffer', 'filepath', 'source'],
-            2,
-            data)
-    elif target_type == 'Material':
-        data = dump_datablock(target, 2)
-        if target.node_tree:
-            dump_datablock_attibutes(
-                target.node_tree, ["nodes", "links"], 5, data['node_tree'])
-        elif target.grease_pencil:
-            dump_datablock_attibutes(target, ["grease_pencil"], 3, data)
-    elif target_type == 'GreasePencil':
-        data = dump_datablock(target, 2)
-        dump_datablock_attibutes(
-            target, ['layers'], 9, data)
-    elif target_type == 'Camera':
-        data = dump_datablock(target, 1)
-    elif 'Light' in target_type:
-        data = dump_datablock(target, 3)
-    elif target_type == 'Mesh':
-        data = dump_datablock(target, 2)
-        data = dump_mesh(target, data)
-        # dump_datablock_attibutes(
-        # target, ['name', 'polygons', 'edges', 'vertices', 'id'], 6, data)
-
-        # Fix material index
-        m_list = []
-        for m in target.materials:
-            m_list.append(m.name)
-
-        data['material_list'] = m_list
-    elif target_type == 'Curve':
-        data = dump_datablock(target, 1)
-        dump_datablock_attibutes(
-            target, ['splines'], 5, data)
-        # for index, spline in enumerate(target.splines):
-        #     data["splines"][index] = dump_datablock_attibutes(target.splines[index],"Curve/{}".format(index), ["bezier_points", "material_index", "points", "order_u", "order_v", "point_count_u", "point_count_v",
-        #                                                               "radius_interpolation", "resolution_v", "use_bezier_u", "use_bezier_v", "use_cyclic_u", "use_cyclic_v", "use_endpoint_u", "use_endpoint_v"], 3)
-    elif target_type == 'Object':
-        data = dump_datablock(target, 1)
-
-        if hasattr(target,'modifiers'):
-            dump_datablock_attibutes(
-                target, ['modifiers'], 3, data)
-    elif target_type == 'Collection':
-        data = dump_datablock(target, 4)
-    elif target_type == 'Scene':
-        data = dump_datablock_attibutes(
-            target, ['name', 'collection', 'id', 'camera', 'grease_pencil'], 2)
-        dump_datablock_attibutes(
-            target, ['collection'], 4, data)
-
-    # elif target_type == 'Armature':
-    #     data = dump_datablock(target, 4)
-
-    return data
-
-
 def dump_datablock(datablock, depth):
     if datablock:
         dumper = dump_anything.Dumper()
@@ -744,89 +200,6 @@ def dump_datablock_attibutes(datablock=None, attributes=[], depth=1, dickt=None)
         return data
 
 
-def dump_image(image):
-    pixels = None
-    if image.source == "GENERATED":
-        img_name = "{}.png".format(image.name)
-
-        image.filepath_raw = os.path.join(environment.CACHE_DIR, img_name)
-        image.file_format = "PNG"
-        image.save()
-
-    if image.source == "FILE":
-        image.save()
-        file = open(image.filepath_raw, "rb")
-        pixels = file.read()
-        logger.debug("Reading image file {}".format(image.name))
-    else:
-        logger.error("image format not supported")
-    return pixels
-
-
-def dump_mesh(mesh, data={}):
-    import bmesh
-
-    mesh_data = data
-    mesh_buffer = bmesh.new()
-
-    mesh_buffer.from_mesh(mesh)
-
-    uv_layer = mesh_buffer.loops.layers.uv.verify()
-    bevel_layer = mesh_buffer.verts.layers.bevel_weight.verify()
-    skin_layer = mesh_buffer.verts.layers.skin.verify()
-
-    verts = {}
-    for vert in mesh_buffer.verts:
-        v = {}
-        v["co"] = list(vert.co)
-
-        # vert metadata
-        v['bevel'] = vert[bevel_layer]
-        # v['skin'] = list(vert[skin_layer])
-
-        verts[str(vert.index)] = v
-
-    mesh_data["verts"] = verts
-
-    edges = {}
-    for edge in mesh_buffer.edges:
-        e = {}
-        e["verts"] = [edge.verts[0].index, edge.verts[1].index]
-
-        # Edge metadata
-        e["smooth"] = edge.smooth
-
-        edges[edge.index] = e
-    mesh_data["edges"] = edges
-
-    faces = {}
-    for face in mesh_buffer.faces:
-        f = {}
-        fverts = []
-        for vert in face.verts:
-            fverts.append(vert.index)
-
-        f["verts"] = fverts
-        f["material_index"] = face.material_index
-
-        uvs = []
-        # Face metadata
-        for loop in face.loops:
-            loop_uv = loop[uv_layer]
-
-            uvs.append(list(loop_uv.uv))
-
-        f["uv"] = uvs
-        faces[face.index] = f
-
-    mesh_data["faces"] = faces
-
-    uv_layers = []
-    for uv_layer in mesh.uv_layers:
-        uv_layers.append(uv_layer.name)
-
-    mesh_data["uv_layers"] = uv_layers
-    return mesh_data
 
 
 def init_client(key=None):