Backups/multi-user
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch '29-differential-revision' into 'develop'

Browse Source 
Resolve "Implementation cleanup"

See merge request slumber/multi-user!32
This commit is contained in:
Swann Martinez
2020-04-22 15:24:11 +00:00
parent 2e60bb985f 4c44c2f1a0
commit f3d8f15ab1
53 changed files with 968 additions and 395 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -10,4 +10,7 @@ config
multi_user_updater/
# sphinx build folder
_build
_build
# ignore generated zip generated from blender_addon_tester
*.zip

6
.gitlab-ci.yml
View File

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

9
.gitlab/ci/build.gitlab-ci.yml
View File

@ -1,17 +1,14 @@
image: python:latest
build:
stage: build
image: python:latest
script:
- git submodule init
- git submodule update
- cd multi_user/libs/replication
- rm -rf tests .git .gitignore
- rm -rf tests .git .gitignore script
artifacts:
name: multi_user
paths:
- multi_user
only:
- master
- develop

13
.gitlab/ci/test.gitlab-ci.yml Normal file
View File

@ -0,0 +1,13 @@
test:
stage: test
image: python:latest
script:
- git submodule init
- git submodule update
- apt update
# install blender to get all required dependencies
# TODO: indtall only dependencies
- apt install -f -y blender
- pip install blender-addon-tester
- python scripts/test_addon.py

18
multi_user/__init__.py
View File

@ -46,22 +46,26 @@ from . import environment, utils
# TODO: remove dependency as soon as replication will be installed as a module
DEPENDENCIES = {
("zmq","zmq"),
("jsondiff","jsondiff")
("jsondiff","jsondiff"),
("deepdiff", "deepdiff")
}
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
libs = os.path.dirname(os.path.abspath(__file__))+"\\libs\\replication\\replication"
def register():
# Setup logging policy
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
if libs not in sys.path:
sys.path.append(libs)
environment.setup(DEPENDENCIES,bpy.app.binary_path_python)
try:
environment.setup(DEPENDENCIES, bpy.app.binary_path_python)
except ModuleNotFoundError:
logging.fatal("Fail to install multi-user dependencies, try to execute blender with admin rights.")
return
from . import presence
from . import operators
from . import ui

9
multi_user/bl_types/bl_action.py
View File

@ -139,7 +139,7 @@ class BlAction(BlDatablock):
def _construct(self, data):
return bpy.data.actions.new(data["name"])
def _load(self, data, target):
def _load_implementation(self, data, target):
for dumped_fcurve in data["fcurves"]:
dumped_data_path = dumped_fcurve["data_path"]
dumped_array_index = dumped_fcurve["dumped_array_index"]
@ -154,8 +154,7 @@ class BlAction(BlDatablock):
load_fcurve(dumped_fcurve, fcurve)
target.id_root = data['id_root']
def _dump(self, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
dumper = Dumper()
dumper.exclude_filter = [
'name_full',
@ -170,11 +169,11 @@ class BlAction(BlDatablock):
'users'
]
dumper.depth = 1
data = dumper.dump(pointer)
data = dumper.dump(instance)
data["fcurves"] = []
for fcurve in self.pointer.fcurves:
for fcurve in instance.fcurves:
data["fcurves"].append(dump_fcurve(fcurve, use_numpy=True))
return data

20
multi_user/bl_types/bl_armature.py
View File

@ -46,7 +46,7 @@ class BlArmature(BlDatablock):
if parent_object is None:
parent_object = bpy.data.objects.new(
data['user_name'], self.pointer)
data['user_name'], target)
parent_object.uuid = data['user']
is_object_in_master = (
@ -81,10 +81,10 @@ class BlArmature(BlDatablock):
bpy.ops.object.mode_set(mode='EDIT')
for bone in data['bones']:
if bone not in self.pointer.edit_bones:
new_bone = self.pointer.edit_bones.new(bone)
if bone not in target.edit_bones:
new_bone = target.edit_bones.new(bone)
else:
new_bone = self.pointer.edit_bones[bone]
new_bone = target.edit_bones[bone]
bone_data = data['bones'].get(bone)
@ -94,7 +94,7 @@ class BlArmature(BlDatablock):
new_bone.head_radius = bone_data['head_radius']
if 'parent' in bone_data:
new_bone.parent = self.pointer.edit_bones[data['bones']
new_bone.parent = target.edit_bones[data['bones']
[bone]['parent']]
new_bone.use_connect = bone_data['use_connect']
@ -109,8 +109,8 @@ class BlArmature(BlDatablock):
if 'EDIT' in current_mode:
bpy.ops.object.mode_set(mode='EDIT')
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
dumper = Dumper()
dumper.depth = 4
@ -126,13 +126,13 @@ class BlArmature(BlDatablock):
'layers'
]
data = dumper.dump(pointer)
data = dumper.dump(instance)
for bone in pointer.bones:
for bone in instance.bones:
if bone.parent:
data['bones'][bone.name]['parent'] = bone.parent.name
# get the parent Object
object_users = utils.get_datablock_users(pointer)[0]
object_users = utils.get_datablock_users(instance)[0]
data['user'] = object_users.uuid
data['user_name'] = object_users.name

6
multi_user/bl_types/bl_camera.py
View File

@ -45,8 +45,8 @@ class BlCamera(BlDatablock):
if dof_settings:
loader.load(target.dof, dof_settings)
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
# TODO: background image support
@ -80,6 +80,6 @@ class BlCamera(BlDatablock):
'sensor_height',
'sensor_width',
]
return dumper.dump(pointer)
return dumper.dump(instance)

43
multi_user/bl_types/bl_collection.py
View File

@ -38,57 +38,61 @@ class BlCollection(BlDatablock):
name for name in sourceData.collections if name == self.data['name']]
instance = bpy.data.collections[self.data['name']]
instance.uuid = self.uuid
return instance
instance = bpy.data.collections.new(data["name"])
instance.uuid = self.uuid
return instance
def _load_implementation(self, data, target):
# Load other meshes metadata
target.name = data["name"]
# link objects
# Objects
for object in data["objects"]:
object_ref = utils.find_from_attr('uuid', object, bpy.data.objects)
if object_ref and object_ref.name not in target.objects.keys():
object_ref = bpy.data.objects.get(object)
if object_ref is None:
continue
if object not in target.objects.keys():
target.objects.link(object_ref)
for object in target.objects:
if object.uuid not in data["objects"]:
if object.name not in data["objects"]:
target.objects.unlink(object)
# Link childrens
for collection in data["children"]:
collection_ref = utils.find_from_attr(
'uuid', collection, bpy.data.collections)
if collection_ref and collection_ref.name not in target.children.keys():
collection_ref = bpy.data.collections.get(collection)
if collection_ref is None:
continue
if collection_ref.name not in target.children.keys():
target.children.link(collection_ref)
for collection in target.children:
if collection.uuid not in data["children"]:
if collection.name not in data["children"]:
target.children.unlink(collection)
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
data = {}
data['name'] = pointer.name
data['name'] = instance.name
# dump objects
collection_objects = []
for object in pointer.objects:
for object in instance.objects:
if object not in collection_objects:
collection_objects.append(object.uuid)
collection_objects.append(object.name)
data['objects'] = collection_objects
# dump children collections
collection_children = []
for child in pointer.children:
for child in instance.children:
if child not in collection_children:
collection_children.append(child.uuid)
collection_children.append(child.name)
data['children'] = collection_children
@ -97,10 +101,9 @@ class BlCollection(BlDatablock):
def _resolve_deps_implementation(self):
deps = []
for child in self.pointer.children:
for child in self.instance.children:
deps.append(child)
for object in self.pointer.objects:
for object in self.instance.objects:
deps.append(object)
return deps

32
multi_user/bl_types/bl_curve.py
View File

