refactor: cleanup

draw.py

@@ -0,0 +1,189 @@
+import bpy
+import bgl
+import blf
+import gpu
+import mathutils
+
+from bpy_extras import view3d_utils
+from gpu_extras.batch import batch_for_shader
+
+def view3d_find():
+    for area in bpy.data.window_managers[0].windows[0].screen.areas:
+        if area.type == 'VIEW_3D':
+            v3d = area.spaces[0]
+            rv3d = v3d.region_3d
+            for region in area.regions:
+                if region.type == 'WINDOW':
+                    return area, region, rv3d
+
+    return None, None, None
+
+
+def get_target(region, rv3d, coord):
+    target = [0, 0, 0]
+
+    if coord and region and rv3d:
+        view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, coord)
+        ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)
+        target = ray_origin + view_vector
+
+    return [target.x, target.y, target.z]
+
+
+def get_client_view_rect():
+    area, region, rv3d = view3d_find()
+
+    v1 = [0, 0, 0]
+    v2 = [0, 0, 0]
+    v3 = [0, 0, 0]
+    v4 = [0, 0, 0]
+
+    if area and region and rv3d:
+        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)
+    )
+
+    return coords
+
+
+def get_client_2d(coords):
+    area, region, rv3d = view3d_find()
+    if area and region and rv3d:
+        return view3d_utils.location_3d_to_region_2d(region, rv3d, coords)
+    else:
+        return None
+
+
+class HUD(object):
+
+    def __init__(self, client_instance = None):
+        self.draw_items = []
+        self.draw3d_handle = None
+        self.draw2d_handle = None
+        self.draw_event = None
+        self.coords = None
+        self.active_object = None
+
+        if client_instance:
+            self.client = client_instance 
+
+            self.create_batch()
+            self.register_handlers()
+
+
+    def register_handlers(self):
+        self.draw3d_handle = bpy.types.SpaceView3D.draw_handler_add(
+            self.draw3d_callback, (), 'WINDOW', 'POST_VIEW')
+        self.draw2d_handle = bpy.types.SpaceView3D.draw_handler_add(
+            self.draw2d_callback, (), 'WINDOW', 'POST_PIXEL')
+
+    def unregister_handlers(self):
+        if self.draw2d_handle:
+            bpy.types.SpaceView3D.draw_handler_remove(
+                self.draw2d_handle, "WINDOW")
+            self.draw2d_handle = None
+
+        if self.draw3d_handle:
+            bpy.types.SpaceView3D.draw_handler_remove(
+                self.draw3d_handle, "WINDOW")
+            self.draw3d_handle = None
+
+        self.draw_items.clear()
+
+    def create_batch(self):
+        index = 0
+        index_object = 0
+
+        self.draw_items.clear()
+
+        for key, values in self.client.property_map.items():
+            if 'net' in key and values.body is not None and values.id != self.client.id:
+                if values.mtype == "clientObject":
+                    indices = (
+                        (0, 1), (1, 2), (2, 3), (0, 3),
+                        (4, 5), (5, 6), (6, 7), (4, 7),
+                        (0, 4), (1, 5), (2, 6), (3, 7)
+                    )
+
+                    if values.body['object'] in bpy.data.objects.keys():
+                        ob = bpy.data.objects[values.body['object']]
+                    else:
+                        return
+                    bbox_corners = [ob.matrix_world @ mathutils.Vector(corner) for corner in ob.bound_box]
+
+                    coords = [(point.x, point.y, point.z)
+                              for point in bbox_corners]
+
+                    shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
+
+                    color = values.body['color']
+                    batch = batch_for_shader(
+                        shader, 'LINES', {"pos": coords}, indices=indices)
+
+                    self.draw_items.append(
+                        (shader, batch, (None, None), color))
+
+                    # index_object += 1
+
+                if values.mtype == "client":
+                    indices = (
+                        (1, 3), (2, 1), (3, 0), (2, 0)
+                    )
+
+                    shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
+                    position = values.body['location']
+                    color = values.body['color']
+                    batch = batch_for_shader(
+                        shader, 'LINES', {"pos": position}, indices=indices)
+
+                    self.draw_items.append(
+                        (shader, batch, (position[1], values.id.decode()), color))
+
+                    index += 1
+
+    def draw3d_callback(self):
+        bgl.glLineWidth(3)
+        for shader, batch, font, color in self.draw_items:
+            shader.bind()
+            shader.uniform_float("color", color)
+            batch.draw(shader)
+
+    def draw2d_callback(self):
+        for shader, batch, font, color in self.draw_items:
+            try:
+                coords = get_client_2d(font[0])
+
+                blf.position(0, coords[0], coords[1]+10, 0)
+                blf.size(0, 10, 72)
+                blf.color(0, color[0], color[1], color[2], color[3])
+                blf.draw(0,  font[1])
+
+            except:
+                pass
+
+    def is_object_selected(self, obj):
+        # TODO: function to find occurence
+
+        for k, v in self.client.property_map.items():
+            if v.mtype == 'clientObject':
+                if self.client.id != v.id:
+                    if obj.name in v.body:
+                        return True
+
+        return False
+
+    def draw(self):
+        if self.client:
+            # Draw clients
+            if len(self.client.property_map) > 1:
+                self.create_batch()
+