Python bpy.ops方法代码示例

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def updater_run_success_popup_handler(scene):
    global ran_update_sucess_popup
    ran_update_sucess_popup = True

    # in case of error importing updater
    if updater.invalidupdater == True:
        return

    try:
        bpy.app.handlers.scene_update_post.remove(
                updater_run_success_popup_handler)
    except:
        pass

    atr = addon_updater_updated_successful.bl_idname.split(".")
    getattr(getattr(bpy.ops, atr[0]),atr[1])('INVOKE_DEFAULT') 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def post_update_callback(res=None):

    # in case of error importing updater
    if updater.invalidupdater == True:
        return

    if res==None:
        # this is the same code as in conditional at the end of the register function
        # ie if "auto_reload_post_update" == True, comment out this code
        if updater.verbose: print("{} updater: Running post update callback".format(updater.addon))
        #bpy.app.handlers.scene_update_post.append(updater_run_success_popup_handler)

        atr = addon_updater_updated_successful.bl_idname.split(".")
        getattr(getattr(bpy.ops, atr[0]),atr[1])('INVOKE_DEFAULT')
        global ran_update_sucess_popup
        ran_update_sucess_popup = True
    else:
        # some kind of error occured and it was unable to install,
        # offer manual download instead
        atr = addon_updater_updated_successful.bl_idname.split(".")
        getattr(getattr(bpy.ops, atr[0]),atr[1])('INVOKE_DEFAULT',error=res)
    return


# function for asynchronous background check, which *could* be called on register 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def __repr__(self):  # useful display, repr(op)
        # import bpy
        idname = self.idname()
        as_string = op_as_string(idname)
        # XXX You never quite know what you get from bpy.types,
        # with operators... Operator and OperatorProperties
        # are shadowing each other, and not in the same way for
        # native ops and py ones! See T39158.
        # op_class = getattr(bpy.types, idname)
        op_class = op_get_rna(idname)
        descr = op_class.bl_rna.description
        # XXX, workaround for not registering
        # every __doc__ to save time on load.
        if not descr:
            descr = op_class.__doc__
            if not descr:
                descr = ""

        return "# %s\n%s" % (descr, as_string) 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def set_cameras(self, current_scene, new_scene, wall):  
        camera_data = bpy.data.cameras.new(new_scene.name)
        camera_obj = bpy.data.objects.new(name=camera_data.name + " Camera", 
                                          object_data=camera_data)
         
        current_scene.objects.link(camera_obj)    
        current_scene.camera = camera_obj
        camera_obj.data.type = 'ORTHO'
        camera_obj.rotation_euler.x = math.radians(90.0) 
        camera_obj.rotation_euler.z = wall.obj_bp.rotation_euler.z    
        camera_obj.location = wall.obj_bp.location       
        
        bpy.ops.object.select_all(action='DESELECT')
        wall.get_wall_mesh().select = True
        bpy.ops.view3d.camera_to_view_selected()     
        
        current_scene.camera = None
        current_scene.objects.unlink(camera_obj)
        new_scene.objects.link(camera_obj)
        new_scene.camera = camera_obj
        new_scene.render.resolution_y = 1280
        bpy.data.cameras[new_scene.name].ortho_scale += self.padding 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def clear_and_collect_data(self,context):
        for product in self.products:
            self.products.remove(product)
        
        for wall in self.walls:
            self.walls.remove(wall)

        bpy.ops.fd_material.get_materials()
        for scene in bpy.data.scenes:
            if not scene.mv.plan_view_scene and not scene.mv.elevation_scene:
                for obj in scene.objects:
                    if not obj.mv.dont_export:
                        if obj.mv.type == 'BPWALL':
                            self.walls.append(obj)
                        if obj.mv.type == 'BPASSEMBLY':
                            if obj.mv.type_group == 'PRODUCT':
                                self.products.append(obj)
                        if obj.cabinetlib.type_mesh == 'BUYOUT' and obj.parent is None:
                            self.buyout_products.append(obj) 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def invoke(self, context, event):
        wm = context.window_manager

        data_path = self.data_path
        prop_string = self.prop_string

        # same as eval("bpy.ops." + data_path)
        op_mod_str, ob_id_str = data_path.split(".", 1)
        op = getattr(getattr(bpy.ops, op_mod_str), ob_id_str)
        del op_mod_str, ob_id_str

        try:
            op_rna = op.get_rna()
        except KeyError:
            self.report({'ERROR'}, "Operator not found: bpy.ops.%s" % data_path)
            return {'CANCELLED'}

        def draw_cb(self, context):
            layout = self.layout
            pie = layout.menu_pie()
            pie.operator_enum(data_path, prop_string)

        wm.popup_menu_pie(draw_func=draw_cb, title=op_rna.bl_rna.name, event=event)

        return {'FINISHED'} 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def execute(self, context):
        op_strings = []
        tot = 0
        for op_module_name in dir(bpy.ops):
            op_module = getattr(bpy.ops, op_module_name)
            for op_submodule_name in dir(op_module):
                op = getattr(op_module, op_submodule_name)
                text = repr(op)
                if text.split("\n")[-1].startswith("bpy.ops."):
                    op_strings.append(text)
                    tot += 1

            op_strings.append('')

        textblock = bpy.data.texts.new("OperatorList.txt")
        textblock.write('# %d Operators\n\n' % tot)
        textblock.write('\n'.join(op_strings))
        self.report({'INFO'}, "See OperatorList.txt textblock")
        return {'FINISHED'}


