update sessions presets

.gitignore

@@ -14,5 +14,4 @@ _build
 
 # ignore generated zip generated from blender_addon_tester
 *.zip
-libs
-venv
+libs

.gitlab-ci.yml

@@ -1,8 +1,5 @@
 stages:
   - build
-  - doc
-
 
 include:
-  - local: .gitlab/ci/build.gitlab-ci.yml
-  - local: .gitlab/ci/doc.gitlab-ci.yml
+  - local: .gitlab/ci/build.gitlab-ci.yml

.gitlab/ci/build.gitlab-ci.yml

@@ -7,3 +7,5 @@ build:
     name: multi_user
     paths: 
      - multi_user
+  variables:
+    GIT_SUBMODULE_STRATEGY: recursive

.gitlab/ci/deploy.gitlab-ci.yml

@@ -0,0 +1,21 @@
+deploy:
+  stage: deploy
+  needs: ["build"]
+  image: slumber/docker-python  
+  variables:
+    DOCKER_DRIVER: overlay2
+    DOCKER_TLS_CERTDIR: "/certs"
+    GIT_SUBMODULE_STRATEGY: recursive
+  
+  services:
+  - docker:19.03.12-dind
+
+  script:
+    - RP_VERSION="$(python scripts/get_replication_version.py)"
+    - VERSION="$(python scripts/get_addon_version.py)"
+    - echo "Building docker image with replication ${RP_VERSION}"
+    - docker build --build-arg replication_version=${RP_VERSION}  --build-arg version={VERSION} -t registry.gitlab.com/slumber/multi-user/multi-user-server:${VERSION} ./scripts/docker_server
+    - echo "Pushing to gitlab registry ${VERSION}"
+    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+    - docker tag registry.gitlab.com/slumber/multi-user/multi-user-server:${VERSION} registry.gitlab.com/slumber/multi-user/multi-user-server:${CI_COMMIT_REF_NAME}
+    - docker push registry.gitlab.com/slumber/multi-user/multi-user-server

.gitlab/ci/doc.gitlab-ci.yml

@@ -1,5 +1,6 @@
 pages:
   stage: doc
+  needs: ["deploy"]
   image: python
   script:
   - pip install -U sphinx sphinx_rtd_theme sphinx-material

.gitlab/ci/test.gitlab-ci.yml

@@ -0,0 +1,7 @@
+test:
+  stage: test
+  image: slumber/blender-addon-testing:latest
+  script:
+    - python3 scripts/test_addon.py
+  variables:
+    GIT_SUBMODULE_STRATEGY: recursive

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "multi_user/libs/replication"]
+	path = multi_user/libs/replication
+	url = https://gitlab.com/slumber/replication.git

multi_user/__init__.py

