feat(rcf_: added basic user info replication

__init__.py

@@ -9,6 +9,7 @@ bl_info = {
 }
 
 from .libs.bsyncio import bsyncio
+
 from . import net_operators
 from . import net_ui
 import bpy

net_components.py

@@ -1,6 +1,7 @@
 import zmq
 import asyncio
 import logging
+from .libs.esper import esper
 from .libs import umsgpack
 import time
 import random
@@ -55,24 +56,11 @@ class RCFStore(collections.MutableMapping,dict):
     def __init__(self, custom_factory=RCFFactory()):
         super().__init__() 
         self.factory = custom_factory
-        print("name {}".format(custom_factory.__class__.__name__))
         
     def __getitem__(self,key):
-        # if self[key]:
-            # Get dict data from external
-            # print("getting item from store")
         return dict.__getitem__(self,key)
 
     def __setitem__(self, key, value):
-        #test
-        # TODO: test with try - except KeyError
-        # if key in self:
-        #     # Set dict data from external
-        #     dict.__setitem__(self,key,value)
-        # else:
-        #     print("{}".format(value))
-        #     self.factory.init(value)
-
         dict.__setitem__(self,key,value)
            
     def __delitem__(self, key):
@@ -106,10 +94,11 @@ class RCFMessage(object):
         self.pointer = pointer
         self.get = None
         self.set = None
+        
     def store(self, dikt):
         """Store me in a dict if I have anything to store"""
         # this currently erasing old value
-        if self.key is not None and self.body is not None:
+        if self.key is not None:
             dikt[self.key] = self
 
     def send(self, socket):
@@ -227,9 +216,13 @@ class Client():
 
         for f in self.on_post_init:
             f()
-
+        
         logger.info("{} client running".format(id))
 
+        self.push_update("net/clients/{}".format(self.id.decode()),"client",None)
+    
+
+
         # Main loop
         while True:
             # TODO: find a better way

net_operators.py

@@ -92,7 +92,6 @@ def resolve_bpy_path(path):
     Get bpy property value from path
     """
 
-    t = time.perf_counter()
     path = path.split('/')
 
     obj = None
@@ -112,27 +111,32 @@ def resolve_bpy_path(path):
 def observer():
     global client
 
-    try:
-        for key, values in client.property_map.items():
-            # if values.id == client.id:
-            obj, attr = resolve_bpy_path(key)
+   
+    for key, values in client.property_map.items():
+        if client.id in key:
+            #client position update 
+            pass
+        else:
+            try:
+                obj, attr = resolve_bpy_path(key)
+
+                if attr != to_bpy(client.property_map[key]):
+                    value_type, value = from_bpy(attr)
+                    client.push_update(key, value_type, value)
+            except:
+                pass
 
-            if attr != to_bpy(client.property_map[key]):
-                value_type, value = from_bpy(attr)
-                client.push_update(key, value_type, value)
-    except:
-        pass
     return bpy.context.scene.session_settings.update_frequency
 
-
-# CLIENT-SERVER
 def refresh_window():
     import bpy
 
     bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)
 
+def init_scene(msg):
+    pass
 
-def patch_scene(msg):
+def update_scene(msg):
     global client
 
     if msg.id != client.id:
@@ -152,8 +156,13 @@ def patch_scene(msg):
     else:
         logger.debug('no need to update scene on our own')
 
+def update_ui(msg):
+    """
+    Update collaborative UI elements
+    """
+    pass
 
-recv_callbacks = [patch_scene]
+recv_callbacks = [update_scene,update_ui]
 post_init_callbacks = [refresh_window]
 
 
@@ -190,6 +199,7 @@ class session_join(bpy.types.Operator):
         bpy.ops.asyncio.loop()
         bpy.app.timers.register(observer)
 
+
         net_settings.is_running = True
         return {"FINISHED"}
 

net_ui.py

@@ -23,6 +23,22 @@ def get_target(region, rv3d,coord):
     ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)
     return  ray_origin +view_vector
 
+def get_client_view_rect():
+    area, region, rv3d = view3d_find()
+
+    width = region.width
+    height = region.height
+
+    v1 = get_target(region,rv3d,(0,0))
+    v3 = get_target(region,rv3d,(0,height))
+    v2 = get_target(region,rv3d,(width,height))
+    v4 = get_target(region,rv3d,(width,0))
+
+    coords = (v1, v2, v3, v4)
+    indices = (
+            (1, 3), (2, 1), (3, 0),(2,0)
+    )
+
 class DrawClient(bpy.types.Operator):
     bl_idname = "session.draw"
     bl_label = "DrawClient"
@@ -36,6 +52,7 @@ class DrawClient(bpy.types.Operator):
         self.shader = None
         self.batch = None 
         self.draw_handle = None
+        self.draw_event = None
         self.coords = None
         self.indices = None
 
@@ -44,6 +61,11 @@ class DrawClient(bpy.types.Operator):
         return True
 
     def invoke(self, context,event):
+        try:
+            self.unregister_handlers()
+        except:
+            pass
+
         area, region, rv3d = view3d_find()
         width = region.width
         height = region.height
@@ -65,17 +87,21 @@ class DrawClient(bpy.types.Operator):
 
         self.create_batch()
 
-        self.register_handlers()
+        self.register_handlers(context)
 
         context.window_manager.modal_handler_add(self)
         return {"RUNNING_MODAL"}
 
-    def register_handlers(self):
+    def register_handlers(self,context):
         self.draw_handle = bpy.types.SpaceView3D.draw_handler_add(self.draw_callback, (), 'WINDOW', 'POST_VIEW')
+        self.draw_event = context.window_manager.event_timer_add(0.1, window=context.window)
 
-    def unregister_handlers(self):
+    def unregister_handlers(self,context):
+        context.window_manager.event_timer_remove(self.draw_event)
         bpy.types.SpaceView3D.draw_handler_remove(self.draw_handle,"WINDOW")
+
         self.draw_handle = None
+        self.draw_event = None
 
     def create_batch(self):
         self.shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
@@ -92,7 +118,7 @@ class DrawClient(bpy.types.Operator):
         
         
         if event.type in {"ESC"}:
-            self.unregister_handlers()
+            self.unregister_handlers(context)
             return {"CANCELLED"}
         # if self.draw_handle:
         #     self.finish()