@ -27,7 +27,6 @@ from .dump_anything import (Dumper, Loader,
np_load_collection,
np_dump_collection)
logger = logging.getLogger(__name__)
SPLINE_BEZIER_POINT = [
# "handle_left_type",
@ -77,21 +76,34 @@ class BlCurve(BlDatablock):
# Not really working for now...
# See https://blender.stackexchange.com/questions/7020/create-nurbs-surface-with-python
if new_spline.type == 'NURBS':
logger.error("NURBS not supported.")
logging.error("NURBS not supported.")
# new_spline.points.add(len(data['splines'][spline]["points"])-1)
# for point_index in data['splines'][spline]["points"]:
# loader.load(
# new_spline.points[point_index], data['splines'][spline]["points"][point_index])
loader.load(new_spline, spline)
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
dumper = Dumper()
data = dumper.dump(pointer)
# Conflicting attributes
# TODO: remove them with the NURBS support
dumper.exclude_filter = [
'users',
'order_u',
'order_v',
'point_count_v',
'point_count_u',
'active_textbox'
]
if instance.use_auto_texspace:
dumper.exclude_filter.extend([
'texspace_location',
'texspace_size'])
data = dumper.dump(instance)
data['splines'] = {}
for index, spline in enumerate(pointer.splines):
for index, spline in enumerate(instance.splines):
dumper.depth = 2
spline_data = dumper.dump(spline)
# spline_data['points'] = np_dump_collection(spline.points, SPLINE_POINT)
@ -99,10 +111,10 @@ class BlCurve(BlDatablock):
spline_data['bezier_points'] = np_dump_collection(spline.bezier_points, SPLINE_BEZIER_POINT)
data['splines'][index] = spline_data
if isinstance(pointer, T.SurfaceCurve):
if isinstance(instance, T.SurfaceCurve):
data['type'] = 'SURFACE'
elif isinstance(pointer, T.TextCurve):
elif isinstance(instance, T.TextCurve):
data['type'] = 'FONT'
elif isinstance(pointer, T.Curve):
elif isinstance(instance, T.Curve):
data['type'] = 'CURVE'
return data

38
multi_user/bl_types/bl_datablock.py
View File

@ -99,54 +99,54 @@ class BlDatablock(ReplicatedDatablock):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
pointer = kwargs.get('pointer', None)
instance = kwargs.get('instance', None)
# TODO: use is_library_indirect
self.is_library = (pointer and hasattr(pointer, 'library') and
pointer.library) or \
self.is_library = (instance and hasattr(instance, 'library') and
instance.library) or \
(self.data and 'library' in self.data)
if self.pointer and hasattr(self.pointer, 'uuid'):
self.pointer.uuid = self.uuid
if instance and hasattr(instance, 'uuid'):
instance.uuid = self.uuid
self.diff_method = DIFF_BINARY
# self.diff_method = DIFF_BINARY
def _resolve(self):
@property
def instance(self):
datablock_ref = None
datablock_root = getattr(bpy.data, self.bl_id)
datablock_ref = utils.find_from_attr('uuid', self.uuid, datablock_root)
# In case of lost uuid (ex: undo), resolve by name and reassign it
# TODO: avoid reference storing
if not datablock_ref:
datablock_ref = getattr(bpy.data, self.bl_id).get(self.data['name'])
datablock_ref = datablock_root.get(self.data['name'])
if datablock_ref:
setattr(datablock_ref, 'uuid', self.uuid)
self.pointer = datablock_ref
return datablock_ref
def _dump(self, pointer=None):
def _dump(self, instance=None):
dumper = Dumper()
data = {}
# Dump animation data
if has_action(pointer):
if has_action(instance):
dumper = Dumper()
dumper.include_filter = ['action']
data['animation_data'] = dumper.dump(pointer.animation_data)
data['animation_data'] = dumper.dump(instance.animation_data)
if has_driver(pointer):
if has_driver(instance):
dumped_drivers = {'animation_data': {'drivers': []}}
for driver in pointer.animation_data.drivers:
for driver in instance.animation_data.drivers:
dumped_drivers['animation_data']['drivers'].append(
dump_driver(driver))
data.update(dumped_drivers)
if self.is_library:
data.update(dumper.dump(pointer))
data.update(dumper.dump(instance))
else:
data.update(self._dump_implementation(data, pointer=pointer))
data.update(self._dump_implementation(data, instance=instance))
return data
@ -180,8 +180,8 @@ class BlDatablock(ReplicatedDatablock):
def resolve_deps(self):
dependencies = []
if has_action(self.pointer):
dependencies.append(self.pointer.animation_data.action)
if has_action(self.instance):
dependencies.append(self.instance.animation_data.action)
if not self.is_library:
dependencies.extend(self._resolve_deps_implementation())

13
multi_user/bl_types/bl_gpencil.py
View File

@ -95,6 +95,7 @@ def load_stroke(stroke_data, stroke):
np_load_collection(stroke_data['points'], stroke.points, STROKE_POINT)
def dump_frame(frame):
""" Dump a grease pencil frame to a dict
@ -152,7 +153,7 @@ def dump_layer(layer):
'opacity',
'channel_color',
'color',
'thickness',
# 'thickness', #TODO: enabling only for annotation
'tint_color',
'tint_factor',
'vertex_paint_opacity',
@ -251,8 +252,8 @@ class BlGpencil(BlDatablock):
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
dumper = Dumper()
dumper.depth = 2
dumper.include_filter = [
@ -263,11 +264,11 @@ class BlGpencil(BlDatablock):
'pixel_factor',
'stroke_depth_order'
]
data = dumper.dump(pointer)
data = dumper.dump(instance)
data['layers'] = {}
for layer in pointer.layers:
for layer in instance.layers:
data['layers'][layer.info] = dump_layer(layer)
return data
@ -275,7 +276,7 @@ class BlGpencil(BlDatablock):
def _resolve_deps_implementation(self):
deps = []
for material in self.pointer.materials:
for material in self.instance.materials:
deps.append(material)
return deps

12
multi_user/bl_types/bl_image.py
View File

@ -28,7 +28,7 @@ def dump_image(image):
pixels = None
if image.source == "GENERATED":
prefs = utils.get_preferences()
img_name = "{}.png".format(image.name)
img_name = f"{image.name}.png"
# Cache the image on the disk
image.filepath_raw = os.path.join(prefs.cache_directory, img_name)
@ -67,7 +67,7 @@ class BlImage(BlDatablock):
image = target
prefs = utils.get_preferences()
img_name = "{}.png".format(image.name)
img_name = f"{image.name}.png"
img_path = os.path.join(prefs.cache_directory, img_name)
@ -80,10 +80,10 @@ class BlImage(BlDatablock):
image.colorspace_settings.name = data["colorspace_settings"]["name"]
def _dump(self, pointer=None):
assert(pointer)
def _dump(self, instance=None):
assert(instance)
data = {}
data['pixels'] = dump_image(pointer)
data['pixels'] = dump_image(instance)
dumper = Dumper()
dumper.depth = 2
dumper.include_filter = [
@ -95,7 +95,7 @@ class BlImage(BlDatablock):
'filepath',
'source',
'colorspace_settings']
data.update(dumper.dump(pointer))
data.update(dumper.dump(instance))
return data

20
multi_user/bl_types/bl_lattice.py
View File

@ -21,6 +21,7 @@ import mathutils
from .dump_anything import Dumper, Loader, np_dump_collection, np_load_collection
from .bl_datablock import BlDatablock
from ..libs.replication.replication.exception import ContextError
POINT = ['co', 'weight_softbody', 'co_deform']
@ -33,17 +34,21 @@ class BlLattice(BlDatablock):
bl_automatic_push = True
bl_icon = 'LATTICE_DATA'
def _construct(self, data):
return bpy.data.lattices.new(data["name"])
def _load_implementation(self, data, target):
if target.is_editmode:
raise ContextError("lattice is in edit mode")
loader = Loader()
loader.load(target, data)
np_load_collection(data['points'], target.points, POINT)
def _construct(self, data):
return bpy.data.lattices.new(data["name"])
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
if instance.is_editmode:
raise ContextError("lattice is in edit mode")
dumper = Dumper()
dumper.depth = 1
@ -58,8 +63,9 @@ class BlLattice(BlDatablock):
'interpolation_type_w',
'use_outside'
]
data = dumper.dump(pointer)
data = dumper.dump(instance)
data['points'] = np_dump_collection(instance.points, POINT)
data['points'] = np_dump_collection(pointer.points, POINT)
return data

6
multi_user/bl_types/bl_library.py
View File

@ -38,9 +38,9 @@ class BlLibrary(BlDatablock):
def _load(self, data, target):
pass
def dump(self, pointer=None):
assert(pointer)
def _dump(self, instance=None):
assert(instance)
dumper = Dumper()
return dumper.dump(pointer)
return dumper.dump(instance)

11
multi_user/bl_types/bl_light.py
View File

@ -38,8 +38,8 @@ class BlLight(BlDatablock):
loader = Loader()
loader.load(target, data)
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
dumper = Dumper()
dumper.depth = 3
dumper.include_filter = [
@ -61,9 +61,12 @@ class BlLight(BlDatablock):
"contact_shadow_soft_size",
"contact_shadow_bias",
"contact_shadow_thickness",
"shape"
"shape",
"size_y",
"size",
"angle"
]
data = dumper.dump(pointer)
data = dumper.dump(instance)
return data

11
multi_user/bl_types/bl_lightprobe.py
View File

@ -23,7 +23,6 @@ import logging
from .dump_anything import Loader, Dumper
from .bl_datablock import BlDatablock
logger = logging.getLogger(__name__)
class BlLightprobe(BlDatablock):
bl_id = "lightprobes"
@ -39,16 +38,16 @@ class BlLightprobe(BlDatablock):
if bpy.app.version[1] >= 83:
return bpy.data.lightprobes.new(data["name"], type)
else:
logger.warning("Lightprobe replication only supported since 2.83. See https://developer.blender.org/D6396")
logging.warning("Lightprobe replication only supported since 2.83. See https://developer.blender.org/D6396")
def _load_implementation(self, data, target):
loader = Loader()
loader.load(target, data)
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
if bpy.app.version[1] < 83:
logger.warning("Lightprobe replication only supported since 2.83. See https://developer.blender.org/D6396")
logging.warning("Lightprobe replication only supported since 2.83. See https://developer.blender.org/D6396")
dumper = Dumper()
dumper.depth = 1
@ -73,7 +72,7 @@ class BlLightprobe(BlDatablock):
'visibility_blur'
]
return dumper.dump(pointer)
return dumper.dump(instance)

25
multi_user/bl_types/bl_material.py
View File

@ -24,7 +24,6 @@ from .. import utils
from .dump_anything import Loader, Dumper
from .bl_datablock import BlDatablock
logger = logging.getLogger(__name__)
def load_node(node_data, node_tree):
""" Load a node into a node_tree from a dict
@ -46,7 +45,7 @@ def load_node(node_data, node_tree):
try:
target_node.inputs[input].default_value = node_data["inputs"][input]["default_value"]
except:
logger.error("{} not supported, skipping".format(input))
logging.error(f"Material {input} parameter not supported, skipping")
def load_links(links_data, node_tree):
@ -195,8 +194,8 @@ class BlMaterial(BlDatablock):
load_links(data["node_tree"]["links"], target.node_tree)
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
mat_dumper = Dumper()
mat_dumper.depth = 2
mat_dumper.exclude_filter = [
@ -215,17 +214,17 @@ class BlMaterial(BlDatablock):
"line_color",
"view_center",
]
data = mat_dumper.dump(pointer)
data = mat_dumper.dump(instance)
if pointer.use_nodes:
if instance.use_nodes:
nodes = {}
for node in pointer.node_tree.nodes:
for node in instance.node_tree.nodes:
nodes[node.name] = dump_node(node)
data["node_tree"]['nodes'] = nodes
data["node_tree"]["links"] = dump_links(pointer.node_tree.links)
data["node_tree"]["links"] = dump_links(instance.node_tree.links)
if pointer.is_grease_pencil:
if instance.is_grease_pencil:
gp_mat_dumper = Dumper()
gp_mat_dumper.depth = 3
@ -251,19 +250,19 @@ class BlMaterial(BlDatablock):
'mix_color',
'flip'
]
data['grease_pencil'] = gp_mat_dumper.dump(pointer.grease_pencil)
data['grease_pencil'] = gp_mat_dumper.dump(instance.grease_pencil)
return data
def _resolve_deps_implementation(self):
# TODO: resolve node group deps
deps = []
if self.pointer.use_nodes:
for node in self.pointer.node_tree.nodes:
if self.instance.use_nodes:
for node in self.instance.node_tree.nodes:
if node.type == 'TEX_IMAGE':
deps.append(node.image)
if self.is_library:
deps.append(self.pointer.library)
deps.append(self.instance.library)
return deps