@@ -19,9 +19,9 @@
 bl_info = {
     "name": "Multi-User",
     "author": "Swann Martinez",
-    "version": (0, 6, 0),
+    "version": (0, 5, 8),
     "description": "Enable real-time collaborative workflow inside blender",
-    "blender": (4, 0, 0),
+    "blender": (2, 82, 0),
     "location": "3D View > Sidebar > Multi-User tab",
     "warning": "Unstable addon, use it at your own risks",
     "category": "Collaboration",
@@ -43,8 +43,6 @@ from bpy.app.handlers import persistent
 from . import environment
 
 
-environment.preload_modules()
-
 module_error_msg = "Insufficient rights to install the multi-user \
                 dependencies, aunch blender with administrator rights."
 

multi_user/bl_types/bl_material.py

@@ -28,14 +28,9 @@ from replication.protocol import ReplicatedDatablock
 
 from .bl_datablock import get_datablock_from_uuid, resolve_datablock_from_uuid
 from .bl_action import dump_animation_data, load_animation_data, resolve_animation_dependencies
-from bpy.types import (NodeSocketGeometry, NodeSocketShader, 
-                       NodeSocketVirtual, NodeSocketCollection,
-                       NodeSocketObject, NodeSocketMaterial)
 
 NODE_SOCKET_INDEX = re.compile('\[(\d*)\]')
-IGNORED_SOCKETS = ['NodeSocketGeometry', 'NodeSocketShader', 'CUSTOM', 'NodeSocketVirtual']
-IGNORED_SOCKETS_TYPES = (NodeSocketGeometry, NodeSocketShader, NodeSocketVirtual)
-ID_NODE_SOCKETS = (NodeSocketObject, NodeSocketCollection, NodeSocketMaterial)
+IGNORED_SOCKETS = ['GEOMETRY', 'SHADER', 'CUSTOM']
 
 def load_node(node_data: dict, node_tree: bpy.types.ShaderNodeTree):
     """ Load a node into a node_tree from a dict
@@ -62,23 +57,17 @@ def load_node(node_data: dict, node_tree: bpy.types.ShaderNodeTree):
     if node_tree_uuid:
         target_node.node_tree = get_datablock_from_uuid(node_tree_uuid, None)
 
-    if target_node.bl_idname == 'GeometryNodeRepeatOutput':
-        target_node.repeat_items.clear()
-        for sock_name, sock_type in node_data['repeat_items'].items():
-            target_node.repeat_items.new(sock_type, sock_name)
-
     inputs_data = node_data.get('inputs')
     if inputs_data:
-        inputs = [i for i in target_node.inputs if not isinstance(i, IGNORED_SOCKETS_TYPES)]
+        inputs = [i for i in target_node.inputs if i.type not in IGNORED_SOCKETS]
         for idx, inpt in enumerate(inputs):
             if idx < len(inputs_data) and hasattr(inpt, "default_value"):
                 loaded_input = inputs_data[idx]
                 try:
-                    if isinstance(inpt, ID_NODE_SOCKETS):
+                    if inpt.type in ['OBJECT', 'COLLECTION']:
                         inpt.default_value = get_datablock_from_uuid(loaded_input, None)
                     else:
                         inpt.default_value = loaded_input
-                        setattr(inpt, 'default_value', loaded_input)
                 except Exception as e:
                     logging.warning(f"Node {target_node.name} input {inpt.name} parameter not supported, skipping ({e})")
             else:
@@ -86,12 +75,12 @@ def load_node(node_data: dict, node_tree: bpy.types.ShaderNodeTree):
 
     outputs_data = node_data.get('outputs')
     if outputs_data:
-        outputs = [o for o in target_node.outputs if not isinstance(o, IGNORED_SOCKETS_TYPES)]
+        outputs = [o for o in target_node.outputs if o.type not in IGNORED_SOCKETS]
         for idx, output in enumerate(outputs):
             if idx < len(outputs_data) and hasattr(output, "default_value"):
                 loaded_output = outputs_data[idx]
                 try:
-                    if isinstance(output, ID_NODE_SOCKETS):
+                    if output.type in ['OBJECT', 'COLLECTION']:
                         output.default_value = get_datablock_from_uuid(loaded_output, None)
                     else:
                         output.default_value = loaded_output
@@ -152,7 +141,7 @@ def dump_node(node: bpy.types.ShaderNode) -> dict:
 
         if hasattr(node, 'inputs'):
             dumped_node['inputs'] = []
-            inputs = [i for i in node.inputs if not isinstance(i, IGNORED_SOCKETS_TYPES)]
+            inputs = [i for i in node.inputs if i.type not in IGNORED_SOCKETS]
             for idx, inpt in enumerate(inputs):
                 if hasattr(inpt, 'default_value'):
                     if isinstance(inpt.default_value, bpy.types.ID):
@@ -165,7 +154,7 @@ def dump_node(node: bpy.types.ShaderNode) -> dict:
         if hasattr(node, 'outputs'):
             dumped_node['outputs'] = []
             for idx, output in enumerate(node.outputs):
-                if not isinstance(output, IGNORED_SOCKETS_TYPES):
+                if output.type not in IGNORED_SOCKETS:
                     if hasattr(output, 'default_value'):
                         dumped_node['outputs'].append(
                             io_dumper.dump(output.default_value))
@@ -196,12 +185,6 @@ def dump_node(node: bpy.types.ShaderNode) -> dict:
         dumped_node['image_uuid'] = node.image.uuid
     if hasattr(node, 'node_tree') and getattr(node, 'node_tree'):
         dumped_node['node_tree_uuid'] = node.node_tree.uuid
-    
-    if node.bl_idname == 'GeometryNodeRepeatInput':
-        dumped_node['paired_output'] = node.paired_output.name
-
-    if node.bl_idname == 'GeometryNodeRepeatOutput':
-        dumped_node['repeat_items'] = {item.name: item.socket_type for item in node.repeat_items}
     return dumped_node
 
 
@@ -216,8 +199,10 @@ def load_links(links_data, node_tree):
     """
 
     for link in links_data:
-        input_socket = node_tree.nodes[link['to_node']].inputs[int(link['to_socket'])]
-        output_socket = node_tree.nodes[link['from_node']].outputs[int(link['from_socket'])]
+        input_socket = node_tree.nodes[link['to_node']
+                                       ].inputs[int(link['to_socket'])]
+        output_socket = node_tree.nodes[link['from_node']].outputs[int(
+            link['from_socket'])]
         node_tree.links.new(input_socket, output_socket)
 
 
@@ -250,7 +235,7 @@ def dump_node_tree(node_tree: bpy.types.ShaderNodeTree) -> dict:
     """ Dump a shader node_tree to a dict including links and nodes
 
         :arg node_tree: dumped shader node tree
-        :type node_tree: bpy.types.ShaderNodeTree`
+        :type node_tree: bpy.types.ShaderNodeTree
         :return: dict
     """
     node_tree_data = {
@@ -260,8 +245,9 @@ def dump_node_tree(node_tree: bpy.types.ShaderNodeTree) -> dict:
         'type': type(node_tree).__name__
     }
 
-    sockets = [item for item in node_tree.interface.items_tree if item.item_type == 'SOCKET']
-    node_tree_data['interface'] = dump_node_tree_sockets(sockets)
+    for socket_id in ['inputs', 'outputs']:
+        socket_collection = getattr(node_tree, socket_id)
+        node_tree_data[socket_id] = dump_node_tree_sockets(socket_collection)
 
     return node_tree_data
 
@@ -277,21 +263,18 @@ def dump_node_tree_sockets(sockets: bpy.types.Collection) -> dict:
     """
     sockets_data = []
     for socket in sockets:
-        if not socket.socket_type:
-            logging.error(f"Socket {socket.name} has no type, skipping")
-            raise ValueError(f"Socket {socket.name} has no type, skipping")
-        sockets_data.append(
-            (
-                socket.name, 
-                socket.socket_type,
-                socket.in_out
-            )
-        )
+        try:
+            socket_uuid = socket['uuid']
+        except Exception:
+            socket_uuid = str(uuid4())
+            socket['uuid'] = socket_uuid
+
+        sockets_data.append((socket.name, socket.bl_socket_idname, socket_uuid))
 
     return sockets_data
 
 
-def load_node_tree_sockets(interface: bpy.types.NodeTreeInterface,
+def load_node_tree_sockets(sockets: bpy.types.Collection,
                            sockets_data: dict):
     """ load sockets of a shader_node_tree
 
@@ -302,20 +285,20 @@ def load_node_tree_sockets(interface: bpy.types.NodeTreeInterface,
         :arg socket_data: dumped socket data
         :type socket_data: dict
     """
-    # Remove old sockets
-    interface.clear()    
+    # Check for removed sockets
+    for socket in sockets:
+        if not [s for s in sockets_data if 'uuid' in socket and socket['uuid'] == s[2]]:
+            sockets.remove(socket)
 
     # Check for new sockets
-    for name, socket_type, in_out  in sockets_data:
-        if not socket_type:
-            logging.error(f"Socket {name} has no type, skipping")
-            continue
-        socket = interface.new_socket(
-            name,
-            in_out=in_out,
-            socket_type=socket_type
-        )
-  
+    for idx, socket_data in enumerate(sockets_data):
+        try:
+            checked_socket = sockets[idx]
+            if checked_socket.name != socket_data[0]:
+                checked_socket.name = socket_data[0]
+        except Exception:
+            s = sockets.new(socket_data[1], socket_data[0])
+            s['uuid'] = socket_data[2]
 
 
 def load_node_tree(node_tree_data: dict, target_node_tree: bpy.types.ShaderNodeTree) -> dict:
@@ -332,8 +315,13 @@ def load_node_tree(node_tree_data: dict, target_node_tree: bpy.types.ShaderNodeT
     if not target_node_tree.is_property_readonly('name'):
         target_node_tree.name = node_tree_data['name']
 
-    if 'interface' in node_tree_data:
-        load_node_tree_sockets(target_node_tree.interface, node_tree_data['interface'])
+    if 'inputs' in node_tree_data:
+        socket_collection = getattr(target_node_tree, 'inputs')
+        load_node_tree_sockets(socket_collection, node_tree_data['inputs'])
+
+    if 'outputs' in node_tree_data:
+        socket_collection = getattr(target_node_tree,  'outputs')
+        load_node_tree_sockets(socket_collection, node_tree_data['outputs'])
 
     # Load nodes
     for node in node_tree_data["nodes"]:
@@ -347,15 +335,6 @@ def load_node_tree(node_tree_data: dict, target_node_tree: bpy.types.ShaderNodeT
             target_node.parent =  target_node_tree.nodes[node_data['parent']]
         else:
             target_node.parent = None
-
-    # Load geo node repeat zones
-    zone_input_to_pair = [node_data for node_data in node_tree_data["nodes"].values() if node_data['bl_idname'] == 'GeometryNodeRepeatInput']
-    for node_input_data in zone_input_to_pair:
-        zone_input = target_node_tree.nodes.get(node_input_data['name'])
-        zone_output = target_node_tree.nodes.get(node_input_data['paired_output'])
-
-        zone_input.pair_with_output(zone_output)
-
     # TODO: load only required nodes links
     # Load nodes links
     target_node_tree.links.clear()

multi_user/bl_types/bl_mesh.py

@@ -37,6 +37,8 @@ VERTICE = ['co']
 
 EDGE = [
     'vertices',
+    'crease',
+    'bevel_weight',
     'use_seam',
     'use_edge_sharp',
 ]
@@ -52,18 +54,6 @@ POLYGON = [
     'material_index',
 ]
 
-GENERIC_ATTRIBUTES =[
-    'crease_vert',
-    'crease_edge',
-    'bevel_weight_vert',
-    'bevel_weight_edge'
-]
-
-GENERIC_ATTRIBUTES_ENSURE = {
-    'crease_vert': 'vertex_crease_ensure',
-    'crease_edge': 'edge_crease_ensure'
-}
-
 class BlMesh(ReplicatedDatablock):
     use_delta = True
 
@@ -128,17 +118,7 @@ class BlMesh(ReplicatedDatablock):
                         datablock.vertex_colors[color_layer].data, 
                         'color', 
                         data["vertex_colors"][color_layer]['data'])
-            
-            # Generic attibutes
-            for attribute_name, attribute_data_type, attribute_domain, attribute_data in data["attributes"]:
-                if attribute_name not in datablock.attributes:
-                    datablock.attributes.new(
-                        attribute_name,
-                        attribute_data_type,
-                        attribute_domain
-                    )
-                np_load_collection(attribute_data, datablock.attributes[attribute_name].data ,['value'])
-                    
+
             datablock.validate()
             datablock.update()
 
@@ -155,6 +135,7 @@ class BlMesh(ReplicatedDatablock):
             'use_auto_smooth',
             'auto_smooth_angle',
             'use_customdata_edge_bevel',
+            'use_customdata_edge_crease'
         ]
 
         data = dumper.dump(mesh)
@@ -169,21 +150,6 @@ class BlMesh(ReplicatedDatablock):
         data["egdes_count"] = len(mesh.edges)
         data["edges"] = np_dump_collection(mesh.edges, EDGE)
 
-        # ATTIBUTES
-        data["attributes"] = []
-        for attribute_name in GENERIC_ATTRIBUTES:
-            if attribute_name in datablock.attributes:
-                attribute_data = datablock.attributes.get(attribute_name)
-                dumped_attr_data = np_dump_collection(attribute_data.data, ['value'])
-
-                data["attributes"].append(
-                    (
-                        attribute_name,
-                        attribute_data.data_type,
-                        attribute_data.domain,
-                        dumped_attr_data
-                    )
-                )
         # POLYGONS
         data["poly_count"] = len(mesh.polygons)
         data["polygons"] = np_dump_collection(mesh.polygons, POLYGON)

multi_user/bl_types/bl_object.py

@@ -58,17 +58,23 @@ else:
 
 def get_node_group_properties_identifiers(node_group):
     props_ids = []
-    
-    for socket in node_group.interface.items_tree:
-        if socket.socket_type in IGNORED_SOCKETS:
+    # Inputs
+    for inpt in node_group.inputs:
+        if inpt.type in IGNORED_SOCKETS:
             continue
         else:
-            props_ids.append((socket.identifier, socket.socket_type))
-        
-        props_ids.append((f"{socket.identifier}_attribute_name",'NodeSocketString'))
-        props_ids.append((f"{socket.identifier}_use_attribute", 'NodeSocketBool'))
+            props_ids.append((inpt.identifier, inpt.type))
+
+        if inpt.type in ['INT', 'VALUE', 'BOOLEAN', 'RGBA', 'VECTOR']:
+            props_ids.append((f"{inpt.identifier}_attribute_name",'STR'))
+            props_ids.append((f"{inpt.identifier}_use_attribute", 'BOOL'))
+
+    for outpt in node_group.outputs:
+        if outpt.type not in IGNORED_SOCKETS and  outpt.type in ['INT', 'VALUE', 'BOOLEAN', 'RGBA', 'VECTOR']:
+            props_ids.append((f"{outpt.identifier}_attribute_name", 'STR'))
 
     return props_ids
+    # return [inpt.identifer for inpt in node_group.inputs if  inpt.type not in IGNORED_SOCKETS]
 
 
 def dump_physics(target: bpy.types.Object)->dict:
@@ -113,21 +119,17 @@ def load_physics(dumped_settings: dict, target: bpy.types.Object):
 
     if 'rigid_body' in dumped_settings:
         if not target.rigid_body:
-            with bpy.context.temp_override(object=target):
-                bpy.ops.rigidbody.object_add()
+            bpy.ops.rigidbody.object_add({"object": target})
         loader.load(target.rigid_body, dumped_settings['rigid_body'])
     elif target.rigid_body:
-        with bpy.context.temp_override(object=target):
-            bpy.ops.rigidbody.object_remove()
+        bpy.ops.rigidbody.object_remove({"object": target})
 
     if 'rigid_body_constraint' in dumped_settings:
         if not target.rigid_body_constraint:
-            with bpy.context.temp_override(object=target):
-                bpy.ops.rigidbody.constraint_add()
+            bpy.ops.rigidbody.constraint_add({"object": target})
         loader.load(target.rigid_body_constraint, dumped_settings['rigid_body_constraint'])
     elif target.rigid_body_constraint:
-        with bpy.context.temp_override(object=target):
-            bpy.ops.rigidbody.constraint_remove()
+        bpy.ops.rigidbody.constraint_remove({"object": target})
 
 
 def dump_modifier_geometry_node_props(modifier: bpy.types.Modifier) -> list:
@@ -138,11 +140,11 @@ def dump_modifier_geometry_node_props(modifier: bpy.types.Modifier) -> list:
     """
     dumped_props = []
     
-    for prop_id, prop_type in get_node_group_properties_identifiers(modifier.node_group):
+    for prop_value, prop_type in get_node_group_properties_identifiers(modifier.node_group):
         try:
-            prop_value = modifier[prop_id]
+            prop_value = modifier[prop_value]
         except KeyError as e:
-            logging.error(f"fail to dump geomety node modifier property : {prop_id} ({e})")
+            logging.error(f"fail to dump geomety node modifier property : {prop_value} ({e})")
         else:
             dump = None
             if isinstance(prop_value, bpy.types.ID):
@@ -153,6 +155,7 @@ def dump_modifier_geometry_node_props(modifier: bpy.types.Modifier) -> list:
                 dump = prop_value.to_list()
 
             dumped_props.append((dump, prop_type))
+            # logging.info(prop_value)
 
     return dumped_props
 
@@ -169,12 +172,13 @@ def load_modifier_geometry_node_props(dumped_modifier: dict, target_modifier: bp
     for input_index, inpt in enumerate(get_node_group_properties_identifiers(target_modifier.node_group)):
         dumped_value, dumped_type = dumped_modifier['props'][input_index]
         input_value = target_modifier[inpt[0]]
-        if dumped_type in ['NodeSocketInt', 'NodeSocketFloat', 'NodeSocketString', 'NodeSocketBool']:
+        if dumped_type in ['INT', 'VALUE', 'STR', 'BOOL']:
+            logging.info(f"{inpt[0]}/{dumped_value}")
             target_modifier[inpt[0]] = dumped_value
-        elif dumped_type in ['NodeSocketColor', 'NodeSocketVector']:
+        elif dumped_type in ['RGBA', 'VECTOR']:
             for index in range(len(input_value)):
                 input_value[index] = dumped_value[index]
-        elif dumped_type in ['NodeSocketCollection', 'NodeSocketObject', 'NodeSocketImage', 'NodeSocketTexture', 'NodeSocketMaterial']:
+        elif dumped_type in ['COLLECTION', 'OBJECT', 'IMAGE', 'TEXTURE', 'MATERIAL']:
             target_modifier[inpt[0]] = get_datablock_from_uuid(dumped_value, None)
 
 
@@ -575,6 +579,16 @@ class BlObject(ReplicatedDatablock):
         if 'pose' in data:
             if not datablock.pose:
                 raise Exception('No pose data yet (Fixed in a near futur)')
+            # Bone groups
+            for bg_name in data['pose']['bone_groups']:
+                bg_data = data['pose']['bone_groups'].get(bg_name)
+                bg_target = datablock.pose.bone_groups.get(bg_name)
+
+                if not bg_target:
+                    bg_target = datablock.pose.bone_groups.new(name=bg_name)
+
+                loader.load(bg_target, bg_data)
+                # datablock.pose.bone_groups.get
 
             # Bones
             for bone in data['pose']['bones']:
@@ -586,6 +600,9 @@ class BlObject(ReplicatedDatablock):
 
                 load_pose(target_bone, bone_data)
 
+                if 'bone_index' in bone_data.keys():
+                    target_bone.bone_group = datablock.pose.bone_group[bone_data['bone_group_index']]
+
         # TODO: find another way...
         if datablock.empty_display_type == "IMAGE":
             img_uuid = data.get('data_uuid')
@@ -725,6 +742,7 @@ class BlObject(ReplicatedDatablock):
                 bones[bone.name] = {}
                 dumper.depth = 1
                 rotation = 'rotation_quaternion' if bone.rotation_mode == 'QUATERNION' else 'rotation_euler'
+                group_index = 'bone_group_index' if bone.bone_group else None
                 dumper.include_filter = [
                     'rotation_mode',
                     'location',
@@ -732,6 +750,7 @@ class BlObject(ReplicatedDatablock):
                     'custom_shape',
                     'use_custom_shape_bone_size',
                     'custom_shape_scale',
+                    group_index,
                     rotation
                 ]
                 bones[bone.name] = dumper.dump(bone)
@@ -742,6 +761,17 @@ class BlObject(ReplicatedDatablock):
 
             data['pose'] = {'bones': bones}
 
+            # GROUPS
+            bone_groups = {}
+            for group in datablock.pose.bone_groups:
+                dumper.depth = 3
+                dumper.include_filter = [
+                    'name',
+                    'color_set'
+                ]
+                bone_groups[group.name] = dumper.dump(group)
+            data['pose']['bone_groups'] = bone_groups
+
         # VERTEx GROUP
         if len(datablock.vertex_groups) > 0:
             data['vertex_groups'] = dump_vertex_groups(datablock)

multi_user/bl_types/dump_anything.py

@@ -26,8 +26,8 @@ import numpy as np
 BPY_TO_NUMPY_TYPES = {
     'FLOAT': np.float32,
     'INT': np.int32,
-    'BOOL': bool,
-    'BOOLEAN': bool}
+    'BOOL': np.bool,
+    'BOOLEAN': np.bool}
 
 PRIMITIVE_TYPES = ['FLOAT', 'INT', 'BOOLEAN']
 

multi_user/environment.py

@@ -29,6 +29,15 @@ import bpy
 VERSION_EXPR = re.compile('\d+.\d+.\d+')
 DEFAULT_CACHE_DIR = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), "cache")