# -----------------------------------------------------------------------------
# Add-on Operators 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def execute(self, context):
        from os.path import basename, splitext
        filepath = self.filepath

        # change the menu title to the most recently chosen option
        preset_class = getattr(bpy.types, self.menu_idname)
        preset_class.bl_label = bpy.path.display_name(basename(filepath))

        ext = splitext(filepath)[1].lower()

        # execute the preset using script.python_file_run
        if ext == ".py":
            bpy.ops.script.python_file_run(filepath=filepath)
        elif ext == ".xml":
            import rna_xml
            rna_xml.xml_file_run(context,
                                 filepath,
                                 preset_class.preset_xml_map)
        else:
            self.report({'ERROR'}, "unknown filetype: %r" % ext)
            return {'CANCELLED'}

        return {'FINISHED'} 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def importMesh_PointSet(geom, ancestry, _):
    # VRML not x3d
    coord = geom.getChildBySpec('Coordinate')  # works for x3d and vrml
    if coord:
        points = coord.getFieldAsArray('point', 3, ancestry)
    else:
        points = []

    # vcolor = geom.getChildByName('color')
    # blender dosnt have per vertex color

    bpymesh = bpy.data.meshes.new("PointSet")
    bpymesh.vertices.add(len(points))
    bpymesh.vertices.foreach_set("co", [a for v in points for a in v])

    # No need to validate
    bpymesh.update()
    return bpymesh


# -----------------------------------------------------------------------------------
# Primitives
# SA: they used to use bpy.ops for primitive creation. That was
# unbelievably slow on complex scenes. I rewrote to generate meshes
# by hand. 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def execute(self, context):
        import addon_utils

        module_name = self.module

        modules = addon_utils.modules(refresh=False)
        mod = addon_utils.addons_fake_modules.get(module_name)
        if mod is not None:
            info = addon_utils.module_bl_info(mod)
            info["show_expanded"] = True

            bpy.context.user_preferences.active_section = 'ADDONS'
            context.window_manager.addon_filter = 'All'
            context.window_manager.addon_search = info["name"]
            bpy.ops.screen.userpref_show('INVOKE_DEFAULT')

        return {'FINISHED'}


# Note: shares some logic with WM_OT_addon_install
# but not enough to de-duplicate. Fixes here may apply to both. 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def updater_run_success_popup_handler(scene):
	global ran_update_sucess_popup
	ran_update_sucess_popup = True

	# in case of error importing updater
	if updater.invalidupdater == True:
		return

	try:
		bpy.app.handlers.scene_update_post.remove(
				updater_run_success_popup_handler)
	except:
		pass

	atr = addon_updater_updated_successful.bl_idname.split(".")
	getattr(getattr(bpy.ops, atr[0]),atr[1])('INVOKE_DEFAULT') 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def still_registered(self, oplist):
    if getattr(still_registered, 'is_broken', False): return False
    def is_registered():
        cur = bpy.ops
        for n in oplist:
            if not hasattr(cur, n): return False
            cur = getattr(cur, n)
        try:    StructRNA.path_resolve(self, "properties")
        except:
            print('no properties!')
            return False
        return True
    if is_registered(): return True
    still_registered.is_broken = True
    print('bpy.ops.%s is no longer registered!' % '.'.join(oplist))
    return False 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def iter_exporters():
    #categories = dir(bpy.ops)
    categories = ["export_anim", "export_mesh", "export_scene"]
    for category_name in categories:
        op_category = getattr(bpy.ops, category_name)
        
        for name in dir(op_category):
            total_name = category_name + "." + name
            
            if total_name == ExportSelected.bl_idname:
                continue
            
            if "export" in total_name:
                op = getattr(op_category, name)
                
                yield total_name, op 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def execute(self, context):
        with ToggleObjectMode(undo=None):
            self.clear_world(context)
            
            if self.format:
                props = {}
                for key in CurrentFormatProperties._keys():
                    props[key] = getattr(self.format_props, key)
                props["filepath"] = self.filepath
                
                op = get_op(self.format)
                
                op(**props)
            else:
                bpy.ops.wm.save_as_mainfile(
                    filepath=self.filepath,
                    copy=True,
                )
            
            bpy.ops.ed.undo()
            bpy.ops.ed.undo_push(message="Export Selected")
        
        return {'FINISHED'} 

# 需要导入模块: import bpy [as 别名]
# 或者: from bpy import ops [as 别名]
def post_update_callback():

	# in case of error importing updater
	if updater.invalidupdater == True:
		return

	# this is the same code as in conditional at the end of the register function
	# ie if "auto_reload_post_update" == True, comment out this code
	if updater.verbose: print("{} updater: Running post update callback".format(updater.addon))
	#bpy.app.handlers.scene_update_post.append(updater_run_success_popup_handler)

	atr = addon_updater_updated_successful.bl_idname.split(".")
	getattr(getattr(bpy.ops, atr[0]),atr[1])('INVOKE_DEFAULT')
	global ran_update_sucess_popup
	ran_update_sucess_popup = True
	return


# function for asynchronous background check, which *could* be called on register