16
multi_user/bl_types/bl_mesh.py
View File

@ -24,9 +24,9 @@ import numpy as np
from .dump_anything import Dumper, Loader, np_load_collection_primitives, np_dump_collection_primitive, np_load_collection, np_dump_collection
from ..libs.replication.replication.constants import DIFF_BINARY
from ..libs.replication.replication.exception import ContextError
from .bl_datablock import BlDatablock
logger = logging.getLogger(__name__)
VERTICE = ['co']
@ -109,10 +109,12 @@ class BlMesh(BlDatablock):
target.validate()
target.update()
def _dump_implementation(self, data, pointer=None):
assert(pointer)
mesh = pointer
def _dump_implementation(self, data, instance=None):
assert(instance)
if instance.is_editmode:
raise ContextError("Mesh is in edit mode")
mesh = instance
dumper = Dumper()
dumper.depth = 1
@ -156,7 +158,7 @@ class BlMesh(BlDatablock):
# Fix material index
m_list = []
for material in pointer.materials:
for material in instance.materials:
if material:
m_list.append(material.name)
@ -167,7 +169,7 @@ class BlMesh(BlDatablock):
def _resolve_deps_implementation(self):
deps = []
for material in self.pointer.materials:
for material in self.instance.materials:
if material:
deps.append(material)

23
multi_user/bl_types/bl_metaball.py
View File