+REPLICATION_DEPENDENCIES = {
+    ("pyzmq", "25.0.0"),
+    ("deepdiff","5.7.0"),
+}
+LIBS = os.path.join(os.path.dirname(os.path.abspath(__file__)), "libs")
+REPLICATION = os.path.join(LIBS,"replication")
+
+PYTHON_PATH = None
+SUBPROCESS_DIR = None
 
 rtypes = []
 
@@ -41,20 +50,40 @@ def module_can_be_imported(name: str) -> bool:
         return False
 
 
-def install_pip(python_path):
+def install_pip():
     # pip can not necessarily be imported into Blender after this
-    subprocess.run([str(python_path), "-m", "ensurepip"])
+    subprocess.run([str(PYTHON_PATH), "-m", "ensurepip"])
 
 
-def preload_modules():
-    from . import wheels
+def install_package(name: str, version:str=None, install_dir: str=None):
+    logging.info(f"installing {name} version...")
+    env = os.environ
+    if "PIP_REQUIRE_VIRTUALENV" in env:
+        # PIP_REQUIRE_VIRTUALENV is an env var to ensure pip cannot install packages outside a virtual env
+        # https://docs.python-guide.org/dev/pip-virtualenv/
+        # But since Blender's pip is outside of a virtual env, it can block our packages installation, so we unset the
+        # env var for the subprocess.
+        env = os.environ.copy()
+        del env["PIP_REQUIRE_VIRTUALENV"]
+    module_name = f"{name}" if version is None else f"{name}=={version}"
+    subprocess.run([str(PYTHON_PATH), "-m", "pip", "install", module_name, "-t", install_dir], env=env)
 
