def test_create_materials(self): not_a_mesh = Object() mesh_with_0_mat = Object() mesh_with_1_mat = Object() mesh_with_2_mat = Object() mesh_with_0_mat.data = Mesh() mesh_with_1_mat.data = Mesh() mesh_with_2_mat.data = Mesh() material = Material() material.name = "material" material.diffuse_color = [1.0, 1.0, 1.0, 1.0] mesh_with_0_mat.data.materials = [] mesh_with_1_mat.data.materials = [material] * 1 mesh_with_2_mat.data.materials = [material] * 2 exporter = Exporter() exporter.create_materials( [not_a_mesh, mesh_with_0_mat, mesh_with_1_mat, mesh_with_2_mat]) self.assertEqual(len(exporter.names), 4) self.assertEqual(len(exporter.materials), 4) self.assertEqual(exporter.materials[0], exporter.get_default_material()) self.assertEqual(not_a_mesh.data in exporter.materials_by_mesh, False) self.assertEqual(len(exporter.materials_by_mesh[mesh_with_0_mat.data]), 0) self.assertEqual(len(exporter.materials_by_mesh[mesh_with_1_mat.data]), 1) self.assertEqual(len(exporter.materials_by_mesh[mesh_with_2_mat.data]), 2)
def apply_modifiers(obj: Object, calc_undeformed: bool = False): """ apply modifiers to object """ m = obj.to_mesh(bpy.context.depsgraph if b280() else bpy.context.scene, True, calc_undeformed=calc_undeformed) obj.modifiers.clear() obj.data = m
def test_create_vector_groups(self): not_a_mesh = Object() mesh = Object() mesh.data = Mesh() vertex = MeshVertex() mesh.data.vertices = [vertex] * 3 n_x = MeshLoop() n_x.normal = [1.0, 0.0, 0.0] n_y = MeshLoop() n_y.normal = [0.0, 1.0, 0.0] n_z = MeshLoop() n_z.normal = [0.0, 0.0, 1.0] mesh.data.loops = [n_x, n_y, n_z] tri = MeshLoopTriangle() tri.vertices = [0, 1, 2] tri.loops = [0, 1, 2] mesh.data.loop_triangles = [tri] exporter = Exporter() exporter.create_vector_groups([not_a_mesh, mesh]) self.assertEqual(len(exporter.tri_nv_groups), len(exporter.vtx_nv_groups)) self.assertEqual(not_a_mesh.data in exporter.normal_indices_by_mesh, False) self.assertEqual(exporter.normal_indices_by_mesh[mesh.data], [0, 1, 2]) self.assertEqual(exporter.tri_nv_groups[0].tri_nv_num, 1) self.assertEqual(exporter.tri_nv_groups[1].tri_nv_num, 1) self.assertEqual(exporter.vtx_nv_groups[0].vtx_nv_num, 1) self.assertEqual(exporter.vtx_nv_groups[1].vtx_nv_num, 3)
def add_driver_to_vars(obj: bpy_types.Object, prop_to, variables, expression: str = None) -> None: """ Add a driver to obj's prop_to property Each var must be under the form : (var_name, id_type, _id, prop_from)""" if obj: if type(prop_to) is tuple: driver = obj.driver_add(prop_to[0], prop_to[1]).driver else: driver = obj.driver_add(prop_to).driver ModifierManager.drivers.append((obj, prop_to)) for i, var_prop in enumerate(variables): try: var = driver.variables[i] except IndexError: var = driver.variables.new() var.name = var_prop[0] var.type = 'SINGLE_PROP' target = var.targets[0] target.id_type = var_prop[1] target.id = var_prop[2] target.data_path = str(var_prop[3]) if expression: driver.expression = expression else: driver.expression = variables[0][0]
def safeUnlink(obj: Object, protect: bool = True): scn = bpy.context.scene try: unlink_object(obj) except RuntimeError: pass obj.protected = protect obj.use_fake_user = True
def safeLink(obj: Object, protect: bool = False, collections=None): collections = collections or [scn.collection] for coll in collections: try: coll.objects.link(obj) except RuntimeError: continue obj.protected = protect obj.use_fake_user = False
def safe_unlink(obj: Object, protect: bool = True): # unlink object from scene try: unlink_object(obj, all=True) except RuntimeError: pass # prevent object data from being tossed on Blender exit obj.use_fake_user = True # protect object from deletion (useful in Bricker addon) if hasattr(obj, "protected"): obj.protected = protect
def safeUnlink(obj:Object, protect:bool=True): # unlink object from scene try: unlink_object(obj) except RuntimeError: pass # prevent object data from being tossed on Blender exit obj.use_fake_user = True # protect object from deletion (useful in Bricker addon) if hasattr(obj, "protected"): obj.protected = protect
def safeLink(obj:Object, protect:bool=False, collections=None): # link object to scene try: link_object(obj) except RuntimeError: pass # remove fake user from object data obj.use_fake_user = False # protect object from deletion (useful in Bricker addon) if hasattr(obj, "protected"): obj.protected = protect
def safe_link(obj: Object, protect: bool = False, collections=None): # link object to scene try: link_object(obj) except RuntimeError: pass # remove fake user from object data obj.use_fake_user = False # protect object from deletion (useful in Bricker addon) if hasattr(obj, "protected"): obj.protected = protect
def safeLink(obj:Object, protect:bool=False, collections=None): # link object to target collections (scene collection by default) collections = collections or [bpy.context.scene.collection] for coll in collections: try: coll.objects.link(obj) except RuntimeError: continue # remove fake user from object data obj.use_fake_user = False # protect object from deletion (useful in Bricker addon) if hasattr(obj, "protected"): obj.protected = protect
def safe_link(obj: Object, protect: bool = False, collections=[]): # link object to target collections (scene collection by default) collections = collections or [bpy.context.scene.collection] for coll in collections: try: coll.objects.link(obj) except RuntimeError: continue # remove fake user from object data obj.use_fake_user = False # protect object from deletion (useful in Bricker addon) if hasattr(obj, "protected"): obj.protected = protect
def apply_transform(obj:Object, location:bool=True, rotation:bool=True, scale:bool=True): loc, rot, scale = obj.matrix_world.decompose() obj.matrix_world = Matrix.Identity(4) m = obj.data s_mat_x = Matrix.Scale(scale.x, 4, Vector((1, 0, 0))) s_mat_y = Matrix.Scale(scale.y, 4, Vector((0, 1, 0))) s_mat_z = Matrix.Scale(scale.z, 4, Vector((0, 0, 1))) if scale: m.transform(s_mat_x * s_mat_y * s_mat_z) else: obj.scale = scale if rotation: m.transform(rot.to_matrix().to_4x4()) else: obj.rotation_euler = rot.to_euler() if location: m.transform(Matrix.Translation(loc)) else: obj.location = loc
def test_create_shapes(self): obj = Object() mesh = Mesh() mesh.name = "mesh" obj.data = mesh mat_red = Material() mat_red.name = "red" mat_red.diffuse_color = [1.0, 0.0, 0.0, 1.0] mesh.materials = [mat_red] vertex = MeshVertex() vertex.co = [0.0, 0.0, 0.0] mesh.vertices = [vertex] * 3 uv_loop = MeshUVLoop() uv_loop.uv = [0.5, 0.5] uv_loop_layer = MeshUVLoopLayer() uv_loop_layer.data = [uv_loop] * 3 mesh.uv_layers = [uv_loop_layer] loop = MeshLoop() loop.normal = [1.0, 2.0, 3.0] mesh.loops = [loop] * 3 tri_red = MeshLoopTriangle() tri_red.vertices = [0, 1, 2] tri_red.loops = [0, 1, 2] tri_red.material_index = 0 mesh.loop_triangles = [tri_red] exporter = Exporter() exporter.create_materials([obj]) exporter.create_vertex_groups([obj]) exporter.create_vector_groups([obj]) exporter.create_st_groups([obj]) exporter.create_tri_groups([obj]) exporter.create_parts([obj]) exporter.create_shapes([obj]) self.assertEqual(exporter.shapes[0].shape_tri_link, exporter.tri_groups[0].this_tri_group_index) self.assertEqual(exporter.shapes[0].shape_mat_link, exporter.get_default_material().this_mat_index) self.assertEqual(exporter.shapes[0].shape_part_num, 1) self.assertEqual(exporter.shape_by_mesh[mesh], exporter.shapes[0])
def apply_transform(obj:Object, location:bool=True, rotation:bool=True, scale:bool=True): """ apply object transformation to mesh """ loc, rot, scale = obj.matrix_world.decompose() obj.matrix_world = Matrix.Identity(4) m = obj.data s_mat_x = Matrix.Scale(scale.x, 4, Vector((1, 0, 0))) s_mat_y = Matrix.Scale(scale.y, 4, Vector((0, 1, 0))) s_mat_z = Matrix.Scale(scale.z, 4, Vector((0, 0, 1))) if scale: m.transform(mathutils_mult(s_mat_x, s_mat_y, s_mat_z)) else: obj.scale = scale if rotation: m.transform(rot.to_matrix().to_4x4()) else: obj.rotation_euler = rot.to_euler() if location: m.transform(Matrix.Translation(loc)) else: obj.location = loc
def copyAnimationData(source:Object, target:Object): """ copy animation data from one object to another """ if source.animation_data is None: return ad = source.animation_data properties = [p.identifier for p in ad.bl_rna.properties if not p.is_readonly] if target.animation_data is None: target.animation_data_create() ad2 = target.animation_data for prop in properties: setattr(ad2, prop, getattr(ad, prop))
def cast_rays(obj_eval: Object, point: Vector, direction: Vector, mini_dist: float, round_type: str = "CEILING", edge_len: int = 0): """ obj_eval -- source object to test intersections for point -- starting point for ray casting direction -- cast ray in this direction mini_dist -- Vector with miniscule amount to add after intersection round_type -- round final intersection location Vector with this type edge_len -- distance to test for intersections """ # initialize variables first_direction = False first_intersection = None next_intersection_loc = None last_intersection = None edge_intersects = False edge_len2 = round(edge_len + 0.000001, 6) starting_point = point intersections = 0 # cast rays until no more rays to cast while True: _, location, normal, index = obj_eval.ray_cast( starting_point, direction) #distance=edge_len*1.00000000001) if index == -1: break if intersections == 0: first_direction = direction.dot(normal) if edge_len != 0: dist = (location - point).length # get first and last intersection (used when getting materials of nearest (first or last intersected) face) if dist <= edge_len2: if intersections == 0: edge_intersects = True first_intersection = { "idx": index, "dist": dist, "loc": location, "normal": normal } last_intersection = { "idx": index, "dist": edge_len - dist, "loc": location, "normal": normal } # set next_intersection_loc if next_intersection_loc is None: next_intersection_loc = location.copy() intersections += 1 location = vec_round(location, precision=6, round_type=round_type) starting_point = location + mini_dist if edge_len != 0: return intersections, first_direction, first_intersection, next_intersection_loc, last_intersection, edge_intersects else: return intersections, first_direction
def castRays(obj: Object, point: Vector, direction: Vector, miniDist: float, roundType: str = "CEILING", edgeLen: int = 0): """ obj -- source object to test intersections for point -- origin point for ray casting direction -- cast ray in this direction miniDist -- Vector with miniscule amount to add after intersection roundType -- round final intersection location Vector with this type edgeLen -- distance to test for intersections """ # initialize variables firstDirection = False firstIntersection = None nextIntersection = None lastIntersection = None edgeIntersects = False edgeLen2 = edgeLen * 1.00001 orig = point intersections = 0 # cast rays until no more rays to cast while True: _, location, normal, index = obj.ray_cast( orig, direction) #distance=edgeLen*1.00000000001) if index == -1: break if intersections == 0: firstDirection = direction.dot(normal) if edgeLen != 0: dist = (location - point).length # get first and last intersection (used when getting materials of nearest (first or last intersected) face) if dist <= edgeLen2: if intersections == 0: edgeIntersects = True firstIntersection = { "idx": index, "dist": dist, "loc": location, "normal": normal } lastIntersection = { "idx": index, "dist": edgeLen - dist, "loc": location, "normal": normal } # set nextIntersection if nextIntersection is None: nextIntersection = location.copy() intersections += 1 location = VectorRound(location, 5, roundType=roundType) orig = location + miniDist if edgeLen != 0: return intersections, firstDirection, firstIntersection, nextIntersection, lastIntersection, edgeIntersects else: return intersections, firstDirection
def position_bone_in_animation_frame( self, armature_obj: Object, animation_frame_armature_bone_model: 'BlenderPoseModeAnimationFrameModelNode'): pose = armature_obj.pose # type: Pose complementary_pose_bone = pose.bones.get(animation_frame_armature_bone_model.bone_name) # type: PoseBone complementary_pose_bone.rotation_mode = 'QUATERNION' if animation_frame_armature_bone_model.bone_name != "ROOT_CHANNEL": loc = Matrix.Translation(Vector(( animation_frame_armature_bone_model.position.x, animation_frame_armature_bone_model.position.y, animation_frame_armature_bone_model.position.z))) rot = Quaternion(Vector(( animation_frame_armature_bone_model.rotation.w, animation_frame_armature_bone_model.rotation.x, animation_frame_armature_bone_model.rotation.y, animation_frame_armature_bone_model.rotation.z)), ).to_matrix().to_4x4() scale = Matrix() scale[0][0] = animation_frame_armature_bone_model.scale.x scale[1][1] = animation_frame_armature_bone_model.scale.y scale[2][2] = animation_frame_armature_bone_model.scale.z world_mat = loc @ rot @ scale complementary_pose_bone.matrix = armature_obj.convert_space( pose_bone=complementary_pose_bone, matrix=world_mat, from_space='WORLD', to_space='POSE')
def create(name: str, location: Vector, template: Object, collection: Collection) \ -> bpy.types.Object: obj = template.copy() obj.name = name obj.location = location collection.objects.link(obj) return obj
def ob_copy_to_faces(ob: Object) -> None: mats = mesh.face_pos() if mats: ob.matrix_world = mats.pop() collection = bpy.context.collection space_data = bpy.context.space_data use_local_view = bool(space_data.local_view) for mat in mats: ob_copy = ob.copy() collection.objects.link(ob_copy) ob_copy.matrix_world = mat ob_copy.select_set(True) if use_local_view: ob_copy.local_view_set(space_data, True)
def duplicate(obj:Object, linked:bool=False, link_to_scene:bool=False): """ efficient duplication of objects """ copy = obj.copy() if not linked and copy.data: copy.data = copy.data.copy() copy.hide = False if link_to_scene: bpy.context.scene.objects.link(copy) return copy
def duplicate(obj: Object, linked: bool = False, link_to_scene: bool = False): """ efficient duplication of objects """ copy = obj.copy() if not linked and copy.data: copy.data = copy.data.copy() unhide(copy, render=False) if link_to_scene: link_object(copy) return copy
def duplicate(obj:Object, linked:bool=False, link_to_scene:bool=False): """ efficient duplication of objects """ copy = obj.copy() if not linked and copy.data: copy.data = copy.data.copy() unhide(copy, render=False) if link_to_scene: link_object(copy) return copy
def est_curve_length(ob: Object) -> float: if ob.modifiers: # Reset curve # --------------------------- settings = { "bevel_object": None, "bevel_depth": 0.0, "extrude": 0.0, } for k, v in settings.items(): x = getattr(ob.data, k) setattr(ob.data, k, v) settings[k] = x # Calculate length # --------------------------- depsgraph = bpy.context.evaluated_depsgraph_get() ob_eval = ob.evaluated_get(depsgraph) me = ob_eval.to_mesh() me.transform(ob.matrix_world) bm = bmesh.new() bm.from_mesh(me) ob_eval.to_mesh_clear() length = 0.0 for edge in bm.edges: length += edge.calc_length() bm.free() # Restore curve # --------------------------- for k, v in settings.items(): setattr(ob.data, k, v) else: curve = ob.data.copy() curve.transform(ob.matrix_world) length = 0.0 for spline in curve.splines: length += spline.calc_length() bpy.data.curves.remove(curve) return length
def test_create_textures(self): image = Image() image.filepath = "//test/image/path.png" image.library = "//test/image/library" node = ShaderNodeTexImage() node.image = image material = Material() material.name = "material" material.diffuse_color = [1.0, 1.0, 1.0, 1.0] material.use_nodes = True material.node_tree = NodeTree() material.node_tree.nodes = [node] mesh = Mesh() mesh.materials = [material] obj = Object() obj.data = mesh bpy.path.abspath = Mock(return_value=image.filepath) bpy.path.display_name_from_filepath = Mock(return_value="texture") reader = Mock() reader.read = Mock(return_value=[12, 34, [[0x05, 0x06], [0x07, 0x08]]]) png.Reader = Mock(return_value=reader) exporter = Exporter() exporter.create_textures([obj]) bpy.path.abspath.assert_called_once_with( "//test/image/path.png", library="//test/image/library") bpy.path.display_name_from_filepath.assert_called_once_with( "//test/image/path.png") png.Reader.assert_called_once_with("//test/image/path.png") reader.read.assert_called_once() self.assertEqual(exporter.names[0].node_name, "texture.tex") self.assertEqual(exporter.tex_images[0].tex_img_data, [5, 6, 7, 8]) self.assertEqual(exporter.textures[0].tex_img_width, 12) self.assertEqual(exporter.textures[0].tex_img_height, 34)
def apply_transform(obj:Object, location:bool=True, rotation:bool=True, scale:bool=True): """ apply object transformation to mesh """ loc, rot, scl = obj.matrix_world.decompose() obj.matrix_world = Matrix.Identity(4) m = obj.data s_mat_x = Matrix.Scale(scl.x, 4, Vector((1, 0, 0))) s_mat_y = Matrix.Scale(scl.y, 4, Vector((0, 1, 0))) s_mat_z = Matrix.Scale(scl.z, 4, Vector((0, 0, 1))) if scale: m.transform(mathutils_mult(s_mat_x, s_mat_y, s_mat_z)) else: obj.scale = scl if rotation: m.transform(rot.to_matrix().to_4x4()) else: obj.rotation_euler = rot.to_euler() if location: m.transform(Matrix.Translation(loc)) else: obj.location = loc
def test_create_vertex_groups(self): not_a_mesh = Object() mesh = Object() mesh.data = Mesh() mesh.data.name = "mesh" vertex = MeshVertex() vertex.co = [0.0, 0.0, 0.0] mesh.data.vertices = [vertex] * 10 exporter = Exporter() exporter.create_vertex_groups([not_a_mesh, mesh]) self.assertEqual(len(exporter.names), 1) self.assertEqual(len(exporter.vtx_groups), 1) self.assertEqual(not_a_mesh.data in exporter.vtx_group_by_mesh, False) self.assertEqual(exporter.vtx_group_by_mesh[mesh.data], exporter.vtx_groups[0])
def new_mesh_from_object(obj: Object): unlink_later = False depsgraph = bpy.context.evaluated_depsgraph_get() # link the object if it's not in the scene, because otherwise the evaluated data may be outdated (e.g. after file is reopened) if obj.name not in bpy.context.scene.objects: link_object(obj) depsgraph_update() unlink_later = True obj_eval = obj.evaluated_get(depsgraph) if unlink_later: unlink_object(obj) return bpy.data.meshes.new_from_object(obj_eval)
def setObjOrigin(obj: Object, loc: Vector): """ set object origin """ l, r, s = obj.matrix_world.decompose() l_mat = Matrix.Translation(l) r_mat = r.to_matrix().to_4x4() s_mat_x = Matrix.Scale(s.x, 4, Vector((1, 0, 0))) s_mat_y = Matrix.Scale(s.y, 4, Vector((0, 1, 0))) s_mat_z = Matrix.Scale(s.z, 4, Vector((0, 0, 1))) s_mat = mathutils_mult(s_mat_x, s_mat_y, s_mat_z) m = obj.data mx = mathutils_mult((obj.location - loc), l_mat, r_mat, s_mat.inverted()) m.transform(Matrix.Translation(mx)) obj.location = loc
def apply_transform(obj: Object): """ efficiently apply object transformation """ # select(obj, active=True, only=True) # bpy.ops.object.transform_apply(location=True, rotation=True, scale=True) loc, rot, scale = obj.matrix_world.decompose() obj.matrix_world = Matrix.Identity(4) m = obj.data s_mat_x = Matrix.Scale(scale.x, 4, Vector((1, 0, 0))) s_mat_y = Matrix.Scale(scale.y, 4, Vector((0, 1, 0))) s_mat_z = Matrix.Scale(scale.z, 4, Vector((0, 0, 1))) m.transform(s_mat_x * s_mat_y * s_mat_z) m.transform(rot.to_matrix().to_4x4()) m.transform(Matrix.Translation(loc))
def test_create_tri_groups(self): not_a_mesh = Object() mesh = Object() mesh.data = Mesh() mesh.data.name = "mesh" vertex = MeshVertex() vertex.co = [0.0, 0.0, 0.0] mesh.data.vertices = [vertex] * 3 uv_loop = MeshUVLoop() uv_loop.uv = [0.5, 0.5] uv_loop_layer = MeshUVLoopLayer() uv_loop_layer.data = [uv_loop] * 3 mesh.data.uv_layers = [uv_loop_layer] loop = MeshLoop() loop.normal = [1.0, 2.0, 3.0] mesh.data.loops = [loop] * 3 tri = MeshLoopTriangle() tri.vertices = [0, 1, 2] tri.loops = [0, 1, 2] mesh.data.loop_triangles = [tri] exporter = Exporter() exporter.create_vertex_groups([not_a_mesh, mesh]) exporter.create_vector_groups([not_a_mesh, mesh]) exporter.create_st_groups([not_a_mesh, mesh]) exporter.create_tri_groups([not_a_mesh, mesh]) self.assertEqual(len(exporter.tri_groups), 1) self.assertEqual(not_a_mesh.data in exporter.tri_group_by_mesh, False) self.assertEqual(exporter.tri_group_by_mesh[mesh.data], exporter.tri_groups[0])
def ob_copy_and_parent(ob: Object, parents: Iterable[Object]) -> None: is_orig = True space_data = bpy.context.space_data use_local_view = bool(space_data.local_view) for parent in parents: if is_orig: ob_copy = ob is_orig = False else: ob_copy = ob.copy() for coll in parent.users_collection: coll.objects.link(ob_copy) if use_local_view: ob_copy.local_view_set(space_data, True) ob_copy.select_set(True) ob.location = parent.location ob.rotation_euler = parent.rotation_euler ob.parent = parent ob.matrix_parent_inverse = parent.matrix_basis.inverted()
def _create_dstr(ob: Object, curve: Object, sizes: list, con_add=True) -> list[tuple[Constraint, float, float]]: space_data = bpy.context.space_data use_local_view = bool(space_data.local_view) ob_colls = ob.users_collection child_colls = [(child, child.users_collection) for child in ob.children] obs = [] app = obs.append for is_last, size in iterutils.spot_last(_flatten(sizes)): if is_last: ob_copy = ob else: ob_copy = ob.copy() for coll in ob_colls: coll.objects.link(ob_copy) if use_local_view: ob_copy.local_view_set(space_data, True) for child, colls in child_colls: child_copy = child.copy() for coll in colls: coll.objects.link(child_copy) child_copy.parent = ob_copy child_copy.matrix_parent_inverse = child.matrix_parent_inverse if con_add: con = ob_copy.constraints.new("FOLLOW_PATH") con.target = curve con.use_curve_follow = True con.forward_axis = "FORWARD_X" else: for con in ob_copy.constraints: if con.type == "FOLLOW_PATH": break scaling = size / ob_copy.dimensions.y if not _eq(scaling, 1.0): ob_copy.scale *= scaling app((con, None, size)) return obs
def generate_uv_map_materials(use_existing_materials: str, uv_image_path: str, model_name: str, capmodel: Object) -> [str, str]: uv_material_name: str = model_name + '_material' if uv_material_name not in data.materials or not use_existing_materials: # Overwrite material if not using existing ones! if uv_material_name in data.materials: printw( 'Existing material named "%s" is overwritten, you may require the "use existing materials" option' % uv_material_name) data.materials.remove(data.materials[uv_material_name]) mat = data.materials.new(name=uv_material_name) mat.use_nodes = True mat_nodes = mat.node_tree.nodes mat_edges = mat.node_tree.links # Get BSDF shader node bsdfNode: ShaderNodeBsdfPrincipled = mat_nodes['Principled BSDF'] # Add coordinate and image nodes coordsNode: ShaderNodeTexCoord = mat_nodes.new('ShaderNodeTexCoord') imgNode: ShaderNodeTexImage = mat_nodes.new('ShaderNodeTexImage') # Position the new nodes relative to the old ones node_horizontal_margin_offset: Vector = Vector((300.0, 0.0)) imgNode.location = bsdfNode.location - node_horizontal_margin_offset coordsNode.location = imgNode.location - node_horizontal_margin_offset # Add appropriate edges mat_edges.new(coordsNode.outputs['UV'], imgNode.inputs['Vector']) mat_edges.new(imgNode.outputs['Color'], bsdfNode.inputs['Base Color']) else: bpy_internal_uv_image_name: str = basename(uv_image_path) imgNode = get_only( [ n for n in data.materials[uv_material_name].node_tree.nodes if n.type == 'TEX_IMAGE' and n.image is not None and n.image.name is not None and n.image.name.endswith(bpy_internal_uv_image_name) ], 'No image node for "%s" found in material "%s" when trying to use existing materials for uv' % (bpy_internal_uv_image_name, uv_material_name), 'Multiple image nodes for "%s" were found in material "%s" when trying to use existing materials for uv' % (bpy_internal_uv_image_name, uv_material_name)) capmodel.active_material = data.materials[uv_material_name] return (imgNode, uv_material_name)
def _children_to_fds(self, context) -> "list": """Export children in FDS notation.""" # Init bodies = list() # Materials bodies.append("! --- Boundary conditions (from Blender Materials)\n\n") mas = [ma for ma in bpy.data.materials] mas.sort(key=lambda k: k.name) # Alphabetic order by element name for ma in mas: body = ma.to_fds(context) if body: bodies.append(body) bodies.append("\n") # Objects bodies.append("! --- Geometric entities (from Blender Objects)\n\n") bodies.extend(Object._children_to_fds(self=None, context=context)) # Call objects without a parent bodies.append("\n") # Return return bodies
def hide(obj:Object, viewport:bool=True, render:bool=True): if not obj.hide_viewport and viewport: obj.hide_viewport = True if not obj.hide_render and render: obj.hide_render = True
def unhide(obj:Object, viewport:bool=True, render:bool=True): if obj.hide_viewport and viewport: obj.hide_viewport = False if obj.hide_render and render: obj.hide_render = False
def apply_modifiers(obj:Object, settings:str="PREVIEW"): """ apply modifiers to object """ m = obj.to_mesh(bpy.context.scene, True, "PREVIEW") obj.modifiers.clear() obj.data = m