@ -84,19 +84,22 @@ class BlMetaball(BlDatablock):
load_metaball_elements(data['elements'], target.elements)
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
dumper = Dumper()
dumper.depth = 1
dumper.exclude_filter = [
"is_editmode",
"is_evaluated",
"is_embedded_data",
"is_library_indirect",
"name_full"
dumper.include_filter = [
'name',
'resolution',
'render_resolution',
'threshold',
'update_method',
'use_auto_texspace',
'texspace_location',
'texspace_size'
]
data = dumper.dump(pointer)
data['elements'] = dump_metaball_elements(pointer.elements)
data = dumper.dump(instance)
data['elements'] = dump_metaball_elements(instance.elements)
return data

91
multi_user/bl_types/bl_object.py
View File

@ -22,8 +22,7 @@ import logging
from .dump_anything import Loader, Dumper
from .bl_datablock import BlDatablock
logger = logging.getLogger(__name__)
from ..libs.replication.replication.exception import ContextError
def load_pose(target_bone, data):
@ -41,7 +40,7 @@ class BlObject(BlDatablock):
bl_icon = 'OBJECT_DATA'
def _construct(self, data):
pointer = None
instance = None
if self.is_library:
with bpy.data.libraries.load(filepath=bpy.data.libraries[self.data['library']].filepath, link=True) as (sourceData, targetData):
@ -56,33 +55,33 @@ class BlObject(BlDatablock):
if "data" not in data:
pass
elif data["data"] in bpy.data.meshes.keys():
pointer = bpy.data.meshes[data["data"]]
instance = bpy.data.meshes[data["data"]]
elif data["data"] in bpy.data.lights.keys():
pointer = bpy.data.lights[data["data"]]
instance = bpy.data.lights[data["data"]]
elif data["data"] in bpy.data.cameras.keys():
pointer = bpy.data.cameras[data["data"]]
instance = bpy.data.cameras[data["data"]]
elif data["data"] in bpy.data.curves.keys():
pointer = bpy.data.curves[data["data"]]
instance = bpy.data.curves[data["data"]]
elif data["data"] in bpy.data.metaballs.keys():
pointer = bpy.data.metaballs[data["data"]]
instance = bpy.data.metaballs[data["data"]]
elif data["data"] in bpy.data.armatures.keys():
pointer = bpy.data.armatures[data["data"]]
instance = bpy.data.armatures[data["data"]]
elif data["data"] in bpy.data.grease_pencils.keys():
pointer = bpy.data.grease_pencils[data["data"]]
instance = bpy.data.grease_pencils[data["data"]]
elif data["data"] in bpy.data.curves.keys():
pointer = bpy.data.curves[data["data"]]
instance = bpy.data.curves[data["data"]]
elif data["data"] in bpy.data.lattices.keys():
pointer = bpy.data.lattices[data["data"]]
instance = bpy.data.lattices[data["data"]]
elif data["data"] in bpy.data.speakers.keys():
pointer = bpy.data.speakers[data["data"]]
instance = bpy.data.speakers[data["data"]]
elif data["data"] in bpy.data.lightprobes.keys():
# Only supported since 2.83
if bpy.app.version[1] >= 83:
pointer = bpy.data.lightprobes[data["data"]]
instance = bpy.data.lightprobes[data["data"]]
else:
logger.warning(
logging.warning(
"Lightprobe replication only supported since 2.83. See https://developer.blender.org/D6396")
instance = bpy.data.objects.new(data["name"], pointer)
instance = bpy.data.objects.new(data["name"], instance)
instance.uuid = self.uuid
return instance
@ -126,7 +125,8 @@ class BlObject(BlDatablock):
target.vertex_groups.clear()
for vg in data['vertex_groups']:
vertex_group = target.vertex_groups.new(name=vg['name'])
for vert in vg['vertices']:
point_attr = 'vertices' if 'vertices' in vg else 'points'
for vert in vg[point_attr]:
vertex_group.add(
[vert['index']], vert['weight'], 'REPLACE')
@ -152,8 +152,14 @@ class BlObject(BlDatablock):
target.data.shape_keys.key_blocks[key_block].relative_key = target.data.shape_keys.key_blocks[reference]
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
child_data = getattr(instance, 'data', None)
if child_data and hasattr(child_data, 'is_editmode') and child_data.is_editmode:
raise ContextError("Object is in edit-mode.")
dumper = Dumper()
dumper.depth = 1
dumper.include_filter = [
@ -169,33 +175,33 @@ class BlObject(BlDatablock):
"instance_type",
"location",
"scale",
'rotation_quaternion' if pointer.rotation_mode == 'QUATERNION' else 'rotation_euler',
'rotation_quaternion' if instance.rotation_mode == 'QUATERNION' else 'rotation_euler',
]
data = dumper.dump(pointer)
data = dumper.dump(instance)
if self.is_library:
return data
# MODIFIERS
if hasattr(pointer, 'modifiers'):
if hasattr(instance, 'modifiers'):
dumper.include_filter = None
dumper.depth = 2
data["modifiers"] = {}
for index, modifier in enumerate(pointer.modifiers):
for index, modifier in enumerate(instance.modifiers):
data["modifiers"][modifier.name] = dumper.dump(modifier)
# CONSTRAINTS
# OBJECT
if hasattr(pointer, 'constraints'):
if hasattr(instance, 'constraints'):
dumper.depth = 3
data["constraints"] = dumper.dump(pointer.constraints)
data["constraints"] = dumper.dump(instance.constraints)
# POSE
if hasattr(pointer, 'pose') and pointer.pose:
if hasattr(instance, 'pose') and instance.pose:
# BONES
bones = {}
for bone in pointer.pose.bones:
for bone in instance.pose.bones:
bones[bone.name] = {}
dumper.depth = 1
rotation = 'rotation_quaternion' if bone.rotation_mode == 'QUATERNION' else 'rotation_euler'
@ -220,7 +226,7 @@ class BlObject(BlDatablock):
# GROUPS
bone_groups = {}
for group in pointer.pose.bone_groups:
for group in instance.pose.bone_groups:
dumper.depth = 3
dumper.include_filter = [
'name',
@ -230,28 +236,29 @@ class BlObject(BlDatablock):
data['pose']['bone_groups'] = bone_groups
# CHILDS
if len(pointer.children) > 0:
if len(instance.children) > 0:
childs = []
for child in pointer.children:
for child in instance.children:
childs.append(child.name)
data["children"] = childs
# VERTEx GROUP
if len(pointer.vertex_groups) > 0:
if len(instance.vertex_groups) > 0:
points_attr = 'vertices' if isinstance(instance.data, bpy.types.Mesh) else 'points'
vg_data = []
for vg in pointer.vertex_groups:
for vg in instance.vertex_groups:
vg_idx = vg.index
dumped_vg = {}
dumped_vg['name'] = vg.name
vertices = []
for v in pointer.data.vertices:
for i, v in enumerate(getattr(instance.data, points_attr)):
for vg in v.groups:
if vg.group == vg_idx:
vertices.append({
'index': v.index,
'index': i,
'weight': vg.weight
})
@ -262,7 +269,7 @@ class BlObject(BlDatablock):
data['vertex_groups'] = vg_data
# SHAPE KEYS
object_data = pointer.data
object_data = instance.data
if hasattr(object_data, 'shape_keys') and object_data.shape_keys:
dumper = Dumper()
dumper.depth = 2
@ -295,17 +302,17 @@ class BlObject(BlDatablock):
deps = []
# Avoid Empty case
if self.pointer.data:
deps.append(self.pointer.data)
if len(self.pointer.children) > 0:
deps.extend(list(self.pointer.children))
if self.instance.data:
deps.append(self.instance.data)
if len(self.instance.children) > 0:
deps.extend(list(self.instance.children))
if self.is_library:
deps.append(self.pointer.library)
deps.append(self.instance.library)
if self.pointer.instance_type == 'COLLECTION':
if self.instance.instance_type == 'COLLECTION':
# TODO: uuid based
deps.append(self.pointer.instance_collection)
deps.append(self.instance.instance_collection)
return deps

38
multi_user/bl_types/bl_scene.py
View File

@ -34,11 +34,9 @@ class BlScene(BlDatablock):
def _construct(self, data):
instance = bpy.data.scenes.new(data["name"])
instance.uuid = self.uuid
return instance
def _load_implementation(self, data, target):
target = self.pointer
# Load other meshes metadata
loader = Loader()
loader.load(target, data)
@ -82,10 +80,10 @@ class BlScene(BlDatablock):
#TODO: change this ugly fix
target.view_settings.curve_mapping.white_level = data['view_settings']['curve_mapping']['white_level']
target.view_settings.curve_mapping.black_level = data['view_settings']['curve_mapping']['black_level']
target.view_settings.curve_mapping.update()
target.view_settings.curve_mapping.update()
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
data = {}
scene_dumper = Dumper()
@ -97,12 +95,12 @@ class BlScene(BlDatablock):
'camera',
'grease_pencil',
]
data = scene_dumper.dump(pointer)
data = scene_dumper.dump(instance)
scene_dumper.depth = 3
scene_dumper.include_filter = ['children','objects','name']
data['collection'] = scene_dumper.dump(pointer.collection)
data['collection'] = scene_dumper.dump(instance.collection)
scene_dumper.depth = 1
scene_dumper.include_filter = None
@ -125,19 +123,19 @@ class BlScene(BlDatablock):
'samples',
'volume_bounces'
]
data['eevee'] = scene_dumper.dump(pointer.eevee)
data['cycles'] = scene_dumper.dump(pointer.cycles)
data['view_settings'] = scene_dumper.dump(pointer.view_settings)
data['view_settings']['curve_mapping'] = scene_dumper.dump(pointer.view_settings.curve_mapping)
if pointer.view_settings.use_curve_mapping:
data['eevee'] = scene_dumper.dump(instance.eevee)
data['cycles'] = scene_dumper.dump(instance.cycles)
data['view_settings'] = scene_dumper.dump(instance.view_settings)
if instance.view_settings.use_curve_mapping:
data['view_settings']['curve_mapping'] = scene_dumper.dump(instance.view_settings.curve_mapping)
scene_dumper.depth = 5
scene_dumper.include_filter = [
'curves',
'points',
'location'
]
data['view_settings']['curve_mapping']['curves'] = scene_dumper.dump(pointer.view_settings.curve_mapping.curves)
data['view_settings']['curve_mapping']['curves'] = scene_dumper.dump(instance.view_settings.curve_mapping.curves)
return data
@ -146,19 +144,19 @@ class BlScene(BlDatablock):
deps = []
# child collections
for child in self.pointer.collection.children:
for child in self.instance.collection.children:
deps.append(child)
# childs objects
for object in self.pointer.objects:
for object in self.instance.objects:
deps.append(object)
# world
if self.pointer.world:
deps.append(self.pointer.world)
if self.instance.world:
deps.append(self.instance.world)
# annotations
if self.pointer.grease_pencil:
deps.append(self.pointer.grease_pencil)
if self.instance.grease_pencil:
deps.append(self.instance.grease_pencil)
return deps

6
multi_user/bl_types/bl_speaker.py
View File

@ -38,8 +38,8 @@ class BlSpeaker(BlDatablock):
def _construct(self, data):
return bpy.data.speakers.new(data["name"])
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
dumper = Dumper()
dumper.depth = 1
@ -58,7 +58,7 @@ class BlSpeaker(BlDatablock):
'cone_volume_outer'
]
return dumper.dump(pointer)
return dumper.dump(instance)

18
multi_user/bl_types/bl_world.py
View File

@ -51,8 +51,8 @@ class BlWorld(BlDatablock):
load_links(data["node_tree"]["links"], target.node_tree)
def _dump_implementation(self, data, pointer=None):
assert(pointer)
def _dump_implementation(self, data, instance=None):
assert(instance)
world_dumper = Dumper()
world_dumper.depth = 2
@ -66,27 +66,27 @@ class BlWorld(BlDatablock):
"users",
"view_center"
]
data = world_dumper.dump(pointer)
if pointer.use_nodes:
data = world_dumper.dump(instance)
if instance.use_nodes:
nodes = {}
for node in pointer.node_tree.nodes:
for node in instance.node_tree.nodes:
nodes[node.name] = dump_node(node)
data["node_tree"]['nodes'] = nodes
data["node_tree"]['links'] = dump_links(pointer.node_tree.links)
data["node_tree"]['links'] = dump_links(instance.node_tree.links)
return data
def _resolve_deps_implementation(self):
deps = []
if self.pointer.use_nodes:
for node in self.pointer.node_tree.nodes:
if self.instance.use_nodes:
for node in self.instance.node_tree.nodes:
if node.type == 'TEX_IMAGE':
deps.append(node.image)
if self.is_library:
deps.append(self.pointer.library)
deps.append(self.instance.library)
return deps

63
multi_user/bl_types/dump_anything.py
View File