-    wheels.load_wheel_global("ordered_set", "ordered_set")
-    wheels.load_wheel_global("deepdiff", "deepdiff")
-    wheels.load_wheel_global("replication", "replication")
-    wheels.load_wheel_global("zmq", "pyzmq", match_platform=True)
+    if name in sys.modules:
+        del sys.modules[name]
 
 
+def check_package_version(name: str, required_version: str):
+    logging.info(f"Checking {name} version...")
+    out = subprocess.run([str(PYTHON_PATH), "-m", "pip", "show", name], capture_output=True)
+
+    version = VERSION_EXPR.search(out.stdout.decode())
+    if version and version.group() == required_version:
+        logging.info(f"{name} is up to date")
+        return True
+    else:
+        logging.info(f"{name} need an update")
+        return False
+
 
 def get_ip():
     """
@@ -89,10 +118,34 @@ def remove_paths(paths: list):
         if path in sys.path:
             logging.debug(f"Removing {path} dir from the path.")
             sys.path.remove(path)
-      
+
+
+def install_modules(dependencies: tuple, python_path: str, install_dir: str):
+    global PYTHON_PATH, SUBPROCESS_DIR
+
+    PYTHON_PATH = Path(python_path)
+    SUBPROCESS_DIR = PYTHON_PATH.parent
+
+    if not module_can_be_imported("pip"):
+        install_pip()
+
+    for package_name, package_version in dependencies:
+        if not module_can_be_imported(package_name):
+            install_package(package_name, version=package_version, install_dir=install_dir)
+            module_can_be_imported(package_name)
 
 def register():
-    check_dir(DEFAULT_CACHE_DIR)
+    if bpy.app.version >= (2,91,0):
+            python_binary_path = sys.executable
+    else:
+        python_binary_path = bpy.app.binary_path_python
+
+    for module_name in list(sys.modules.keys()):
+        if 'replication' in module_name:
+            del sys.modules[module_name]
+
+    setup_paths([LIBS, REPLICATION])
+    install_modules(REPLICATION_DEPENDENCIES, python_binary_path, install_dir=LIBS)
 
 def unregister():
-    pass
+    remove_paths([REPLICATION, LIBS])

multi_user/handlers.py

@@ -81,9 +81,9 @@ def on_scene_update(scene):
 
         # NOTE: maybe we don't need to check each update but only the first
         for update in reversed(dependency_updates):
-            update_uuid = getattr(update.id.original, 'uuid', None)
+            update_uuid = getattr(update.id, 'uuid', None)
             if update_uuid:
-                node = session.repository.graph.get(update_uuid)
+                node = session.repository.graph.get(update.id.uuid)
                 check_common = session.repository.rdp.get_implementation(update.id).bl_check_common
 
                 if node and (node.owner == session.repository.username or check_common):
@@ -133,7 +133,7 @@ def load_pre_handler(dummy):
 
 @persistent
 def update_client_frame(scene):
-    if session and session.state == STATE_ACTIVE:
+    if session and session.state == STATE_ACTIVE and bpy.context.screen and not bpy.context.screen.is_animation_playing:
         porcelain.update_user_metadata(session.repository, {
             'frame_current': scene.frame_current
         })

multi_user/operators.py

@@ -16,20 +16,27 @@
 # ##### END GPL LICENSE BLOCK #####
 
 
-
+import asyncio
+import copy
 import gzip
 import logging
-
+from multi_user.preferences import ServerPreset
 import os
+import queue
+import random
+import shutil
+import string
 import sys
-
+import time
 import traceback
 from uuid import uuid4
 from datetime import datetime
-
+from operator import itemgetter
 from pathlib import Path
 from queue import Queue
+from time import gmtime, strftime
 
+from bpy.props import FloatProperty
 import bmesh
 
 try:
@@ -39,11 +46,15 @@ except ImportError:
 
 import bpy
 import mathutils
-
+from bpy.app.handlers import persistent
 from bpy_extras.io_utils import ExportHelper, ImportHelper
 from replication import porcelain
-from replication.constants import (FETCHED, RP_COMMON, STATE_ACTIVE)
+from replication.constants import (COMMITED, FETCHED, RP_COMMON, STATE_ACTIVE,
+                                   STATE_INITIAL, STATE_SYNCING, UP)
+from replication.exception import ContextError, NonAuthorizedOperationError
 from replication.interface import session
+from replication.objects import Node
+from replication.protocol import DataTranslationProtocol
 from replication.repository import Repository
 
 from . import bl_types, environment, shared_data, timers, ui, utils
@@ -238,9 +249,6 @@ def on_connection_end(reason="none"):
 
     if on_scene_update in bpy.app.handlers.depsgraph_update_post:
         bpy.app.handlers.depsgraph_update_post.remove(on_scene_update)
-    
-    renderer.clear_widgets()
-    renderer.add_widget("session_status", SessionStatusWidget())
 
     # Step 3: remove file handled
     logger = logging.getLogger()
@@ -289,17 +297,20 @@ def setup_timer():
     session_user_sync = timers.SessionUserSync()
     session_background_executor = timers.MainThreadExecutor(execution_queue=background_execution_queue)
     session_listen = timers.SessionListenTimer(timeout=0.001)
+    session_frame_sync = timers.SessionFrameSync(timeout=1)
 
     session_listen.register()
     session_update.register()
     session_user_sync.register()
     session_background_executor.register()
+    session_frame_sync.register()
 
     deleyables.append(session_background_executor)
     deleyables.append(session_update)
     deleyables.append(session_user_sync)
     deleyables.append(session_listen)
     deleyables.append(timers.AnnotationUpdates())
+    deleyables.append(session_frame_sync)
 
 def get_active_server_preset(context):
     active_index = context.window_manager.server_index

multi_user/preferences.py

@@ -44,6 +44,27 @@ DEFAULT_PRESETS = {
         "admin_password": "admin",
         "server_password": ""
     },
+    "NTHU Session 1" : {
+        "server_name": "Session 1",
+        "ip": "31.38.153.178",
+        "port": 5555,
+        "admin_password": "",
+        "server_password": ""
+    },
+        "NTHU Session 2" : {
+        "server_name": "Session 2",
+        "ip": "31.38.153.178",
+        "port": 5655,
+        "admin_password": "",
+        "server_password": ""
+    },
+        "NTHU Session 3" : {
+        "server_name": "Session 3",
+        "ip": "31.38.153.178",
+        "port": 5755,
+        "admin_password": "",
+        "server_password": ""
+    }
 }
 
 def randomColor():

multi_user/presence.py

@@ -67,10 +67,8 @@ def refresh_sidebar_view():
     """
     area, region, rv3d = view3d_find()
 
