feat: mesh dump refactoring wip

multi_user/bl_types/bl_mesh.py

@@ -19,82 +19,90 @@
 import bpy
 import bmesh
 import mathutils
+import logging
+import numpy as np
 
 from .. import utils
 from ..libs.replication.replication.constants import DIFF_BINARY
 from .bl_datablock import BlDatablock
 
+logger = logging.getLogger(__name__)
 
 def dump_mesh(mesh, data={}):
     import bmesh
 
     mesh_data = data
-    mesh_buffer = bmesh.new()
-
     # https://blog.michelanders.nl/2016/02/copying-vertices-to-numpy-arrays-in_4.html
-    mesh_buffer.from_mesh(mesh)
 
-    uv_layer = mesh_buffer.loops.layers.uv.verify()
+    # VERTICES
-    bevel_layer = mesh_buffer.verts.layers.bevel_weight.verify()
+    start = utils.current_milli_time()
-    skin_layer = mesh_buffer.verts.layers.skin.verify()
 
-    verts = {}
+    vert_count = len(mesh.vertices)
-    for vert in mesh_buffer.verts:
+    shape = (vert_count, 3) 
-        v = {}
-        v["co"] = list(vert.co)
 
-        # vert metadata
+    verts_co = np.empty(vert_count*3, dtype=np.float64)
-        v['bevel'] = vert[bevel_layer]
+    mesh.vertices.foreach_get('co', verts_co)
-        v['normal'] = list(vert.normal)
+    # verts_co.shape = shape
-        # v['skin'] = list(vert[skin_layer])
+    mesh_data["verts_co"] = verts_co.tobytes()
 
-        verts[str(vert.index)] = v
+    verts_normal = np.empty(vert_count*3, dtype=np.float64)
+    mesh.vertices.foreach_get('normal', verts_normal)
+    # verts_normal.shape = shape
+    mesh_data["verts_normal"] = verts_normal.tobytes()
+    
+    verts_bevel = np.empty(vert_count, dtype=np.float64)
+    mesh.vertices.foreach_get('bevel_weight', verts_bevel)
+    mesh_data["verts_bevel"] = verts_bevel.tobytes()
 
-    mesh_data["verts"] = verts
+    logger.error(f"verts {utils.current_milli_time()-start} ms")
+    
+    # EDGES
+    start = utils.current_milli_time()
+    edge_count = len(mesh.edges)
+    
+    edges_vert = np.empty(edge_count*2, dtype=np.int)
+    mesh.edges.foreach_get('vertices', edges_vert)
+    # edges_vert.shape = (edge_count, 2)
+    mesh_data["egdes_vert"] = edges_vert.tobytes()
 
-    edges = {}
+    logger.error(f"edges {utils.current_milli_time()-start} ms")
-    for edge in mesh_buffer.edges:
-        e = {}
-        e["verts"] = [edge.verts[0].index, edge.verts[1].index]
 
-        # Edge metadata
+    start = utils.current_milli_time()
-        e["smooth"] = edge.smooth
 
-        edges[edge.index] = e
+    # POLYGONS
-    mesh_data["edges"] = edges
+    start = utils.current_milli_time()
+    poly_count = len(mesh.polygons)
 
-    faces = {}
+    poly_mat = np.empty(poly_count, dtype=np.int)
-    for face in mesh_buffer.faces:
+    mesh.polygons.foreach_get("material_index", poly_mat)
-        f = {}
+    mesh_data["poly_mat"] = poly_mat.tobytes()
-        fverts = []
-        for vert in face.verts:
-            fverts.append(vert.index)
 
-        f["verts"] = fverts
+    poly_loop_start = np.empty(poly_count, dtype=np.int)
-        f["material_index"] = face.material_index
+    mesh.polygons.foreach_get("loop_start", poly_loop_start)
-        f["smooth"] = face.smooth
+    mesh_data["poly_loop_start"] = poly_loop_start.tobytes()
-        f["normal"] = list(face.normal)
-        f["index"] = face.index
 
-        uvs = []
+    poly_loop_total = np.empty(poly_count, dtype=np.int)
-        # Face metadata
+    mesh.polygons.foreach_get("loop_total", poly_loop_total)
-        for loop in face.loops:
+    mesh_data["poly_loop_total"] = poly_loop_total.tobytes()
-            loop_uv = loop[uv_layer]
 
-            uvs.append(list(loop_uv.uv))
+    poly_smooth = np.empty(poly_count, dtype=np.bool)
+    mesh.polygons.foreach_get("use_smooth", poly_smooth)
+    mesh_data["poly_smooth"] = poly_smooth.tobytes()
+    
+    logger.error(f"polygons {utils.current_milli_time()-start} ms")
 
-        f["uv"] = uvs
+    # UV
-        faces[face.index] = f
+    start = utils.current_milli_time()
+    mesh_data['uv_layers'] = {}
+    for layer in mesh.uv_layers:
+        mesh_data['uv_layers'][layer.name] = {}
+        
+        uv_layer = np.empty(len(layer.data)*2, dtype=np.float64)
+        layer.data.foreach_get("uv", uv_layer)
 
-    mesh_data["faces"] = faces
+        mesh_data['uv_layers'][layer.name]['data'] = uv_layer.tobytes()
-
-    uv_layers = []
-    for uv_layer in mesh.uv_layers:
-        uv_layers.append(uv_layer.name)
-
-    mesh_data["uv_layers"] = uv_layers
-    # return mesh_data
 
+    logger.error(f"uvs {utils.current_milli_time()-start} ms")
 
 class BlMesh(BlDatablock):
     bl_id = "meshes"
@@ -174,8 +182,12 @@ class BlMesh(BlDatablock):
             'use_auto_smooth',
             'auto_smooth_angle'
         ]
+
+        
         data = dumper.dump(pointer)
+        
         dump_mesh(pointer, data)
+        
         # Fix material index
         m_list = []
         for material in pointer.materials:

multi_user/utils.py

@@ -22,6 +22,7 @@ import os
 import random
 import string
 import sys
+import time
 from uuid import uuid4
 from collections.abc import Iterable
 
@@ -175,4 +176,7 @@ def resolve_from_id(id, optionnal_type=None):
             
 
 def get_preferences():
-    return bpy.context.preferences.addons[__package__].preferences
+    return bpy.context.preferences.addons[__package__].preferences
+
+def current_milli_time():
+    return int(round(time.time() * 1000))