@ -22,7 +22,6 @@ import bpy.types as T
import mathutils
import numpy as np
logger = logging.getLogger(__name__)
BPY_TO_NUMPY_TYPES = {
'FLOAT': np.float,
@ -47,6 +46,10 @@ def np_load_collection(dikt: dict, collection: bpy.types.CollectionProperty, att
:arg attributes: list of attributes name
:type attributes: list
"""
if not dikt or len(collection) == 0:
logging.warning(f'Skipping collection')
return
if attributes is None:
attributes = dikt.keys()
@ -58,7 +61,7 @@ def np_load_collection(dikt: dict, collection: bpy.types.CollectionProperty, att
elif attr_type == 'ENUM':
np_load_collection_enum(collection, attr, dikt[attr])
else:
logger.error(f"{attr} of type {attr_type} not supported.")
logging.error(f"{attr} of type {attr_type} not supported.")
def np_dump_collection(collection: bpy.types.CollectionProperty, attributes: list = None) -> dict:
@ -94,7 +97,7 @@ def np_dump_collection(collection: bpy.types.CollectionProperty, attributes: lis
elif attr_type == 'ENUM':
dumped_collection[attr] = np_dump_collection_enum(collection, attr)
else:
logger.error(f"{attr} of type {attr_type} not supported. Only {PRIMITIVE_TYPES} and ENUM supported. Skipping it.")
logging.error(f"{attr} of type {attr_type} not supported. Only {PRIMITIVE_TYPES} and ENUM supported. Skipping it.")
return dumped_collection
@ -111,11 +114,15 @@ def np_dump_collection_primitive(collection: bpy.types.CollectionProperty, attri
:type attribute: str
:return: numpy byte buffer
"""
if len(collection) == 0:
logging.warning(f'Skipping empty {attribute} attribute')
return {}
attr_infos = collection[0].bl_rna.properties.get(attribute)
assert(attr_infos.type in ['FLOAT', 'INT', 'BOOLEAN'])
size = sum(attr_infos.array_dimensions) if attr_infos.is_array else 1
dumped_sequence = np.zeros(
@ -182,10 +189,12 @@ def np_load_collection_primitives(collection: bpy.types.CollectionProperty, attr
:arg attribute: target attribute
:type attribute: str
:arg sequence: data buffer
:type sequence: str
:return: numpy byte buffer
:type sequence: strr
"""
if len(collection) == 0 or not sequence:
logging.warning(f"Skipping loadin {attribute}")
return
attr_infos = collection[0].bl_rna.properties.get(attribute)
assert(attr_infos.type in ['FLOAT', 'INT', 'BOOLEAN'])
@ -369,7 +378,7 @@ class Dumper:
return False
getattr(default, p)
except AttributeError as err:
logger.debug(err)
logging.debug(err)
return False
if p.startswith("__"):
return False
@ -479,7 +488,7 @@ class Loader:
for i in range(len(dump)):
element.read()[i] = dump[i]
except AttributeError as err:
logger.debug(err)
logging.debug(err)
if not self.occlude_read_only:
raise err
@ -493,7 +502,7 @@ class Loader:
DESTRUCTOR_REMOVE = "remove"
DESTRUCTOR_CLEAR = "clear"
constructors = {
_constructors = {
T.ColorRampElement: (CONSTRUCTOR_NEW, ["position"]),
T.ParticleSettingsTextureSlot: (CONSTRUCTOR_ADD, []),
T.Modifier: (CONSTRUCTOR_NEW, ["name", "type"]),
@ -507,9 +516,9 @@ class Loader:
}
element_type = element.bl_rna_property.fixed_type
constructor = constructors.get(type(element_type))
_constructor = _constructors.get(type(element_type))
if constructor is None: # collection type not supported
if _constructor is None: # collection type not supported
return
destructor = destructors.get(type(element_type))
@ -528,14 +537,14 @@ class Loader:
new_element = element.read()[0]
else:
try:
constructor_parameters = [dumped_element[name]
for name in constructor[1]]
_constructor_parameters = [dumped_element[name]
for name in _constructor[1]]
except KeyError:
logger.debug("Collection load error, missing parameters.")
logging.debug("Collection load error, missing parameters.")
continue # TODO handle error
new_element = getattr(element.read(), constructor[0])(
*constructor_parameters)
new_element = getattr(element.read(), _constructor[0])(
*_constructor_parameters)
self._load_any(
BlenderAPIElement(
new_element, occlude_read_only=self.occlude_read_only),
@ -566,24 +575,24 @@ class Loader:
else:
dst_curve.points.new(pos[0], pos[1])
def _load_pointer(self, pointer, dump):
rna_property_type = pointer.bl_rna_property.fixed_type
def _load_pointer(self, instance, dump):
rna_property_type = instance.bl_rna_property.fixed_type
if not rna_property_type:
return
if isinstance(rna_property_type, T.Image):
pointer.write(bpy.data.images.get(dump))
instance.write(bpy.data.images.get(dump))
elif isinstance(rna_property_type, T.Texture):
pointer.write(bpy.data.textures.get(dump))
instance.write(bpy.data.textures.get(dump))
elif isinstance(rna_property_type, T.ColorRamp):
self._load_default(pointer, dump)
self._load_default(instance, dump)
elif isinstance(rna_property_type, T.Object):
pointer.write(bpy.data.objects.get(dump))
instance.write(bpy.data.objects.get(dump))
elif isinstance(rna_property_type, T.Mesh):
pointer.write(bpy.data.meshes.get(dump))
instance.write(bpy.data.meshes.get(dump))
elif isinstance(rna_property_type, T.Material):
pointer.write(bpy.data.materials.get(dump))
instance.write(bpy.data.materials.get(dump))
elif isinstance(rna_property_type, T.Collection):
pointer.write(bpy.data.collections.get(dump))
instance.write(bpy.data.collections.get(dump))
def _load_matrix(self, matrix, dump):
matrix.write(mathutils.Matrix(dump))
@ -613,11 +622,11 @@ class Loader:
for k in self._ordered_keys(dump.keys()):
v = dump[k]
if not hasattr(default.read(), k):
logger.debug(f"Load default, skipping {default} : {k}")
logging.debug(f"Load default, skipping {default} : {k}")
try:
self._load_any(default.extend(k), v)
except Exception as err:
logger.debug(f"Cannot load {k}: {err}")
logging.debug(f"Cannot load {k}: {err}")
@property
def match_subset_all(self):

149
multi_user/delayable.py
View File

@ -22,9 +22,6 @@ import bpy
from . import operators, presence, utils
from .libs.replication.replication.constants import FETCHED, RP_COMMON, STATE_INITIAL,STATE_QUITTING, STATE_ACTIVE, STATE_SYNCING, STATE_SRV_SYNC
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
class Delayable():
"""Delayable task interface
@ -92,8 +89,7 @@ class ApplyTimer(Timer):
try:
client.apply(node)
except Exception as e:
logger.error(
"fail to apply {}: {}".format(node_ref.uuid, e))
logging.error(f"Fail to apply {node_ref.uuid}: {e}")
class DynamicRightSelectTimer(Timer):
@ -164,7 +160,7 @@ class DynamicRightSelectTimer(Timer):
}
session.update_user_metadata(user_metadata)
logger.info("Update selection")
logging.debug("Update selection")
# Fix deselection until right managment refactoring (with Roles concepts)
if len(current_selection) == 0 and self._right_strategy == RP_COMMON:
@ -214,11 +210,13 @@ class DrawClient(Draw):
def execute(self):
session = getattr(operators, 'client', None)
renderer = getattr(presence, 'renderer', None)
prefs = utils.get_preferences()
if session and renderer and session.state['STATE'] == STATE_ACTIVE:
settings = bpy.context.window_manager.session
users = session.online_users
# Update users
for user in users.values():
metadata = user.get('metadata')
color = metadata.get('color')
@ -237,79 +235,96 @@ class DrawClient(Draw):
renderer.flush_selection()
renderer.flush_users()
class ClientUpdate(Timer):
def __init__(self, timout=.5):
def __init__(self, timout=.016):
super().__init__(timout)
self.handle_quit = False
self.users_metadata = {}
def execute(self):
settings = utils.get_preferences()
session = getattr(operators, 'client', None)
renderer = getattr(presence, 'renderer', None)
if session and renderer and session.state['STATE'] == STATE_ACTIVE:
# Check if session has been closes prematurely
if session.state['STATE'] == 0:
bpy.ops.session.stop()
if session and renderer:
if session.state['STATE'] == STATE_ACTIVE:
# Check if session has been closes prematurely
if session.state['STATE'] == 0:
bpy.ops.session.stop()
local_user = operators.client.online_users.get(
settings.username)
if not local_user:
return
local_user = operators.client.online_users.get(settings.username)
if not local_user:
return
else:
for username, user_data in operators.client.online_users.items():
if username != settings.username:
cached_user_data = self.users_metadata.get(username)
new_user_data = operators.client.online_users[username]['metadata']
if cached_user_data is None:
self.users_metadata[username] = user_data['metadata']
elif 'view_matrix' in cached_user_data and 'view_matrix' in new_user_data and cached_user_data['view_matrix'] != new_user_data['view_matrix']:
presence.refresh_3d_view()
self.users_metadata[username] = user_data['metadata']
break
else:
self.users_metadata[username] = user_data['metadata']
local_user_metadata = local_user.get('metadata')
current_view_corners = presence.get_view_corners()
scene_current = bpy.context.scene.name
if not local_user_metadata or 'color' not in local_user_metadata.keys():
metadata = {
'view_corners': current_view_corners,
'view_matrix': presence.get_view_matrix(),
'color': (settings.client_color.r,
settings.client_color.g,
settings.client_color.b,
1),
'frame_current':bpy.context.scene.frame_current,
'scene_current': scene_current
}
session.update_user_metadata(metadata)
elif current_view_corners != local_user_metadata['view_corners']:
logger.info('update user metadata')
local_user_metadata['view_corners'] = current_view_corners
local_user_metadata['view_matrix'] = presence.get_view_matrix()
session.update_user_metadata(local_user_metadata)
elif scene_current != local_user_metadata['scene_current']:
local_user_metadata['scene_current'] = scene_current
session.update_user_metadata(local_user_metadata)
local_user_metadata = local_user.get('metadata')
scene_current = bpy.context.scene.name
local_user = session.online_users.get(settings.username)
current_view_corners = presence.get_view_corners()
# Init client metadata
if not local_user_metadata or 'color' not in local_user_metadata.keys():
metadata = {
'view_corners': presence.get_view_matrix(),
'view_matrix': presence.get_view_matrix(),
'color': (settings.client_color.r,
settings.client_color.g,
settings.client_color.b,
1),
'frame_current':bpy.context.scene.frame_current,
'scene_current': scene_current
}
session.update_user_metadata(metadata)
# sync online users
session_users = operators.client.online_users
ui_users = bpy.context.window_manager.online_users
# Update client representation
# Update client current scene
elif scene_current != local_user_metadata['scene_current']:
local_user_metadata['scene_current'] = scene_current
session.update_user_metadata(local_user_metadata)
elif 'view_corners' in local_user_metadata and current_view_corners != local_user_metadata['view_corners']:
local_user_metadata['view_corners'] = current_view_corners
local_user_metadata['view_matrix'] = presence.get_view_matrix()
session.update_user_metadata(local_user_metadata)
# sync online users
session_users = operators.client.online_users
ui_users = bpy.context.window_manager.online_users
for index, user in enumerate(ui_users):
if user.username not in session_users.keys():
ui_users.remove(index)
renderer.flush_selection()
renderer.flush_users()
break
for index, user in enumerate(ui_users):
if user.username not in session_users.keys():
ui_users.remove(index)
renderer.flush_selection()
renderer.flush_users()
break
for user in session_users:
if user not in ui_users:
new_key = ui_users.add()
new_key.name = user
new_key.username = user
# TODO: event drivent 3d view refresh
presence.refresh_3d_view()
elif session.state['STATE'] == STATE_QUITTING:
presence.refresh_3d_view()
self.handle_quit = True
elif session.state['STATE'] == STATE_INITIAL and self.handle_quit:
self.handle_quit = False
presence.refresh_3d_view()
for user in session_users:
if user not in ui_users:
new_key = ui_users.add()
new_key.name = user
new_key.username = user
elif session.state['STATE'] == STATE_QUITTING:
presence.refresh_sidebar_view()
self.handle_quit = True
elif session.state['STATE'] == STATE_INITIAL and self.handle_quit:
self.handle_quit = False
presence.refresh_sidebar_view()
operators.unregister_delayables()
presence.renderer.stop()
operators.unregister_delayables()
presence.renderer.stop()
# # ui update
elif session.state['STATE'] != STATE_INITIAL:
presence.refresh_3d_view()
presence.refresh_sidebar_view()

8
multi_user/environment.py
View File

@ -23,8 +23,6 @@ import subprocess
import sys
from pathlib import Path
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
THIRD_PARTY = os.path.join(os.path.dirname(os.path.abspath(__file__)), "libs")
DEFAULT_CACHE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cache")
@ -49,8 +47,9 @@ def install_pip():
def install_package(name):
subprocess.run([str(PYTHON_PATH), "-m", "pip", "install",
name], cwd=SUBPROCESS_DIR)
logging.debug(f"Using {PYTHON_PATH} for installation")
subprocess.run([str(PYTHON_PATH), "-m", "pip", "install", name])
def check_dir(dir):
if not os.path.exists(dir):
@ -68,3 +67,4 @@ def setup(dependencies, python_path):
for module_name, package_name in dependencies:
if not module_can_be_imported(module_name):
install_package(package_name)
module_can_be_imported(package_name)

2
multi_user/libs/replication

Submodule multi_user/libs/replication updated: 727bd6bbb1...f9892c2c8c

67
multi_user/operators.py
View File

@ -39,8 +39,6 @@ from .libs.replication.replication.data import ReplicatedDataFactory
from .libs.replication.replication.exception import NonAuthorizedOperationError
from .libs.replication.replication.interface import Session
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
client = None
delayables = []
@ -91,7 +89,7 @@ class SessionStartOperator(bpy.types.Operator):
# init the factory with supported types
for type in bl_types.types_to_register():
type_module = getattr(bl_types, type)
type_impl_name = "Bl{}".format(type.split('_')[1].capitalize())
type_impl_name = f"Bl{type.split('_')[1].capitalize()}"
type_module_class = getattr(type_module, type_impl_name)
supported_bl_types.append(type_module_class.bl_id)
@ -135,7 +133,7 @@ class SessionStartOperator(bpy.types.Operator):
)
except Exception as e:
self.report({'ERROR'}, repr(e))
logger.error(f"Error: {e}")
logging.error(f"Error: {e}")
finally:
runtime_settings.is_admin = True
@ -153,7 +151,7 @@ class SessionStartOperator(bpy.types.Operator):
)
except Exception as e:
self.report({'ERROR'}, repr(e))
logger.error(f"Error: {e}")
logging.error(f"Error: {e}")
finally:
runtime_settings.is_admin = False
@ -177,7 +175,7 @@ class SessionStartOperator(bpy.types.Operator):
self.report(
{'INFO'},
"connexion on tcp://{}:{}".format(settings.ip, settings.port))
f"connecting to tcp://{settings.ip}:{settings.port}")
return {"FINISHED"}
@ -467,8 +465,7 @@ class ApplyArmatureOperator(bpy.types.Operator):
try:
client.apply(node)
except Exception as e:
logger.error(
"fail to apply {}: {}".format(node_ref.uuid, e))
logging.error("Dail to apply armature: {e}")
return {'PASS_THROUGH'}
@ -510,19 +507,7 @@ def load_pre_handler(dummy):
bpy.ops.session.stop()
@persistent
def sanitize_deps_graph(dummy):
"""sanitize deps graph
Temporary solution to resolve each node pointers after a Undo.
A future solution should be to avoid storing dataclock reference...
"""
global client
if client and client.state['STATE'] in [STATE_ACTIVE]:
for node_key in client.list():
client.get(node_key)._resolve()
@persistent
@ -532,40 +517,6 @@ def update_client_frame(scene):
'frame_current': scene.frame_current
})
@persistent
def depsgraph_evaluation(scene):
if client and client.state['STATE'] == STATE_ACTIVE:
context = bpy.context
blender_depsgraph = bpy.context.view_layer.depsgraph
dependency_updates = [u for u in blender_depsgraph.updates]
session_infos = utils.get_preferences()
# NOTE: maybe we don't need to check each update but only the first
for update in reversed(dependency_updates):
# Is the object tracked ?
if update.id.uuid:
# Retrieve local version
node = client.get(update.id.uuid)
# Check our right on this update:
# - if its ours or ( under common and diff), launch the
# update process
# - if its to someone else, ignore the update (go deeper ?)
if node.owner == session_infos.username:
# Avoid slow geometry update
if 'EDIT' in context.mode:
break
logger.error("UPDATE: MODIFIFY {}".format(type(update.id)))
# client.commit(node.uuid)
# client.push(node.uuid)
else:
# Distant update
continue
# else:
# # New items !
# logger.error("UPDATE: ADD")C.obj
def register():
from bpy.utils import register_class
@ -574,13 +525,9 @@ def register():
bpy.app.handlers.load_pre.append(load_pre_handler)
bpy.app.handlers.undo_post.append(sanitize_deps_graph)
bpy.app.handlers.redo_post.append(sanitize_deps_graph)
bpy.app.handlers.frame_change_pre.append(update_client_frame)
# bpy.app.handlers.depsgraph_update_post.append(depsgraph_evaluation)
def unregister():
global client
@ -595,13 +542,9 @@ def unregister():
bpy.app.handlers.load_pre.remove(load_pre_handler)
bpy.app.handlers.undo_post.remove(sanitize_deps_graph)
bpy.app.handlers.redo_post.remove(sanitize_deps_graph)
bpy.app.handlers.frame_change_pre.remove(update_client_frame)
# bpy.app.handlers.depsgraph_update_post.remove(depsgraph_evaluation)
if __name__ == "__main__":
register()