-    if area is not None :
-        for region in area.regions:
-            if region.type == "UI":
-                region.tag_redraw()
+    if area:
+        area.regions[3].tag_redraw()
 
 
 def project_to_viewport(region: bpy.types.Region, rv3d: bpy.types.RegionView3D, coords: list, distance: float = 1.0) -> list:
@@ -255,9 +253,10 @@ class Widget(object):
         return True
 
     def configure_bgl(self):
-        gpu.state.line_width_set(2.0)
-        gpu.state.depth_test_set("LESS")
-        gpu.state.blend_set("ALPHA")
+        bgl.glLineWidth(2.)
+        bgl.glEnable(bgl.GL_DEPTH_TEST)
+        bgl.glEnable(bgl.GL_BLEND)
+        bgl.glEnable(bgl.GL_LINE_SMOOTH)
 
 
     def draw(self):
@@ -301,8 +300,7 @@ class UserFrustumWidget(Widget):
 
     def draw(self):
         location = self.data.get('view_corners')
-        shader = gpu.shader.from_builtin('UNIFORM_COLOR')
-        # 'FLAT_COLOR', 'IMAGE', 'IMAGE_COLOR', 'SMOOTH_COLOR', 'UNIFORM_COLOR', 'POLYLINE_FLAT_COLOR', 'POLYLINE_SMOOTH_COLOR', 'POLYLINE_UNIFORM_COLOR'
+        shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
         positions = [tuple(coord) for coord in location]
 
         if len(positions) != 7:
@@ -374,7 +372,7 @@ class UserSelectionWidget(Widget):
             vertex_pos += bbox_pos
             vertex_ind += bbox_ind
 
-        shader = gpu.shader.from_builtin('UNIFORM_COLOR')
+        shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
         batch = batch_for_shader(
             shader,
             'LINES',
@@ -423,7 +421,7 @@ class UserNameWidget(Widget):
 
         if coords:
             blf.position(0, coords[0], coords[1]+10, 0)
-            blf.size(0, 16)
+            blf.size(0, 16, 72)
             blf.color(0, color[0], color[1], color[2], color[3])
             blf.draw(0,  self.username)
 
@@ -479,7 +477,7 @@ class UserModeWidget(Widget):
 
         if origin_coord :
             blf.position(0, origin_coord[0]+8, origin_coord[1]-15, 0)
-            blf.size(0, 16)
+            blf.size(0, 16, 72)
             blf.color(0, color[0], color[1], color[2], color[3])
             blf.draw(0,  mode_current)        
 
@@ -513,7 +511,7 @@ class SessionStatusWidget(Widget):
         vpos = (self.preferences.presence_hud_vpos*bpy.context.area.height)/100
 
         blf.position(0, hpos, vpos, 0)
-        blf.size(0, int(text_scale*ui_scale))
+        blf.size(0, int(text_scale*ui_scale), 72)
         blf.color(0, color[0], color[1], color[2], color[3])
         blf.draw(0,  state_str)
 

multi_user/timers.py

@@ -177,6 +177,7 @@ class AnnotationUpdates(Timer):
                                     affect_dependencies=False)
                     self._annotating = False
 