17
multi_user/preferences.py
View File

@ -23,7 +23,6 @@ import string
from . import utils, bl_types, environment, addon_updater_ops, presence, ui
from .libs.replication.replication.constants import RP_COMMON
logger = logging.getLogger(__name__)
def randomColor():
@ -124,6 +123,18 @@ class SessionPrefs(bpy.types.AddonPreferences):
],
default='CONFIG'
)
# WIP
logging_level: bpy.props.EnumProperty(
name="Log level",
description="Log verbosity level",
items=[
('ERROR', "error", "show only errors"),
('WARNING', "warning", "only show warnings and errors"),
('INFO', "info", "default level"),
('DEBUG', "debug", "show all logs"),
],
default='INFO'
)
conf_session_identity_expanded: bpy.props.BoolProperty(
name="Identity",
description="Identity",
@ -287,7 +298,7 @@ class SessionPrefs(bpy.types.AddonPreferences):
new_db = self.supported_datablocks.add()
type_module = getattr(bl_types, type)
type_impl_name = "Bl{}".format(type.split('_')[1].capitalize())
type_impl_name = f"Bl{type.split('_')[1].capitalize()}"
type_module_class = getattr(type_module, type_impl_name)
new_db.name = type_impl_name
@ -398,7 +409,7 @@ def register():
prefs = bpy.context.preferences.addons[__package__].preferences
if len(prefs.supported_datablocks) == 0:
logger.info('Generating bl_types preferences')
logging.debug('Generating bl_types preferences')
prefs.generate_supported_types()

25
multi_user/presence.py
View File

@ -32,10 +32,12 @@ from . import utils
renderer = None
logger = logging.getLogger(__name__)
def view3d_find():
""" Find the first 'VIEW_3D' windows found in areas
:return: tuple(Area, Region, RegionView3D)
"""
for area in bpy.data.window_managers[0].windows[0].screen.areas:
if area.type == 'VIEW_3D':
v3d = area.spaces[0]
@ -43,15 +45,22 @@ def view3d_find():
for region in area.regions:
if region.type == 'WINDOW':
return area, region, rv3d
return None, None, None
def refresh_3d_view():
""" Refresh the viewport
"""
area, region, rv3d = view3d_find()
if area and region and rv3d:
area.tag_redraw()
def refresh_sidebar_view():
""" Refresh the blender sidebar
"""
area, region, rv3d = view3d_find()
area.regions[3].tag_redraw()
def get_target(region, rv3d, coord):
target = [0, 0, 0]
@ -199,7 +208,7 @@ class DrawFactory(object):
def flush_selection(self, user=None):
key_to_remove = []
select_key = "{}_select".format(user) if user else "select"
select_key = f"{user}_select" if user else "select"
for k in self.d3d_items.keys():
if select_key in k:
@ -226,7 +235,7 @@ class DrawFactory(object):
self.flush_selection(client_id)
for select_ob in client_selection:
drawable_key = "{}_select_{}".format(client_id, select_ob)
drawable_key = f"{client_id}_select_{select_ob}"
ob = utils.find_from_attr("uuid", select_ob, bpy.data.objects)
if not ob:
@ -302,7 +311,7 @@ class DrawFactory(object):
self.d2d_items[client_id] = (position[1], client_id, color)
except Exception as e:
logger.error("Draw client exception {}".format(e))
logging.error(f"Draw client exception: {e}")
def draw3d_callback(self):
bgl.glLineWidth(1.5)
@ -316,7 +325,7 @@ class DrawFactory(object):
shader.uniform_float("color", color)
batch.draw(shader)
except Exception:
logger.error("3D Exception")
logging.error("3D Exception")
def draw2d_callback(self):
for position, font, color in self.d2d_items.values():
@ -330,7 +339,7 @@ class DrawFactory(object):
blf.draw(0, font)
except Exception:
logger.error("2D EXCEPTION")
logging.error("2D EXCEPTION")
def register():

5
multi_user/ui.py
View File

@ -48,10 +48,9 @@ def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1,
From here:
https://gist.github.com/greenstick/b23e475d2bfdc3a82e34eaa1f6781ee4
"""
percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
filledLength = int(length * iteration // total)
bar = fill * filledLength + fill_empty * (length - filledLength)
return '{} |{}| {}/{}{}'.format(prefix, bar, iteration,total, suffix)
return f"{prefix} |{bar}| {iteration}/{total}{suffix}"
def get_state_str(state):
state_str = 'UNKNOWN'
@ -422,7 +421,7 @@ def draw_property(context, parent, property_uuid, level=0):
detail_item_box.label(text="",
icon=settings.supported_datablocks[item.str_type].icon)
detail_item_box.label(text="{} ".format(name))
detail_item_box.label(text=f"{name}")
# Operations

3
multi_user/utils.py
View File

@ -29,9 +29,6 @@ import mathutils
from . import environment, presence
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
def find_from_attr(attr_name, attr_value, list):
for item in list:

25
scripts/test_addon.py Normal file
View File

@ -0,0 +1,25 @@
import sys
try:
import blender_addon_tester as BAT
except Exception as e:
print(e)
sys.exit(1)
def main():
if len(sys.argv) > 1:
addon = sys.argv[1]
else:
addon = "multi_user"
if len(sys.argv) > 2:
blender_rev = sys.argv[2]
else:
blender_rev = "2.82"
try:
exit_val = BAT.test_blender_addon(addon_path=addon, blender_revision=blender_rev)
except Exception as e:
print(e)
exit_val = 1
sys.exit(exit_val)
main()

25
tests/test_bl_types/conftest.py Normal file
View File

@ -0,0 +1,25 @@
import os
import pytest
import bpy
@pytest.fixture
def clear_blend():
""" Remove all datablocks of a blend
"""
for type_name in dir(bpy.data):
try:
type_collection = getattr(bpy.data, type_name)
for item in type_collection:
type_collection.remove(item)
except Exception:
continue
@pytest.fixture
def load_blendfile(blendname):
print(f"loading {blendname}")
dir_path = os.path.dirname(os.path.realpath(__file__))
bpy.ops.wm.open_mainfile(filepath=os.path.join(dir_path, blendname))

38
tests/test_bl_types/test_action.py Normal file
View File

@ -0,0 +1,38 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_action import BlAction
INTERPOLATION = ['CONSTANT', 'LINEAR', 'BEZIER', 'SINE', 'QUAD', 'CUBIC', 'QUART', 'QUINT', 'EXPO', 'CIRC', 'BACK', 'BOUNCE', 'ELASTIC']
# @pytest.mark.parametrize('blendname', ['test_action.blend'])
def test_action(clear_blend):
# Generate a random action
datablock = bpy.data.actions.new("sdsad")
fcurve_sample = datablock.fcurves.new('location')
fcurve_sample.keyframe_points.add(100)
datablock.id_root = 'MESH'
for i, point in enumerate(fcurve_sample.keyframe_points):
point.co[0] = i
point.co[1] = random.randint(-10,10)
point.interpolation = INTERPOLATION[random.randint(0, len(INTERPOLATION)-1)]
bpy.ops.mesh.primitive_plane_add()
bpy.data.objects[0].animation_data_create()
bpy.data.objects[0].animation_data.action = datablock
# Test
implementation = BlAction()
expected = implementation._dump(datablock)
bpy.data.actions.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

22
tests/test_bl_types/test_armature.py Normal file
View File

@ -0,0 +1,22 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_armature import BlArmature
def test_armature(clear_blend):
bpy.ops.object.armature_add()
datablock = bpy.data.armatures[0]
implementation = BlArmature()
expected = implementation._dump(datablock)
bpy.data.armatures.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

25
tests/test_bl_types/test_camera.py Normal file
View File

@ -0,0 +1,25 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
from multi_user.bl_types.bl_camera import BlCamera
@pytest.mark.parametrize('camera_type', ['PANO','PERSP','ORTHO'])
def test_camera(clear_blend, camera_type):
bpy.ops.object.camera_add()
datablock = bpy.data.cameras[0]
datablock.type = camera_type
camera_dumper = BlCamera()
expected = camera_dumper._dump(datablock)
bpy.data.cameras.remove(datablock)
test = camera_dumper._construct(expected)
camera_dumper._load(expected, test)
result = camera_dumper._dump(test)
assert not DeepDiff(expected, result)

28
tests/test_bl_types/test_collection.py Normal file
View File

@ -0,0 +1,28 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_collection import BlCollection
def test_collection(clear_blend):
# Generate a collection with childrens and a cube
datablock = bpy.data.collections.new("root")
datablock.children.link(bpy.data.collections.new("child"))
datablock.children.link(bpy.data.collections.new("child2"))
bpy.ops.mesh.primitive_cube_add()
datablock.objects.link(bpy.data.objects[0])
# Test
implementation = BlCollection()
expected = implementation._dump(datablock)
bpy.data.collections.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

29
tests/test_bl_types/test_curve.py Normal file
View File

@ -0,0 +1,29 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_curve import BlCurve
@pytest.mark.parametrize('curve_type', ['TEXT','BEZIER'])
def test_curve(clear_blend, curve_type):
if curve_type == 'TEXT':
bpy.ops.object.text_add(enter_editmode=False, align='WORLD', location=(0, 0, 0))
elif curve_type == 'BEZIER':
bpy.ops.curve.primitive_bezier_curve_add(enter_editmode=False, align='WORLD', location=(0, 0, 0))
else: #TODO: NURBS support
bpy.ops.surface.primitive_nurbs_surface_curve_add(radius=1, enter_editmode=False, align='WORLD', location=(0, 0, 0))
datablock = bpy.data.curves[0]
implementation = BlCurve()
expected = implementation._dump(datablock)
bpy.data.curves.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

23
tests/test_bl_types/test_gpencil.py Normal file
View File

@ -0,0 +1,23 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
from multi_user.bl_types.bl_gpencil import BlGpencil
def test_gpencil(clear_blend):
bpy.ops.object.gpencil_add(type='MONKEY')
datablock = bpy.data.grease_pencils[0]
implementation = BlGpencil()
expected = implementation._dump(datablock)
bpy.data.grease_pencils.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

21
tests/test_bl_types/test_image.py Normal file
View File

@ -0,0 +1,21 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_image import BlImage
def test_image(clear_blend):
datablock = bpy.data.images.new('asd',2000,2000)
implementation = BlImage()
expected = implementation._dump(datablock)
bpy.data.images.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

23
tests/test_bl_types/test_lattice.py Normal file
View File

@ -0,0 +1,23 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
from multi_user.bl_types.bl_lattice import BlLattice
def test_lattice(clear_blend):
bpy.ops.object.add(type='LATTICE', enter_editmode=False, align='WORLD', location=(0, 0, 0))
datablock = bpy.data.lattices[0]
implementation = BlLattice()
expected = implementation._dump(datablock)
bpy.data.lattices.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

24
tests/test_bl_types/test_lightprobes.py Normal file
View File

@ -0,0 +1,24 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
from multi_user.bl_types.bl_lightprobe import BlLightprobe
@pytest.mark.skipif(bpy.app.version[1] < 83, reason="requires blender 2.83 or higher")
@pytest.mark.parametrize('lightprobe_type', ['PLANAR','GRID','CUBEMAP'])
def test_lightprobes(clear_blend, lightprobe_type):
bpy.ops.object.lightprobe_add(type=lightprobe_type)
blender_light = bpy.data.lightprobes[0]
lightprobe_dumper = BlLightprobe()
expected = lightprobe_dumper._dump(blender_light)
bpy.data.lightprobes.remove(blender_light)
test = lightprobe_dumper._construct(expected)
lightprobe_dumper._load(expected, test)
result = lightprobe_dumper._dump(test)
assert not DeepDiff(expected, result)

23
tests/test_bl_types/test_lights.py Normal file
View File

@ -0,0 +1,23 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
from multi_user.bl_types.bl_light import BlLight
@pytest.mark.parametrize('light_type', ['SPOT','SUN','POINT','AREA'])
def test_light(clear_blend, light_type):
bpy.ops.object.light_add(type=light_type)
blender_light = bpy.data.lights[0]
light_dumper = BlLight()
expected = light_dumper._dump(blender_light)
bpy.data.lights.remove(blender_light)
test = light_dumper._construct(expected)
light_dumper._load(expected, test)
result = light_dumper._dump(test)
assert not DeepDiff(expected, result)

28
tests/test_bl_types/test_material.py Normal file
View File

@ -0,0 +1,28 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
from multi_user.bl_types.bl_material import BlMaterial
def test_material(clear_blend):
nodes_types = [node.bl_rna.identifier for node in bpy.types.ShaderNode.__subclasses__()]
datablock = bpy.data.materials.new("test")
datablock.use_nodes = True
bpy.data.materials.create_gpencil_data(datablock)
for ntype in nodes_types:
datablock.node_tree.nodes.new(ntype)
implementation = BlMaterial()
expected = implementation._dump(datablock)
bpy.data.materials.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

28
tests/test_bl_types/test_mesh.py Normal file
View File

@ -0,0 +1,28 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_mesh import BlMesh
@pytest.mark.parametrize('mesh_type', ['EMPTY','FILLED'])
def test_mesh(clear_blend, mesh_type):
if mesh_type == 'FILLED':
bpy.ops.mesh.primitive_monkey_add()
elif mesh_type == 'EMPTY':
bpy.data.meshes.new('empty_mesh')
datablock = bpy.data.meshes[0]
# Test
implementation = BlMesh()
expected = implementation._dump(datablock)
bpy.data.meshes.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

23
tests/test_bl_types/test_metaball.py Normal file
View File

@ -0,0 +1,23 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
from multi_user.bl_types.bl_metaball import BlMetaball
@pytest.mark.parametrize('metaballs_type', ['PLANE','CAPSULE','BALL','ELLIPSOID','CUBE'])
def test_metaball(clear_blend, metaballs_type):
bpy.ops.object.metaball_add(type=metaballs_type)
datablock = bpy.data.metaballs[0]
dumper = BlMetaball()
expected = dumper._dump(datablock)
bpy.data.metaballs.remove(datablock)
test = dumper._construct(expected)
dumper._load(expected, test)
result = dumper._dump(test)
assert not DeepDiff(expected, result)

64
tests/test_bl_types/test_object.py Normal file
View File

@ -0,0 +1,64 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_object import BlObject
# Removed 'BUILD' modifier because the seed doesn't seems to be
# correctly initialized (#TODO: report the bug)
MOFIFIERS_TYPES = [
'DATA_TRANSFER', 'MESH_CACHE', 'MESH_SEQUENCE_CACHE',
'NORMAL_EDIT', 'WEIGHTED_NORMAL', 'UV_PROJECT', 'UV_WARP',
'VERTEX_WEIGHT_EDIT', 'VERTEX_WEIGHT_MIX',
'VERTEX_WEIGHT_PROXIMITY', 'ARRAY', 'BEVEL', 'BOOLEAN',
'DECIMATE', 'EDGE_SPLIT', 'MASK', 'MIRROR',
'MULTIRES', 'REMESH', 'SCREW', 'SKIN', 'SOLIDIFY',
'SUBSURF', 'TRIANGULATE',
'WELD', 'WIREFRAME', 'ARMATURE', 'CAST', 'CURVE',
'DISPLACE', 'HOOK', 'LAPLACIANDEFORM', 'LATTICE',
'MESH_DEFORM', 'SHRINKWRAP', 'SIMPLE_DEFORM', 'SMOOTH',
'CORRECTIVE_SMOOTH', 'LAPLACIANSMOOTH', 'SURFACE_DEFORM',
'WARP', 'WAVE', 'CLOTH', 'COLLISION', 'DYNAMIC_PAINT',
'EXPLODE', 'FLUID', 'OCEAN', 'PARTICLE_INSTANCE',
'SOFT_BODY', 'SURFACE']
CONSTRAINTS_TYPES = [
'CAMERA_SOLVER', 'FOLLOW_TRACK', 'OBJECT_SOLVER', 'COPY_LOCATION',
'COPY_ROTATION', 'COPY_SCALE', 'COPY_TRANSFORMS', 'LIMIT_DISTANCE',
'LIMIT_LOCATION', 'LIMIT_ROTATION', 'LIMIT_SCALE', 'MAINTAIN_VOLUME',
'TRANSFORM', 'TRANSFORM_CACHE', 'CLAMP_TO', 'DAMPED_TRACK', 'IK',
'LOCKED_TRACK', 'SPLINE_IK', 'STRETCH_TO', 'TRACK_TO', 'ACTION',
'ARMATURE', 'CHILD_OF', 'FLOOR', 'FOLLOW_PATH', 'PIVOT', 'SHRINKWRAP']
def test_object(clear_blend):
bpy.ops.mesh.primitive_cube_add(
enter_editmode=False, align='WORLD', location=(0, 0, 0))
datablock = bpy.data.objects[0]
# Add modifiers
for mod_type in MOFIFIERS_TYPES:
datablock.modifiers.new(mod_type,mod_type)
# Add constraints
for const_type in CONSTRAINTS_TYPES:
datablock.constraints.new(const_type)
datablock.vertex_groups.new(name='vg')
datablock.vertex_groups.new(name='vg1')
datablock.shape_key_add(name='shape')
datablock.shape_key_add(name='shape2')
implementation = BlObject()
expected = implementation._dump(datablock)
bpy.data.objects.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

22
tests/test_bl_types/test_scene.py Normal file
View File

@ -0,0 +1,22 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_scene import BlScene
def test_scene(clear_blend):
datablock = bpy.data.scenes.new("toto")
datablock.view_settings.use_curve_mapping = True
# Test
implementation = BlScene()
expected = implementation._dump(datablock)
bpy.data.scenes.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

22
tests/test_bl_types/test_speaker.py Normal file
View File

@ -0,0 +1,22 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_speaker import BlSpeaker
def test_speaker(clear_blend):
bpy.ops.object.speaker_add()
datablock = bpy.data.speakers[0]
implementation = BlSpeaker()
expected = implementation._dump(datablock)
bpy.data.speakers.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

22
tests/test_bl_types/test_world.py Normal file
View File

@ -0,0 +1,22 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
from multi_user.bl_types.bl_world import BlWorld
def test_world(clear_blend):
datablock = bpy.data.worlds.new('test')
datablock.use_nodes = True
implementation = BlWorld()
expected = implementation._dump(datablock)
bpy.data.worlds.remove(datablock)
test = implementation._construct(expected)
implementation._load(expected, test)
result = implementation._dump(test)
assert not DeepDiff(expected, result)

20
tests/test_operators.py Normal file
View File

@ -0,0 +1,20 @@
import os
import pytest
from deepdiff import DeepDiff
import bpy
import random
def test_start_session():
result = bpy.ops.session.start()
assert 'FINISHED' in result
def test_stop_session():
result = bpy.ops.session.stop()
assert 'FINISHED' in result