+
 class DynamicRightSelectTimer(Timer):
     def __init__(self, timeout=.1):
         super().__init__(timeout)
@@ -266,7 +267,7 @@ class DynamicRightSelectTimer(Timer):
 
 
 class ClientUpdate(Timer):
-    def __init__(self, timeout=.1):
+    def __init__(self, timeout=1):
         super().__init__(timeout)
         self.handle_quit = False
         self.users_metadata = {}
@@ -387,3 +388,12 @@ class MainThreadExecutor(Timer):
             function, kwargs = self.execution_queue.get()
             logging.debug(f"Executing {function.__name__}")
             function(**kwargs)
+
+    
+class SessionFrameSync(Timer):
+    def execute(self):
+        if session and session.state == STATE_ACTIVE:
+            if bpy.context.screen and bpy.context.screen.is_animation_playing:
+                porcelain.update_user_metadata(session.repository, {
+                    'frame_current': bpy.context.scene.frame_current
+                })

multi_user/ui.py

@@ -32,7 +32,6 @@ from replication.constants import (ADDED, ERROR, FETCHED,
 from replication import __version__
 from replication.interface import session
 from .timers import registry
-from . import icons
 
 ICONS_PROP_STATES = ['TRIA_DOWN',  # ADDED
                      'TRIA_UP',  # COMMITED
@@ -110,6 +109,7 @@ class SESSION_PT_settings(bpy.types.Panel):
         layout = self.layout
         settings = get_preferences()
 
+        from multi_user import icons
         offline_icon = icons.icons_col["session_status_offline"]
         waiting_icon = icons.icons_col["session_status_waiting"]
         online_icon = icons.icons_col["session_status_online"]
@@ -531,7 +531,7 @@ def draw_property(context, parent, property_uuid, level=0):
     have_right_to_modify = (item.owner == settings.username or \
         item.owner == RP_COMMON) and item.state != ERROR
 
-    
+    from multi_user import icons
     sync_status = icons.icons_col["repository_push"] #TODO: Link all icons to the right sync (push/merge/issue). For issue use "UNLINKED" for icon
     # sync_status = icons.icons_col["repository_merge"]
 
@@ -727,7 +727,7 @@ class SESSION_UL_network(bpy.types.UIList):
         else:
             split.label(text=server_name)
 
-        from . import icons
+        from multi_user import icons
         server_status = icons.icons_col["server_offline"]
         if item.is_online:
             server_status = icons.icons_col["server_online"]

multi_user/wheels/__init__.py

@@ -1,149 +0,0 @@
-"""External dependencies loader."""
-
-import contextlib
-import importlib
-from pathlib import Path
-import sys
-import logging
-import sysconfig
-from types import ModuleType
-from typing import Iterator, Iterable
-import zipfile
-
-
-_my_dir = Path(__file__).parent
-_log = logging.getLogger(__name__)
-_env_folder = Path(__file__).parent.joinpath("venv")
-
-def load_wheel(module_name: str, submodules: Iterable[str]) -> list[ModuleType]:
-    """Loads modules from a wheel file 'module_name*.whl'.
-
-    Loads `module_name`, and if submodules are given, loads
-    `module_name.submodule` for each of the submodules. This allows loading all
-    required modules from the same wheel in one session, ensuring that
-    inter-submodule references are correct.
-
-    Returns the loaded modules, so [module, submodule, submodule, ...].
-    """
-
-    fname_prefix = _fname_prefix_from_module_name(module_name)
-    wheel = _wheel_filename(fname_prefix)
-
-    loaded_modules: list[ModuleType] = []
-    to_load = [module_name] + [f"{module_name}.{submodule}" for submodule in submodules]
-
-    # Load the module from the wheel file. Keep a backup of sys.path so that it
-    # can be restored later. This should ensure that future import statements
-    # cannot find this wheel file, increasing the separation of dependencies of
-    # this add-on from other add-ons.
-    with _sys_path_mod_backup(wheel):
-        for modname in to_load:
-            try:
-                module = importlib.import_module(modname)
-            except ImportError as ex:
-                raise ImportError(
-                    "Unable to load %r from %s: %s" % (modname, wheel, ex)
-                ) from None
-            assert isinstance(module, ModuleType)
-            loaded_modules.append(module)
-            _log.info("Loaded %s from %s", modname, module.__file__)
-
-    assert len(loaded_modules) == len(
-        to_load
-    ), f"expecting to load {len(to_load)} modules, but only have {len(loaded_modules)}: {loaded_modules}"
-    return loaded_modules
-
-
-def load_wheel_global(module_name: str, fname_prefix: str = "", match_platform: bool = False) -> ModuleType:
-    """Loads a wheel from 'fname_prefix*.whl', unless the named module can be imported.
-
-    This allows us to use system-installed packages before falling back to the shipped wheels.
-    This is useful for development, less so for deployment.
-
-    If `fname_prefix` is the empty string, it will use the first package from `module_name`.
-    In other words, `module_name="pkg.subpkg"` will result in `fname_prefix="pkg"`.
-    """
-
-    if not fname_prefix:
-        fname_prefix = _fname_prefix_from_module_name(module_name)
-
-    try:
-        module = importlib.import_module(module_name)
-    except ImportError as ex:
-        _log.debug("Unable to import %s directly, will try wheel: %s", module_name, ex)
-    else:
-        _log.debug(
-            "Was able to load %s from %s, no need to load wheel %s",
-            module_name,
-            module.__file__,
-            fname_prefix,
-        )
-        return module
-
-    wheel = _wheel_filename(fname_prefix, match_platform=match_platform)
-
-    wheel_filepath = str(wheel)
-
-
-    wheel_archive = zipfile.ZipFile(wheel_filepath)
-
-    
-    wheel_archive.extractall(_env_folder)
-
-    if str(_env_folder) not in sys.path:
-        sys.path.insert(0, str(_env_folder))
-
-    try:
-        module = importlib.import_module(module_name)
-    except ImportError as ex:
-        raise ImportError(
-            "Unable to load %r from %s: %s" % (module_name, wheel, ex)
-        ) from None
-
-    _log.debug("Globally loaded %s from %s", module_name, module.__file__)
-    return module
-
-
-@contextlib.contextmanager
-def _sys_path_mod_backup(wheel_file: Path) -> Iterator[None]:
-    """Temporarily inserts a wheel onto sys.path.
-
-    When the context exits, it restores sys.path and sys.modules, so that
-    anything that was imported within the context remains unimportable by other
-    modules.
-    """
-    old_syspath = sys.path[:]
-    old_sysmod = sys.modules.copy()
-
-    try:
-        sys.path.insert(0, str(wheel_file))
-        yield
-    finally:
-        # Restore without assigning a new list instance. That way references
-        # held by other code will stay valid.
-        sys.path[:] = old_syspath
-        sys.modules.clear()
-        sys.modules.update(old_sysmod)
-
-
-def _wheel_filename(fname_prefix: str, match_platform: bool = False) -> Path:
-    if match_platform:
-        platform_tag = sysconfig.get_platform().replace('-','_').replace('.','_')
-        path_pattern = f"{fname_prefix}*{platform_tag}.whl"
-    else:
-        path_pattern = f"{fname_prefix}*.whl"
-    wheels: list[Path] = list(_my_dir.glob(path_pattern))
-    if not wheels:
-        raise RuntimeError("Unable to find wheel at %r" % path_pattern)
-
-    # If there are multiple wheels that match, load the last-modified one.
-    # Alphabetical sorting isn't going to cut it since BAT 1.10 was released.
-    def modtime(filepath: Path) -> float:
-        return filepath.stat().st_mtime
-
-    wheels.sort(key=modtime)
-    return wheels[-1]
-
-
-def _fname_prefix_from_module_name(module_name: str) -> str:
-    return module_name.split(".", 1)[0]