diff options
| author | Campbell Barton <ideasman42@gmail.com> | 2010-08-20 10:09:58 +0400 |
|---|---|---|
| committer | Campbell Barton <ideasman42@gmail.com> | 2010-08-20 10:09:58 +0400 |
| commit | 4f5f868a523430aa41de8bd63f888878aaf63002 (patch) | |
| tree | 2646d7467382bc8d2e5addc361b91f6eec7246e1 /release/scripts | |
| parent | 4afe81c7260905bcb2682d9cbac016a446310955 (diff) | |
rna data path names which are more likely to break animations.
Added an operator "Update Animation Data",
access from the search menu to update drivers and fcurves.
Diffstat (limited to 'release/scripts')
51 files changed, 1246 insertions, 648 deletions
diff --git a/release/scripts/io/export_fbx.py b/release/scripts/io/export_fbx.py index 54b63ccfa2f..60e9e90e11b 100644 --- a/release/scripts/io/export_fbx.py +++ b/release/scripts/io/export_fbx.py @@ -1082,7 +1082,7 @@ def write(filename, batch_objects = None, \ else: do_shadow = 0 - if light.only_shadow or (not light.diffuse and not light.specular): + if light.use_only_shadow or (not light.diffuse and not light.specular): # if mode & Blender.Lamp.Modes.OnlyShadow or (mode & Blender.Lamp.Modes.NoDiffuse and mode & Blender.Lamp.Modes.NoSpecular): do_light = 0 else: @@ -1190,7 +1190,7 @@ def write(filename, batch_objects = None, \ # mat_spec = mat.spec/2.0 mat_alpha = mat.alpha mat_emit = mat.emit - mat_shadeless = mat.shadeless + mat_shadeless = mat.use_shadeless # mat_shadeless = mat.mode & Blender.Material.Modes.SHADELESS if mat_shadeless: mat_shader = 'Lambert' @@ -1327,9 +1327,9 @@ def write(filename, batch_objects = None, \ Property: "CurrentMappingType", "enum", "",0 Property: "UVSwap", "bool", "",0''') - file.write('\n\t\t\tProperty: "WrapModeU", "enum", "",%i' % tex.clamp_x) + file.write('\n\t\t\tProperty: "WrapModeU", "enum", "",%i' % tex.use_clamp_x) # file.write('\n\t\t\tProperty: "WrapModeU", "enum", "",%i' % tex.clampX) - file.write('\n\t\t\tProperty: "WrapModeV", "enum", "",%i' % tex.clamp_y) + file.write('\n\t\t\tProperty: "WrapModeV", "enum", "",%i' % tex.use_clamp_y) # file.write('\n\t\t\tProperty: "WrapModeV", "enum", "",%i' % tex.clampY) file.write(''' @@ -1605,11 +1605,11 @@ def write(filename, batch_objects = None, \ i=-1 for ed in me.edges: if i==-1: - file.write('%i' % (ed.use_sharp)); i=0 + file.write('%i' % (ed.use_edge_sharp)); i=0 else: if i==54: file.write('\n '); i=0 - file.write(',%i' % (ed.use_sharp)) + file.write(',%i' % (ed.use_edge_sharp)) i+=1 file.write('\n\t\t}') diff --git a/release/scripts/io/export_obj.py b/release/scripts/io/export_obj.py index 319d459e4c2..53c4a324ed1 100644 --- a/release/scripts/io/export_obj.py +++ b/release/scripts/io/export_obj.py @@ -93,7 +93,7 @@ def write_mtl(scene, filepath, copy_images, mtl_dict): file.write('d %.6f\n' % mat.alpha) # Alpha (obj uses 'd' for dissolve) # 0 to disable lighting, 1 for ambient & diffuse only (specular color set to black), 2 for full lighting. - if mat.shadeless: + if mat.use_shadeless: file.write('illum 0\n') # ignore lighting elif mat.specular_intensity == 0: file.write('illum 1\n') # no specular. diff --git a/release/scripts/io/export_x3d.py b/release/scripts/io/export_x3d.py index 3b396011378..aafb7c922a1 100644 --- a/release/scripts/io/export_x3d.py +++ b/release/scripts/io/export_x3d.py @@ -470,7 +470,7 @@ class x3d_class: if len(maters) >= 1: mat=maters[0] # matFlags = mat.getMode() - if not mat.face_texture: + if not mat.use_face_texture: # if not matFlags & Blender.Material.Modes['TEXFACE']: self.writeMaterial(mat, self.cleanStr(mat.name,''), world) # self.writeMaterial(mat, self.cleanStr(maters[0].name,''), world) @@ -520,7 +520,7 @@ class x3d_class: is_smooth = True break if is_smooth == True: - creaseAngle=(mesh.autosmooth_angle)*(math.pi/180.0) + creaseAngle=(mesh.auto_smooth_angle)*(math.pi/180.0) # creaseAngle=(mesh.degr)*(math.pi/180.0) self.file.write("creaseAngle=\"%s\" " % (round(creaseAngle,self.cp))) @@ -699,7 +699,7 @@ class x3d_class: # specB = (mat.specCol[2]+0.001)/(1.25/(mat.spec+0.001)) transp = 1-mat.alpha # matFlags = mat.getMode() - if mat.shadeless: + if mat.use_shadeless: # if matFlags & Blender.Material.Modes['SHADELESS']: ambient = 1 shine = 1 @@ -731,7 +731,7 @@ class x3d_class: def writeBackground(self, world, alltextures): if world: worldname = world.name else: return - blending = (world.blend_sky, world.paper_sky, world.real_sky) + blending = (world.blend_sky, world.paper_sky, world.use_sky_real) # blending = world.getSkytype() grd = world.horizon_color # grd = world.getHor() diff --git a/release/scripts/io/import_scene_obj.py b/release/scripts/io/import_scene_obj.py index cb56fb62bdc..2b5a3f06832 100644 --- a/release/scripts/io/import_scene_obj.py +++ b/release/scripts/io/import_scene_obj.py @@ -379,7 +379,7 @@ def create_materials(filepath, material_libs, unique_materials, unique_material_ texture.mipmap = True texture.interpolation = True texture.use_alpha = True - blender_material.transparency = True + blender_material.use_transparency = True blender_material.alpha = 0.0 else: blender_material.add_texture(texture, 'UV', 'COLOR') @@ -806,7 +806,7 @@ def create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc, v # for sharp_edge in sharp_edges.keys(): # for ed in me.edges: # if edges_match(sharp_edge, ed.vertices): -# ed.use_sharp = True +# ed.use_edge_sharp = True # if unique_smooth_groups and sharp_edges: # SHARP= Mesh.EdgeFlags.SHARP diff --git a/release/scripts/io/netrender/client.py b/release/scripts/io/netrender/client.py index 42fea338891..6f0f6460ae1 100644 --- a/release/scripts/io/netrender/client.py +++ b/release/scripts/io/netrender/client.py @@ -146,7 +146,7 @@ def clientSendJob(conn, scene, anim = False): addPointCache(job, object, modifier.point_cache, default_path) elif modifier.type == "SMOKE" and modifier.smoke_type == "TYPE_DOMAIN": addPointCache(job, object, modifier.domain_settings.point_cache_low, default_path) - if modifier.domain_settings.highres: + if modifier.domain_settings.use_high_resolution: addPointCache(job, object, modifier.domain_settings.point_cache_high, default_path) elif modifier.type == "MULTIRES" and modifier.is_external: file_path = bpy.path.abspath(modifier.filepath) @@ -210,7 +210,7 @@ class NetworkRenderEngine(bpy.types.RenderEngine): address = "" if netsettings.server_address == "[default]" else netsettings.server_address - master.runMaster((address, netsettings.server_port), netsettings.master_broadcast, netsettings.master_clear, netsettings.path, self.update_stats, self.test_break) + master.runMaster((address, netsettings.server_port), netsettings.master_broadcast, netsettings.use_master_clear, netsettings.path, self.update_stats, self.test_break) def render_slave(self, scene): diff --git a/release/scripts/io/netrender/repath.py b/release/scripts/io/netrender/repath.py index e7fcad83682..3ac9636b628 100644 --- a/release/scripts/io/netrender/repath.py +++ b/release/scripts/io/netrender/repath.py @@ -121,7 +121,7 @@ def process(paths): processPointCache(modifier.point_cache) elif modifier.type == "SMOKE" and modifier.smoke_type == "TYPE_DOMAIN": processPointCache(modifier.domain_settings.point_cache_low) - if modifier.domain_settings.highres: + if modifier.domain_settings.use_high_resolution: processPointCache(modifier.domain_settings.point_cache_high) elif modifier.type == "MULTIRES" and modifier.is_external: file_path = bpy.path.abspath(modifier.filepath) diff --git a/release/scripts/io/netrender/slave.py b/release/scripts/io/netrender/slave.py index 7528ea1053a..a44309d5634 100644 --- a/release/scripts/io/netrender/slave.py +++ b/release/scripts/io/netrender/slave.py @@ -201,7 +201,7 @@ def render_slave(engine, netsettings, threads): response.read() # Also output on console - if netsettings.slave_outputlog: + if netsettings.use_slave_output_log: print(str(stdout, encoding='utf8'), end="") stdout = bytes() @@ -225,7 +225,7 @@ def render_slave(engine, netsettings, threads): # flush the rest of the logs if stdout: # Also output on console - if netsettings.slave_thumb: + if netsettings.use_slave_thumb: print(str(stdout, encoding='utf8'), end="") # (only need to update on one frame, they are linked @@ -254,7 +254,7 @@ def render_slave(engine, netsettings, threads): filename = os.path.join(JOB_PREFIX, "%06d.exr" % frame.number) # thumbnail first - if netsettings.slave_thumb: + if netsettings.use_slave_thumb: thumbname = thumbnail(filename) f = open(thumbname, 'rb') @@ -294,7 +294,7 @@ def render_slave(engine, netsettings, threads): conn.close() - if netsettings.slave_clear: + if netsettings.use_slave_clear: clearSlave(NODE_PREFIX) if __name__ == "__main__": diff --git a/release/scripts/io/netrender/ui.py b/release/scripts/io/netrender/ui.py index cacc35ad48d..c2d943f63f8 100644 --- a/release/scripts/io/netrender/ui.py +++ b/release/scripts/io/netrender/ui.py @@ -147,9 +147,9 @@ class RENDER_PT_network_slave_settings(bpy.types.Panel, RenderButtonsPanel): rd = scene.render netsettings = scene.network_render - layout.prop(netsettings, "slave_clear") - layout.prop(netsettings, "slave_thumb") - layout.prop(netsettings, "slave_outputlog") + layout.prop(netsettings, "use_slave_clear") + layout.prop(netsettings, "use_slave_thumb") + layout.prop(netsettings, "use_slave_output_log") layout.label(text="Threads:") layout.prop(rd, "threads_mode", expand=True) sub = layout.column() @@ -171,8 +171,8 @@ class RENDER_PT_network_master_settings(bpy.types.Panel, RenderButtonsPanel): scene = context.scene netsettings = scene.network_render - layout.prop(netsettings, "master_broadcast") - layout.prop(netsettings, "master_clear") + layout.prop(netsettings, "use_master_broadcast") + layout.prop(netsettings, "use_master_clear") class RENDER_PT_network_job(bpy.types.Panel, RenderButtonsPanel): bl_label = "Job Settings" @@ -354,27 +354,27 @@ def addProperties(): min=1, max=65535) - NetRenderSettings.BoolProperty( attr="master_broadcast", + NetRenderSettings.BoolProperty( attr="use_master_broadcast", name="Broadcast", description="broadcast master server address on local network", default = True) - NetRenderSettings.BoolProperty( attr="slave_clear", + NetRenderSettings.BoolProperty( attr="use_slave_clear", name="Clear on exit", description="delete downloaded files on exit", default = True) - NetRenderSettings.BoolProperty( attr="slave_thumb", + NetRenderSettings.BoolProperty( attr="use_slave_thumb", name="Generate thumbnails", description="Generate thumbnails on slaves instead of master", default = False) - NetRenderSettings.BoolProperty( attr="slave_outputlog", + NetRenderSettings.BoolProperty( attr="use_slave_output_log", name="Output render log on console", description="Output render text log to console as well as sending it to the master", default = True) - NetRenderSettings.BoolProperty( attr="master_clear", + NetRenderSettings.BoolProperty( attr="use_master_clear", name="Clear on exit", description="delete saved files on exit", default = False) diff --git a/release/scripts/modules/animsys_refactor.py b/release/scripts/modules/animsys_refactor.py index 3959904e0c5..8cc91873b0e 100644 --- a/release/scripts/modules/animsys_refactor.py +++ b/release/scripts/modules/animsys_refactor.py @@ -42,7 +42,7 @@ class DataPathBuilder(object): str_value = '["%s"]' % key return DataPathBuilder(self.data_path + (str_value, )) - def resolve(self, real_base): + def resolve(self, real_base, rna_update_from_map=None): """ Return (attribute, value) pairs. """ pairs = [] @@ -50,10 +50,24 @@ class DataPathBuilder(object): for item in self.data_path: if base is not Ellipsis: try: + # this only works when running with an old blender + # where the old path will resolve base = eval("base" + item) except: - print("Failed to resolve data path:", self.data_path) - base = Ellipsis + base_new = Ellipsis + # guess the new name + if item.startswith("."): + for item_new in rna_update_from_map.get(item[1:], ()): + try: + print("base." + item_new) + base_new = eval("base." + item_new) + break # found, dont keep looking + except: + pass + + if base_new is Ellipsis: + print("Failed to resolve data path:", self.data_path) + base = base_new pairs.append((item, base)) return pairs @@ -96,14 +110,14 @@ def classes_recursive(base_type, clss=None): return clss -def find_path_new(id_data, data_path, rna_update_dict): +def find_path_new(id_data, data_path, rna_update_dict, rna_update_from_map): # ignore ID props for now if data_path.startswith("["): return data_path # recursive path fixing, likely will be one in most cases. data_path_builder = eval("DataPathBuilder(tuple())." + data_path) - data_resolve = data_path_builder.resolve(id_data) + data_resolve = data_path_builder.resolve(id_data, rna_update_from_map) path_new = [pair[0] for pair in data_resolve] @@ -136,6 +150,10 @@ def update_data_paths(rna_update): rna_update_dict = {} for ren_class, ren_from, ren_to in rna_update: rna_update_dict.setdefault(ren_class, {})[ren_from] = ren_to + + rna_update_from_map = {} + for ren_class, ren_from, ren_to in rna_update: + rna_update_from_map.setdefault(ren_from, []).append(ren_to) for id_data in id_iter(): anim_data = getattr(id_data, "animation_data", None) @@ -150,7 +168,7 @@ def update_data_paths(rna_update): data_path = tar.data_path if id_data_other and data_path: - data_path_new = find_path_new(id_data_other, data_path, rna_update_dict) + data_path_new = find_path_new(id_data_other, data_path, rna_update_dict, rna_update_from_map) # print(data_path_new) if data_path_new != data_path: if not IS_TESTING: @@ -162,22 +180,22 @@ def update_data_paths(rna_update): for action in anim_data_actions(anim_data): for fcu in action.fcurves: data_path = fcu.data_path - data_path_new = find_path_new(id_data, data_path, rna_update_dict) + data_path_new = find_path_new(id_data, data_path, rna_update_dict, rna_update_from_map) # print(data_path_new) if data_path_new != data_path: if not IS_TESTING: fcu.data_path = data_path_new print("fcurve (%s): %s -> %s" % (id_data.name, data_path, data_path_new)) - + if __name__ == "__main__": # Example, should be called externally # (class, from, to) replace_ls = [ - ('AnimVizMotionPaths', 'after_current', 'frame_after'), - ('AnimVizMotionPaths', 'before_current', 'frame_before'), - ('AnimVizOnionSkinning', 'after_current', 'frame_after'), + ('AnimVizMotionPaths', 'frame_after', 'frame_after'), + ('AnimVizMotionPaths', 'frame_before', 'frame_before'), + ('AnimVizOnionSkinning', 'frame_after', 'frame_after'), ] update_data_paths(replace_ls) diff --git a/release/scripts/modules/bpy/__init__.py b/release/scripts/modules/bpy/__init__.py index 3431054413e..5b7d5a76336 100644 --- a/release/scripts/modules/bpy/__init__.py +++ b/release/scripts/modules/bpy/__init__.py @@ -48,7 +48,7 @@ def _main(): import pydoc pydoc.getpager = lambda: pydoc.plainpager pydoc.Helper.getline = lambda self, prompt: None - pydoc.TextDoc.bold = lambda self, text: text + pydoc.TextDoc.use_bold = lambda self, text: text # if "-d" in sys.argv: # Enable this to measure startup speed diff --git a/release/scripts/modules/rigify/__init__.py b/release/scripts/modules/rigify/__init__.py index 2eed5bbb74e..98d9bb235a2 100644 --- a/release/scripts/modules/rigify/__init__.py +++ b/release/scripts/modules/rigify/__init__.py @@ -548,7 +548,7 @@ def generate_test_all(context, GRAPH=False): i = 0 for obj, obj_new in new_objects: - obj.data.drawtype = 'STICK' + obj.data.draw_type = 'STICK' obj.location[1] += i obj_new.location[1] += i obj_new.select = False diff --git a/release/scripts/modules/rigify/arm_biped.py b/release/scripts/modules/rigify/arm_biped.py index ec36210e61d..ac878c3c076 100644 --- a/release/scripts/modules/rigify/arm_biped.py +++ b/release/scripts/modules/rigify/arm_biped.py @@ -161,7 +161,7 @@ def ik(obj, definitions, base_names, options): con.use_stretch = True con.use_target = True con.use_rotation = False - con.chain_length = 2 + con.chain_count = 2 con.pole_angle = -pi/2 # last step setup layers diff --git a/release/scripts/modules/rigify/eye_balls.py b/release/scripts/modules/rigify/eye_balls.py index b1889d7c36f..f65d56b9f2b 100644 --- a/release/scripts/modules/rigify/eye_balls.py +++ b/release/scripts/modules/rigify/eye_balls.py @@ -328,8 +328,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_X' con.frame_start = -20 con.frame_end = 20 - con.minimum = 0.0 - con.maximum = 2.0 + con.min = 0.0 + con.max = 2.0 con.target_space = 'LOCAL' diff --git a/release/scripts/modules/rigify/eye_lid.py b/release/scripts/modules/rigify/eye_lid.py index 2d7e3e0e61f..3f336e268c6 100644 --- a/release/scripts/modules/rigify/eye_lid.py +++ b/release/scripts/modules/rigify/eye_lid.py @@ -436,8 +436,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance*2 - con.maximum = distance + con.min = -distance*2 + con.max = distance con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -455,8 +455,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance*2 - con.maximum = distance + con.min = -distance*2 + con.max = distance con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -473,8 +473,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance*2 - con.maximum = distance + con.min = -distance*2 + con.max = distance con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -491,8 +491,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance*2 - con.maximum = distance + con.min = -distance*2 + con.max = distance con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -509,8 +509,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance*2 - con.maximum = distance + con.min = -distance*2 + con.max = distance con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -528,8 +528,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance - con.maximum = distance*2 + con.min = -distance + con.max = distance*2 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -546,8 +546,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance - con.maximum = distance*2 + con.min = -distance + con.max = distance*2 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -564,8 +564,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance - con.maximum = distance*2 + con.min = -distance + con.max = distance*2 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -582,8 +582,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance - con.maximum = distance*2 + con.min = -distance + con.max = distance*2 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -600,8 +600,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'LOCATION_Y' con.frame_start = -30 con.frame_end = 30 - con.minimum = -distance - con.maximum = distance*2 + con.min = -distance + con.max = distance*2 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver diff --git a/release/scripts/modules/rigify/leg_biped.py b/release/scripts/modules/rigify/leg_biped.py index 2ea70402d36..d2ddba9f549 100644 --- a/release/scripts/modules/rigify/leg_biped.py +++ b/release/scripts/modules/rigify/leg_biped.py @@ -225,7 +225,7 @@ def ik(obj, bone_definition, base_names, options): # IK con = ik_chain.shin_p.constraints.new('IK') - con.chain_length = 2 + con.chain_count = 2 con.iterations = 500 con.pole_angle = -pi / 2.0 con.use_tail = True @@ -256,11 +256,11 @@ def ik(obj, bone_definition, base_names, options): con.owner_space = 'LOCAL' if con_l is cons[-1][-1]: - con.minimum_x = 0.0 - con.maximum_x = 180.0 # XXX -deg + con.min_x = 0.0 + con.max_x = 180.0 # XXX -deg else: - con.minimum_x = -180.0 # XXX -deg - con.maximum_x = 0.0 + con.min_x = -180.0 # XXX -deg + con.max_x = 0.0 # last step setup layers diff --git a/release/scripts/modules/rigify/leg_quadruped.py b/release/scripts/modules/rigify/leg_quadruped.py index 640e1766ca6..739a6402c4b 100644 --- a/release/scripts/modules/rigify/leg_quadruped.py +++ b/release/scripts/modules/rigify/leg_quadruped.py @@ -268,7 +268,7 @@ def ik(obj, bone_definition, base_names, options): # IK con = ik_chain.shin_p.constraints.new('IK') - con.chain_length = 2 + con.chain_count = 2 con.iterations = 500 con.pole_angle = -90.0 # XXX - in deg! con.use_tail = True diff --git a/release/scripts/modules/rigify/mouth.py b/release/scripts/modules/rigify/mouth.py index fff58861e02..ce232b91e7b 100644 --- a/release/scripts/modules/rigify/mouth.py +++ b/release/scripts/modules/rigify/mouth.py @@ -458,7 +458,7 @@ def control(obj, definitions, base_names, options): con.target = obj con.subtarget = jaw con.head_tail = 1.0 - con.original_length = bb[jopent].length + con.rest_length = bb[jopent].length con.volume = 'NO_VOLUME' # Head lips to jaw lips @@ -545,8 +545,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_Y' con.frame_start = 0 con.frame_end = 60 - con.minimum = 0.0 - con.maximum = 1.0 + con.min = 0.0 + con.max = 1.0 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -563,8 +563,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_Y' con.frame_start = 0 con.frame_end = 60 - con.minimum = 0.0 - con.maximum = 1.0 + con.min = 0.0 + con.max = 1.0 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -581,8 +581,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_Y' con.frame_start = 0 con.frame_end = 60 - con.minimum = 0.0 - con.maximum = 1.0 + con.min = 0.0 + con.max = 1.0 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -599,8 +599,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_Y' con.frame_start = 0 con.frame_end = 60 - con.minimum = 0.0 - con.maximum = 1.0 + con.min = 0.0 + con.max = 1.0 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -617,8 +617,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_Y' con.frame_start = 0 con.frame_end = 60 - con.minimum = 0.0 - con.maximum = 1.0 + con.min = 0.0 + con.max = 1.0 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -635,8 +635,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_Y' con.frame_start = 0 con.frame_end = 60 - con.minimum = 0.0 - con.maximum = 1.0 + con.min = 0.0 + con.max = 1.0 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -653,8 +653,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_Y' con.frame_start = 0 con.frame_end = 60 - con.minimum = 0.0 - con.maximum = 1.0 + con.min = 0.0 + con.max = 1.0 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver @@ -671,8 +671,8 @@ def control(obj, definitions, base_names, options): con.transform_channel = 'SCALE_Y' con.frame_start = 0 con.frame_end = 60 - con.minimum = 0.0 - con.maximum = 1.0 + con.min = 0.0 + con.max = 1.0 con.target_space = 'LOCAL' fcurve = con.driver_add("influence") driver = fcurve.driver diff --git a/release/scripts/modules/rigify/stretch.py b/release/scripts/modules/rigify/stretch.py index 67ceeb39954..6a498e5aa29 100644 --- a/release/scripts/modules/rigify/stretch.py +++ b/release/scripts/modules/rigify/stretch.py @@ -100,7 +100,7 @@ def main(obj, bone_definition, base_names, options): con = pb[bone].constraints.new('STRETCH_TO') con.target = obj con.subtarget = mbone2 - con.original_length = bb[bone].length + con.rest_length = bb[bone].length if preserve_volume: con.volume = 'VOLUME_XZX' else: diff --git a/release/scripts/modules/rigify/stretch_twist.py b/release/scripts/modules/rigify/stretch_twist.py index 5250c5a9735..07ce031967f 100644 --- a/release/scripts/modules/rigify/stretch_twist.py +++ b/release/scripts/modules/rigify/stretch_twist.py @@ -128,7 +128,7 @@ def main(obj, bone_definition, base_names, options): con = pb[bone1].constraints.new('STRETCH_TO') con.target = obj con.subtarget = mid_bone - con.original_length = bb[bone1].length + con.rest_length = bb[bone1].length if preserve_volume: con.volume = 'VOLUME_XZX' else: @@ -142,7 +142,7 @@ def main(obj, bone_definition, base_names, options): con = pb[bone2].constraints.new('STRETCH_TO') con.target = obj con.subtarget = mid_bone - con.original_length = bb[bone2].length + con.rest_length = bb[bone2].length if preserve_volume: con.volume = 'VOLUME_XZX' else: diff --git a/release/scripts/modules/rigify_utils.py b/release/scripts/modules/rigify_utils.py index 39481b37f59..a270af949da 100644 --- a/release/scripts/modules/rigify_utils.py +++ b/release/scripts/modules/rigify_utils.py @@ -67,7 +67,7 @@ def add_stretch_to(obj, from_name, to_name, name): con = stretch_pbone.constraints.new('STRETCH_TO') con.target = obj con.subtarget = to_name - con.original_length = (head - tail).length + con.rest_length = (head - tail).length con.keep_axis = 'PLANE_X' con.volume = 'NO_VOLUME' diff --git a/release/scripts/op/animsys_update.py b/release/scripts/op/animsys_update.py new file mode 100644 index 00000000000..0350eeef6b8 --- /dev/null +++ b/release/scripts/op/animsys_update.py @@ -0,0 +1,580 @@ +# ##### BEGIN GPL LICENSE BLOCK ##### +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +# ##### END GPL LICENSE BLOCK ##### + +# <pep8 compliant> + +data_path_update = [ + ("AnimVizMotionPaths", "after_current", "frame_after"), + ("AnimVizMotionPaths", "before_current", "frame_before"), + ("AnimVizOnionSkinning", "after_current", "frame_after"), + ("AnimVizOnionSkinning", "before_current", "frame_before"), + ("ClothCollisionSettings", "min_distance", "distance_min"), + ("ClothCollisionSettings", "self_min_distance", "self_distance_min"), + ("ClothCollisionSettings", "enable_collision", "use_collision"), + ("ClothCollisionSettings", "enable_self_collision", "use_self_collision"), + ("ClothSettings", "pin_cloth", "use_pin_cloth"), + ("ClothSettings", "stiffness_scaling", "use_stiffness_scale"), + ("CollisionSettings", "random_damping", "damping_random"), + ("CollisionSettings", "random_friction", "friction_random"), + ("CollisionSettings", "inner_thickness", "thickness_inner"), + ("CollisionSettings", "outer_thickness", "thickness_outer"), + ("CollisionSettings", "kill_particles", "use_particle_kill"), + ("Constraint", "proxy_local", "is_proxy_local"), + ("ActionConstraint", "maximum", "max"), + ("ActionConstraint", "minimum", "min"), + ("FollowPathConstraint", "use_fixed_position", "use_fixed_location"), + ("KinematicConstraint", "chain_length", "chain_count"), + ("KinematicConstraint", "pos_lock_x", "lock_location_x"), + ("KinematicConstraint", "pos_lock_y", "lock_location_y"), + ("KinematicConstraint", "pos_lock_z", "lock_location_z"), + ("KinematicConstraint", "rot_lock_x", "lock_rotation_x"), + ("KinematicConstraint", "rot_lock_y", "lock_rotation_y"), + ("KinematicConstraint", "rot_lock_z", "lock_rotation_z"), + ("KinematicConstraint", "axis_reference", "reference_axis"), + ("KinematicConstraint", "use_position", "use_location"), + ("LimitLocationConstraint", "maximum_x", "max_x"), + ("LimitLocationConstraint", "maximum_y", "max_y"), + ("LimitLocationConstraint", "maximum_z", "max_z"), + ("LimitLocationConstraint", "minimum_x", "min_x"), + ("LimitLocationConstraint", "minimum_y", "min_y"), + ("LimitLocationConstraint", "minimum_z", "min_z"), + ("LimitLocationConstraint", "use_maximum_x", "use_max_x"), + ("LimitLocationConstraint", "use_maximum_y", "use_max_y"), + ("LimitLocationConstraint", "use_maximum_z", "use_max_z"), + ("LimitLocationConstraint", "use_minimum_x", "use_min_x"), + ("LimitLocationConstraint", "use_minimum_y", "use_min_y"), + ("LimitLocationConstraint", "use_minimum_z", "use_min_z"), + ("LimitLocationConstraint", "limit_transform", "use_transform_limit"), + ("LimitRotationConstraint", "maximum_x", "max_x"), + ("LimitRotationConstraint", "maximum_y", "max_y"), + ("LimitRotationConstraint", "maximum_z", "max_z"), + ("LimitRotationConstraint", "minimum_x", "min_x"), + ("LimitRotationConstraint", "minimum_y", "min_y"), + ("LimitRotationConstraint", "minimum_z", "min_z"), + ("LimitRotationConstraint", "limit_transform", "use_transform_limit"), + ("LimitScaleConstraint", "maximum_x", "max_x"), + ("LimitScaleConstraint", "maximum_y", "max_y"), + ("LimitScaleConstraint", "maximum_z", "max_z"), + ("LimitScaleConstraint", "minimum_x", "min_x"), + ("LimitScaleConstraint", "minimum_y", "min_y"), + ("LimitScaleConstraint", "minimum_z", "min_z"), + ("LimitScaleConstraint", "use_maximum_x", "use_max_x"), + ("LimitScaleConstraint", "use_maximum_y", "use_max_y"), + ("LimitScaleConstraint", "use_maximum_z", "use_max_z"), + ("LimitScaleConstraint", "use_minimum_x", "use_min_x"), + ("LimitScaleConstraint", "use_minimum_y", "use_min_y"), + ("LimitScaleConstraint", "use_minimum_z", "use_min_z"), + ("LimitScaleConstraint", "limit_transform", "use_transform_limit"), + ("PivotConstraint", "enabled_rotation_range", "rotation_range"), + ("PivotConstraint", "use_relative_position", "use_relative_location"), + ("PythonConstraint", "number_of_targets", "target_count"), + ("SplineIKConstraint", "chain_length", "chain_count"), + ("SplineIKConstraint", "chain_offset", "use_chain_offset"), + ("SplineIKConstraint", "even_divisions", "use_even_divisions"), + ("SplineIKConstraint", "y_stretch", "use_y_stretch"), + ("SplineIKConstraint", "xz_scaling_mode", "xz_scale_mode"), + ("StretchToConstraint", "original_length", "rest_length"), + ("TrackToConstraint", "target_z", "use_target_z"), + ("TransformConstraint", "extrapolate_motion", "use_motion_extrapolate"), + ("FieldSettings", "do_location", "apply_to_location"), + ("FieldSettings", "do_rotation", "apply_to_rotation"), + ("FieldSettings", "maximum_distance", "distance_max"), + ("FieldSettings", "minimum_distance", "distance_min"), + ("FieldSettings", "radial_maximum", "radial_max"), + ("FieldSettings", "radial_minimum", "radial_min"), + ("FieldSettings", "force_2d", "use_2d_force"), + ("FieldSettings", "do_absorption", "use_absorption"), + ("FieldSettings", "global_coordinates", "use_global_coords"), + ("FieldSettings", "guide_path_add", "use_guide_path_add"), + ("FieldSettings", "multiple_springs", "use_multiple_springs"), + ("FieldSettings", "use_coordinates", "use_object_coords"), + ("FieldSettings", "root_coordinates", "use_root_coords"), + ("ControlFluidSettings", "reverse_frames", "use_reverse_frames"), + ("DomainFluidSettings", "real_world_size", "simulation_scale"), + ("DomainFluidSettings", "surface_smoothing", "surface_smooth"), + ("DomainFluidSettings", "reverse_frames", "use_reverse_frames"), + ("DomainFluidSettings", "generate_speed_vectors", "use_speed_vectors"), + ("DomainFluidSettings", "override_time", "use_time_override"), + ("FluidFluidSettings", "export_animated_mesh", "use_animated_mesh"), + ("InflowFluidSettings", "export_animated_mesh", "use_animated_mesh"), + ("InflowFluidSettings", "local_coordinates", "use_local_coords"), + ("ObstacleFluidSettings", "export_animated_mesh", "use_animated_mesh"), + ("OutflowFluidSettings", "export_animated_mesh", "use_animated_mesh"), + ("ParticleFluidSettings", "drops", "use_drops"), + ("ParticleFluidSettings", "floats", "use_floats"), + ("GameSoftBodySettings", "linstiff", "linear_stiffness"), + ("GameSoftBodySettings", "position_iterations", "location_iterations"), + ("GameSoftBodySettings", "bending_const", "use_bending_constraints"), + ("GameSoftBodySettings", "cluster_rigid_to_softbody", "use_cluster_rigid_to_softbody"), + ("GameSoftBodySettings", "cluster_soft_to_softbody", "use_cluster_soft_to_softbody"), + ("GameSoftBodySettings", "shape_match", "use_shape_match"), + ("NetRenderSettings", "master_broadcast", "use_master_broadcast"), + ("NetRenderSettings", "master_clear", "use_master_clear"), + ("NetRenderSettings", "slave_clear", "use_slave_clear"), + ("NetRenderSettings", "slave_outputlog", "use_slave_output_log"), + ("NetRenderSettings", "slave_thumb", "use_slave_thumb"), + ("PoseTemplateSettings", "generate_def_rig", "use_generate_deform_rig"), + ("Armature", "drawtype", "draw_type"), + ("Armature", "layer_protection", "layers_protected"), + ("Armature", "auto_ik", "use_auto_ik"), + ("Armature", "delay_deform", "use_deform_delay"), + ("Armature", "deform_envelope", "use_deform_envelopes"), + ("Armature", "deform_quaternion", "use_deform_preserve_volume"), + ("Armature", "deform_vertexgroups", "use_deform_vertex_groups"), + ("Armature", "x_axis_mirror", "use_mirror_x"), + ("Curve", "width", "offset"), + ("Image", "animation_speed", "fps"), + ("Image", "animation_end", "frame_end"), + ("Image", "animation_start", "frame_start"), + ("Image", "animated", "use_animation"), + ("Image", "clamp_x", "use_clamp_x"), + ("Image", "clamp_y", "use_clamp_y"), + ("Image", "premultiply", "use_premultiply"), + ("AreaLamp", "shadow_ray_sampling_method", "shadow_ray_sample_method"), + ("AreaLamp", "only_shadow", "use_only_shadow"), + ("AreaLamp", "shadow_layer", "use_shadow_layer"), + ("AreaLamp", "umbra", "use_umbra"), + ("PointLamp", "shadow_ray_sampling_method", "shadow_ray_sample_method"), + ("PointLamp", "only_shadow", "use_only_shadow"), + ("PointLamp", "shadow_layer", "use_shadow_layer"), + ("PointLamp", "sphere", "use_sphere"), + ("SpotLamp", "shadow_ray_sampling_method", "shadow_ray_sample_method"), + ("SpotLamp", "auto_clip_end", "use_auto_clip_end"), + ("SpotLamp", "auto_clip_start", "use_auto_clip_start"), + ("SpotLamp", "only_shadow", "use_only_shadow"), + ("SpotLamp", "shadow_layer", "use_shadow_layer"), + ("SpotLamp", "sphere", "use_sphere"), + ("SunLamp", "only_shadow", "use_only_shadow"), + ("SunLamp", "shadow_layer", "use_shadow_layer"), + ("Material", "z_offset", "offset_z"), + ("Material", "shadow_casting_alpha", "shadow_cast_alpha"), + ("Material", "cast_approximate", "use_cast_approximate"), + ("Material", "cast_buffer_shadows", "use_cast_buffer_shadows"), + ("Material", "cast_shadows_only", "use_cast_shadows_only"), + ("Material", "face_texture", "use_face_texture"), + ("Material", "face_texture_alpha", "use_face_texture_alpha"), + ("Material", "full_oversampling", "use_full_oversampling"), + ("Material", "light_group_exclusive", "use_light_group_exclusive"), + ("Material", "object_color", "use_object_color"), + ("Material", "only_shadow", "use_only_shadow"), + ("Material", "ray_shadow_bias", "use_ray_shadow_bias"), + ("Material", "traceable", "use_raytrace"), + ("Material", "shadeless", "use_shadeless"), + ("Material", "tangent_shading", "use_tangent_shading"), + ("Material", "transparency", "use_transparency"), + ("Material", "receive_transparent_shadows", "use_transparent_shadows"), + ("Material", "vertex_color_light", "use_vertex_color_light"), + ("Material", "vertex_color_paint", "use_vertex_color_paint"), + ("Mesh", "autosmooth_angle", "auto_smooth_angle"), + ("Mesh", "autosmooth", "use_auto_smooth"), + ("Object", "max_draw_type", "draw_type"), + ("Object", "use_dupli_verts_rotation", "use_dupli_vertices_rotation"), + ("Object", "shape_key_edit_mode", "use_shape_key_edit_mode"), + ("Object", "slow_parent", "use_slow_parent"), + ("Object", "time_offset_add_parent", "use_time_offset_add_parent"), + ("Object", "time_offset_edit", "use_time_offset_edit"), + ("Object", "time_offset_parent", "use_time_offset_parent"), + ("Object", "time_offset_particle", "use_time_offset_particle"), + ("ParticleSettings", "adaptive_pix", "adaptive_pixel"), + ("ParticleSettings", "child_effector", "apply_effector_to_children"), + ("ParticleSettings", "child_guide", "apply_guide_to_children"), + ("ParticleSettings", "billboard_split_offset", "billboard_offset_split"), + ("ParticleSettings", "billboard_random_tilt", "billboard_tilt_random"), + ("ParticleSettings", "child_length_thres", "child_length_threshold"), + ("ParticleSettings", "child_random_size", "child_size_random"), + ("ParticleSettings", "clumppow", "clump_shape"), + ("ParticleSettings", "damp_factor", "damping"), + ("ParticleSettings", "draw_as", "draw_method"), + ("ParticleSettings", "random_factor", "factor_random"), + ("ParticleSettings", "grid_invert", "invert_grid"), + ("ParticleSettings", "random_length", "length_random"), + ("ParticleSettings", "random_lifetime", "lifetime_random"), + ("ParticleSettings", "billboard_lock", "lock_billboard"), + ("ParticleSettings", "boids_2d", "lock_boids_to_surface"), + ("ParticleSettings", "object_aligned_factor", "object_align_factor"), + ("ParticleSettings", "random_phase_factor", "phase_factor_random"), + ("ParticleSettings", "ren_as", "render_type"), + ("ParticleSettings", "rendered_child_nbr", "rendered_child_count"), + ("ParticleSettings", "random_rotation_factor", "rotation_factor_random"), + ("ParticleSettings", "rough1", "roughness_1"), + ("ParticleSettings", "rough1_size", "roughness_1_size"), + ("ParticleSettings", "rough2", "roughness_2"), + ("ParticleSettings", "rough2_size", "roughness_2_size"), + ("ParticleSettings", "rough2_thres", "roughness_2_threshold"), + ("ParticleSettings", "rough_end_shape", "roughness_end_shape"), + ("ParticleSettings", "rough_endpoint", "roughness_endpoint"), + ("ParticleSettings", "random_size", "size_random"), + ("ParticleSettings", "abs_path_time", "use_absolute_path_time"), + ("ParticleSettings", "animate_branching", "use_animate_branching"), + ("ParticleSettings", "branching", "use_branching"), + ("ParticleSettings", "died", "use_dead"), + ("ParticleSettings", "die_on_collision", "use_die_on_collision"), + ("ParticleSettings", "rotation_dynamic", "use_dynamic_rotation"), + ("ParticleSettings", "even_distribution", "use_even_distribution"), + ("ParticleSettings", "rand_group", "use_group_pick_random"), + ("ParticleSettings", "hair_bspline", "use_hair_bspline"), + ("ParticleSettings", "sizemass", "use_multiply_size_mass"), + ("ParticleSettings", "react_multiple", "use_react_multiple"), + ("ParticleSettings", "react_start_end", "use_react_start_end"), + ("ParticleSettings", "render_adaptive", "use_render_adaptive"), + ("ParticleSettings", "self_effect", "use_self_effect"), + ("ParticleSettings", "enable_simplify", "use_simplify"), + ("ParticleSettings", "size_deflect", "use_size_deflect"), + ("ParticleSettings", "render_strand", "use_strand_primitive"), + ("ParticleSettings", "symmetric_branching", "use_symmetric_branching"), + ("ParticleSettings", "velocity_length", "use_velocity_length"), + ("ParticleSettings", "whole_group", "use_whole_group"), + ("CloudsTexture", "noise_size", "noise_scale"), + ("DistortedNoiseTexture", "noise_size", "noise_scale"), + ("EnvironmentMapTexture", "filter_size_minimum", "use_filter_size_min"), + ("EnvironmentMapTexture", "mipmap_gauss", "use_mipmap_gauss"), + ("ImageTexture", "calculate_alpha", "use_calculate_alpha"), + ("ImageTexture", "checker_even", "use_checker_even"), + ("ImageTexture", "checker_odd", "use_checker_odd"), + ("ImageTexture", "filter_size_minimum", "use_filter_size_min"), + ("ImageTexture", "flip_axis", "use_flip_axis"), + ("ImageTexture", "mipmap_gauss", "use_mipmap_gauss"), + ("ImageTexture", "mirror_x", "use_mirror_x"), + ("ImageTexture", "mirror_y", "use_mirror_y"), + ("ImageTexture", "normal_map", "use_normal_map"), + ("MarbleTexture", "noise_size", "noise_scale"), + ("MarbleTexture", "noisebasis2", "noisebasis_2"), + ("MusgraveTexture", "highest_dimension", "dimension_max"), + ("MusgraveTexture", "noise_size", "noise_scale"), + ("StucciTexture", "noise_size", "noise_scale"), + ("VoronoiTexture", "coloring", "color_mode"), + ("VoronoiTexture", "noise_size", "noise_scale"), + ("WoodTexture", "noise_size", "noise_scale"), + ("WoodTexture", "noisebasis2", "noisebasis_2"), + ("World", "blend_sky", "use_sky_blend"), + ("World", "paper_sky", "use_sky_paper"), + ("World", "real_sky", "use_sky_real"), + ("ImageUser", "auto_refresh", "use_auto_refresh"), + ("MaterialHalo", "flares_sub", "flare_subflare_count"), + ("MaterialHalo", "flare_subsize", "flare_subflare_size"), + ("MaterialHalo", "line_number", "line_count"), + ("MaterialHalo", "rings", "ring_count"), + ("MaterialHalo", "star_tips", "star_tip_count"), + ("MaterialHalo", "xalpha", "use_extreme_alpha"), + ("MaterialHalo", "flare_mode", "use_flare_mode"), + ("MaterialHalo", "vertex_normal", "use_vertex_normal"), + ("MaterialPhysics", "align_to_normal", "use_normal_align"), + ("MaterialStrand", "min_size", "size_min"), + ("MaterialStrand", "blender_units", "use_blender_units"), + ("MaterialStrand", "surface_diffuse", "use_surface_diffuse"), + ("MaterialStrand", "tangent_shading", "use_tangent_shading"), + ("MaterialSubsurfaceScattering", "error_tolerance", "error_threshold"), + ("MaterialVolume", "depth_cutoff", "depth_threshold"), + ("MaterialVolume", "lighting_mode", "light_method"), + ("MaterialVolume", "step_calculation", "step_method"), + ("MaterialVolume", "external_shadows", "use_external_shadows"), + ("MaterialVolume", "light_cache", "use_light_cache"), + ("ArmatureModifier", "multi_modifier", "use_multi_modifier"), + ("ArrayModifier", "constant_offset_displacement", "constant_offset_displace"), + ("ArrayModifier", "merge_distance", "merge_threshold"), + ("ArrayModifier", "relative_offset_displacement", "relative_offset_displace"), + ("ArrayModifier", "constant_offset", "use_constant_offset"), + ("ArrayModifier", "merge_adjacent_vertices", "use_merge_vertices"), + ("ArrayModifier", "merge_end_vertices", "use_merge_vertices_cap"), + ("ArrayModifier", "add_offset_object", "use_object_offset"), + ("ArrayModifier", "relative_offset", "use_relative_offset"), + ("BevelModifier", "only_vertices", "use_only_vertices"), + ("CastModifier", "from_radius", "use_radius_as_size"), + ("DisplaceModifier", "midlevel", "mid_level"), + ("DisplaceModifier", "texture_coordinates", "texture_coords"), + ("EdgeSplitModifier", "use_sharp", "use_edge_sharp"), + ("ExplodeModifier", "split_edges", "use_edge_split"), + ("MirrorModifier", "merge_limit", "merge_threshold"), + ("MirrorModifier", "mirror_u", "use_mirror_u"), + ("MirrorModifier", "mirror_v", "use_mirror_v"), + ("MirrorModifier", "mirror_vertex_groups", "use_mirror_vertex_groups"), + ("ParticleInstanceModifier", "particle_system_number", "particle_system_index"), + ("ParticleInstanceModifier", "keep_shape", "use_preserve_shape"), + ("ShrinkwrapModifier", "cull_back_faces", "use_cull_back_faces"), + ("ShrinkwrapModifier", "cull_front_faces", "use_cull_front_faces"), + ("ShrinkwrapModifier", "keep_above_surface", "use_keep_above_surface"), + ("SimpleDeformModifier", "lock_x_axis", "lock_x"), + ("SimpleDeformModifier", "lock_y_axis", "lock_y"), + ("SmokeModifier", "smoke_type", "type"), + ("SubsurfModifier", "subsurf_uv", "use_subsurf_uv"), + ("UVProjectModifier", "num_projectors", "projector_count"), + ("UVProjectModifier", "override_image", "use_image_override"), + ("WaveModifier", "texture_coordinates", "texture_coords"), + ("WaveModifier", "x_normal", "use_normal_x"), + ("WaveModifier", "y_normal", "use_normal_y"), + ("WaveModifier", "z_normal", "use_normal_z"), + ("NlaStrip", "blending", "blend_type"), + ("NlaStrip", "animated_influence", "use_animated_influence"), + ("NlaStrip", "animated_time", "use_animated_time"), + ("NlaStrip", "animated_time_cyclic", "use_animated_time_cyclic"), + ("NlaStrip", "auto_blending", "use_auto_blend"), + ("CompositorNodeAlphaOver", "convert_premul", "use_premultiply"), + ("CompositorNodeBlur", "sizex", "size_x"), + ("CompositorNodeBlur", "sizey", "size_y"), + ("CompositorNodeChannelMatte", "algorithm", "limit_method"), + ("CompositorNodeChromaMatte", "acceptance", "tolerance"), + ("CompositorNodeColorBalance", "correction_formula", "correction_method"), + ("CompositorNodeColorSpill", "algorithm", "limit_method"), + ("CompositorNodeColorSpill", "unspill", "use_unspill"), + ("CompositorNodeCrop", "x2", "max_x"), + ("CompositorNodeCrop", "y2", "max_y"), + ("CompositorNodeCrop", "x1", "min_x"), + ("CompositorNodeCrop", "y1", "min_y"), + ("CompositorNodeCrop", "crop_size", "use_crop_size"), + ("CompositorNodeDefocus", "max_blur", "blur_max"), + ("CompositorNodeDefocus", "gamma_correction", "use_gamma_correction"), + ("CompositorNodeGlare", "rotate_45", "use_rotate_45"), + ("CompositorNodeImage", "auto_refresh", "use_auto_refresh"), + ("CompositorNodeLensdist", "projector", "use_projector"), + ("CompositorNodeVecBlur", "max_speed", "speed_max"), + ("CompositorNodeVecBlur", "min_speed", "speed_min"), + ("ShaderNodeMapping", "maximum", "max"), + ("ShaderNodeMapping", "minimum", "min"), + ("ShaderNodeMapping", "clamp_maximum", "use_max"), + ("ShaderNodeMapping", "clamp_minimum", "use_min"), + ("VertexPaint", "all_faces", "use_all_faces"), + ("VertexPaint", "spray", "use_spray"), + ("ParticleEdit", "add_keys", "default_key_count"), + ("ParticleEdit", "selection_mode", "select_mode"), + ("ParticleEdit", "auto_velocity", "use_auto_velocity"), + ("ParticleEdit", "add_interpolate", "use_default_interpolate"), + ("ParticleEdit", "emitter_deflect", "use_emitter_deflect"), + ("ParticleEdit", "fade_time", "use_fade_time"), + ("ParticleEdit", "keep_lengths", "use_preserve_length"), + ("ParticleEdit", "keep_root", "use_preserve_root"), + ("ParticleSystem", "vertex_group_clump_negate", "invert_vertex_group_clump"), + ("ParticleSystem", "vertex_group_density_negate", "invert_vertex_group_density"), + ("ParticleSystem", "vertex_group_field_negate", "invert_vertex_group_field"), + ("ParticleSystem", "vertex_group_kink_negate", "invert_vertex_group_kink"), + ("ParticleSystem", "vertex_group_length_negate", "invert_vertex_group_length"), + ("ParticleSystem", "vertex_group_rotation_negate", "invert_vertex_group_rotation"), + ("ParticleSystem", "vertex_group_roughness1_negate", "invert_vertex_group_roughness_1"), + ("ParticleSystem", "vertex_group_roughness2_negate", "invert_vertex_group_roughness_2"), + ("ParticleSystem", "vertex_group_roughness_end_negate", "invert_vertex_group_roughness_end"), + ("ParticleSystem", "vertex_group_size_negate", "invert_vertex_group_size"), + ("ParticleSystem", "vertex_group_tangent_negate", "invert_vertex_group_tangent"), + ("ParticleSystem", "vertex_group_velocity_negate", "invert_vertex_group_velocity"), + ("ParticleSystem", "hair_dynamics", "use_hair_dynamics"), + ("ParticleSystem", "keyed_timing", "use_keyed_timing"), + ("PointDensity", "falloff_softness", "falloff_soft"), + ("PointDensity", "particle_cache", "particle_cache_space"), + ("PointDensity", "turbulence_size", "turbulence_scale"), + ("PointDensity", "turbulence", "use_turbulence"), + ("PointDensity", "vertices_cache", "vertex_cache_space"), + ("PoseBone", "ik_lin_weight", "ik_linear_weight"), + ("PoseBone", "ik_rot_weight", "ik_rotation_weight"), + ("PoseBone", "ik_limit_x", "use_ik_limit_x"), + ("PoseBone", "ik_limit_y", "use_ik_limit_y"), + ("PoseBone", "ik_limit_z", "use_ik_limit_z"), + ("PoseBone", "ik_lin_control", "use_ik_linear_control"), + ("PoseBone", "ik_rot_control", "use_ik_rotation_control"), + ("SPHFluidSettings", "spring_k", "spring_force"), + ("SPHFluidSettings", "stiffness_k", "stiffness"), + ("SPHFluidSettings", "stiffness_knear", "stiffness_near"), + ("SceneGameData", "framing_color", "frame_color"), + ("SceneGameData", "framing_type", "frame_type"), + ("SceneGameData", "eye_separation", "stereo_eye_separation"), + ("SceneGameData", "activity_culling", "use_activity_culling"), + ("SceneGameData", "auto_start", "use_auto_start"), + ("SceneGameData", "glsl_extra_textures", "use_glsl_extra_textures"), + ("SceneGameData", "glsl_lights", "use_glsl_lights"), + ("SceneGameData", "glsl_nodes", "use_glsl_nodes"), + ("SceneGameData", "glsl_ramps", "use_glsl_ramps"), + ("SceneGameData", "glsl_shaders", "use_glsl_shaders"), + ("SceneGameData", "glsl_shadows", "use_glsl_shadows"), + ("Sequence", "blend_opacity", "blend_alpha"), + ("Sequence", "blend_mode", "blend_type"), + ("Sequence", "frame_final_length", "frame_final_duration"), + ("Sequence", "use_effect_default_fade", "use_default_fade"), + ("SequenceColorBalance", "inverse_gain", "invert_gain"), + ("SequenceColorBalance", "inverse_gamma", "invert_gamma"), + ("SequenceColorBalance", "inverse_lift", "invert_lift"), + ("EffectSequence", "multiply_colors", "color_multiply"), + ("EffectSequence", "de_interlace", "use_deinterlace"), + ("EffectSequence", "flip_x", "use_flip_x"), + ("EffectSequence", "flip_y", "use_flip_y"), + ("EffectSequence", "convert_float", "use_float"), + ("EffectSequence", "premultiply", "use_premultiply"), + ("EffectSequence", "proxy_custom_directory", "use_proxy_custom_directory"), + ("EffectSequence", "proxy_custom_file", "use_proxy_custom_file"), + ("EffectSequence", "reverse_frames", "use_reverse_frames"), + ("GlowSequence", "blur_distance", "blur_radius"), + ("GlowSequence", "only_boost", "use_only_boost"), + ("SpeedControlSequence", "curve_compress_y", "use_curve_compress_y"), + ("SpeedControlSequence", "curve_velocity", "use_curve_velocity"), + ("SpeedControlSequence", "frame_blending", "use_frame_blend"), + ("TransformSequence", "uniform_scale", "use_uniform_scale"), + ("ImageSequence", "animation_end_offset", "animation_offset_end"), + ("ImageSequence", "animation_start_offset", "animation_offset_start"), + ("ImageSequence", "multiply_colors", "color_multiply"), + ("ImageSequence", "de_interlace", "use_deinterlace"), + ("ImageSequence", "flip_x", "use_flip_x"), + ("ImageSequence", "flip_y", "use_flip_y"), + ("ImageSequence", "convert_float", "use_float"), + ("ImageSequence", "premultiply", "use_premultiply"), + ("ImageSequence", "proxy_custom_directory", "use_proxy_custom_directory"), + ("ImageSequence", "proxy_custom_file", "use_proxy_custom_file"), + ("ImageSequence", "reverse_frames", "use_reverse_frames"), + ("MetaSequence", "animation_end_offset", "animation_offset_end"), + ("MetaSequence", "animation_start_offset", "animation_offset_start"), + ("MetaSequence", "multiply_colors", "color_multiply"), + ("MetaSequence", "de_interlace", "use_deinterlace"), + ("MetaSequence", "flip_x", "use_flip_x"), + ("MetaSequence", "flip_y", "use_flip_y"), + ("MetaSequence", "convert_float", "use_float"), + ("MetaSequence", "premultiply", "use_premultiply"), + ("MetaSequence", "proxy_custom_directory", "use_proxy_custom_directory"), + ("MetaSequence", "proxy_custom_file", "use_proxy_custom_file"), + ("MetaSequence", "reverse_frames", "use_reverse_frames"), + ("MovieSequence", "animation_end_offset", "animation_offset_end"), + ("MovieSequence", "animation_start_offset", "animation_offset_start"), + ("MovieSequence", "multiply_colors", "color_multiply"), + ("MovieSequence", "de_interlace", "use_deinterlace"), + ("MovieSequence", "flip_x", "use_flip_x"), + ("MovieSequence", "flip_y", "use_flip_y"), + ("MovieSequence", "convert_float", "use_float"), + ("MovieSequence", "premultiply", "use_premultiply"), + ("MovieSequence", "proxy_custom_directory", "use_proxy_custom_directory"), + ("MovieSequence", "proxy_custom_file", "use_proxy_custom_file"), + ("MovieSequence", "reverse_frames", "use_reverse_frames"), + ("MulticamSequence", "animation_end_offset", "animation_offset_end"), + ("MulticamSequence", "animation_start_offset", "animation_offset_start"), + ("MulticamSequence", "multiply_colors", "color_multiply"), + ("MulticamSequence", "de_interlace", "use_deinterlace"), + ("MulticamSequence", "flip_x", "use_flip_x"), + ("MulticamSequence", "flip_y", "use_flip_y"), + ("MulticamSequence", "convert_float", "use_float"), + ("MulticamSequence", "premultiply", "use_premultiply"), + ("MulticamSequence", "proxy_custom_directory", "use_proxy_custom_directory"), + ("MulticamSequence", "proxy_custom_file", "use_proxy_custom_file"), + ("MulticamSequence", "reverse_frames", "use_reverse_frames"), + ("SceneSequence", "animation_end_offset", "animation_offset_end"), + ("SceneSequence", "animation_start_offset", "animation_offset_start"), + ("SceneSequence", "multiply_colors", "color_multiply"), + ("SceneSequence", "de_interlace", "use_deinterlace"), + ("SceneSequence", "flip_x", "use_flip_x"), + ("SceneSequence", "flip_y", "use_flip_y"), + ("SceneSequence", "convert_float", "use_float"), + ("SceneSequence", "premultiply", "use_premultiply"), + ("SceneSequence", "proxy_custom_directory", "use_proxy_custom_directory"), + ("SceneSequence", "proxy_custom_file", "use_proxy_custom_file"), + ("SceneSequence", "reverse_frames", "use_reverse_frames"), + ("SoundSequence", "animation_end_offset", "animation_offset_end"), + ("SoundSequence", "animation_start_offset", "animation_offset_start"), + ("SmokeDomainSettings", "smoke_domain_colli", "collision_extents"), + ("SmokeDomainSettings", "smoke_cache_high_comp", "point_cache_compress_high_type"), + ("SmokeDomainSettings", "smoke_cache_comp", "point_cache_compress_type"), + ("SmokeDomainSettings", "maxres", "resolution_max"), + ("SmokeDomainSettings", "smoothemitter", "smooth_emitter"), + ("SmokeDomainSettings", "dissolve_smoke", "use_dissolve_smoke"), + ("SmokeDomainSettings", "dissolve_smoke_log", "use_dissolve_smoke_log"), + ("SmokeDomainSettings", "highres", "use_high_resolution"), + ("SoftBodySettings", "bending", "bend"), + ("SoftBodySettings", "error_limit", "error_threshold"), + ("SoftBodySettings", "lcom", "location_mass_center"), + ("SoftBodySettings", "lrot", "rotation_estimate"), + ("SoftBodySettings", "lscale", "scale_estimate"), + ("SoftBodySettings", "maxstep", "step_max"), + ("SoftBodySettings", "minstep", "step_min"), + ("SoftBodySettings", "diagnose", "use_diagnose"), + ("SoftBodySettings", "edge_collision", "use_edge_collision"), + ("SoftBodySettings", "estimate_matrix", "use_estimate_matrix"), + ("SoftBodySettings", "face_collision", "use_face_collision"), + ("SoftBodySettings", "self_collision", "use_self_collision"), + ("SoftBodySettings", "stiff_quads", "use_stiff_quads"), + ("TexMapping", "maximum", "max"), + ("TexMapping", "minimum", "min"), + ("TexMapping", "has_maximum", "use_max"), + ("TexMapping", "has_minimum", "use_min"), + ("TextCharacterFormat", "bold", "use_bold"), + ("TextCharacterFormat", "italic", "use_italic"), + ("TextCharacterFormat", "underline", "use_underline"), + ("TextureSlot", "rgb_to_intensity", "use_rgb_to_intensity"), + ("TextureSlot", "stencil", "use_stencil"), + ("LampTextureSlot", "texture_coordinates", "texture_coords"), + ("LampTextureSlot", "map_color", "use_map_color"), + ("LampTextureSlot", "map_shadow", "use_map_shadow"), + ("MaterialTextureSlot", "coloremission_factor", "color_emission_factor"), + ("MaterialTextureSlot", "colordiff_factor", "diffuse_color_factor"), + ("MaterialTextureSlot", "x_mapping", "mapping_x"), + ("MaterialTextureSlot", "y_mapping", "mapping_y"), + ("MaterialTextureSlot", "z_mapping", "mapping_z"), + ("MaterialTextureSlot", "colorreflection_factor", "reflection_color_factor"), + ("MaterialTextureSlot", "colorspec_factor", "specular_color_factor"), + ("MaterialTextureSlot", "texture_coordinates", "texture_coords"), + ("MaterialTextureSlot", "colortransmission_factor", "transmission_color_factor"), + ("MaterialTextureSlot", "from_dupli", "use_from_dupli"), + ("MaterialTextureSlot", "from_original", "use_from_original"), + ("MaterialTextureSlot", "map_alpha", "use_map_alpha"), + ("MaterialTextureSlot", "map_ambient", "use_map_ambient"), + ("MaterialTextureSlot", "map_colordiff", "use_map_color_diff"), + ("MaterialTextureSlot", "map_coloremission", "use_map_color_emission"), + ("MaterialTextureSlot", "map_colorreflection", "use_map_color_reflection"), + ("MaterialTextureSlot", "map_colorspec", "use_map_color_spec"), + ("MaterialTextureSlot", "map_colortransmission", "use_map_color_transmission"), + ("MaterialTextureSlot", "map_density", "use_map_density"), + ("MaterialTextureSlot", "map_diffuse", "use_map_diffuse"), + ("MaterialTextureSlot", "map_displacement", "use_map_displacement"), + ("MaterialTextureSlot", "map_emission", "use_map_emission"), + ("MaterialTextureSlot", "map_emit", "use_map_emit"), + ("MaterialTextureSlot", "map_hardness", "use_map_hardness"), + ("MaterialTextureSlot", "map_mirror", "use_map_mirror"), + ("MaterialTextureSlot", "map_normal", "use_map_normal"), + ("MaterialTextureSlot", "map_raymir", "use_map_raymir"), + ("MaterialTextureSlot", "map_reflection", "use_map_reflect"), + ("MaterialTextureSlot", "map_scattering", "use_map_scatter"), + ("MaterialTextureSlot", "map_specular", "use_map_specular"), + ("MaterialTextureSlot", "map_translucency", "use_map_translucency"), + ("MaterialTextureSlot", "map_warp", "use_map_warp"), + ("WorldTextureSlot", "texture_coordinates", "texture_coords"), + ("WorldTextureSlot", "map_blend", "use_map_blend"), + ("WorldTextureSlot", "map_horizon", "use_map_horizon"), + ("WorldTextureSlot", "map_zenith_down", "use_map_zenith_down"), + ("WorldTextureSlot", "map_zenith_up", "use_map_zenith_up"), + ("VoxelData", "still_frame_number", "still_frame"), + ("WorldLighting", "ao_blend_mode", "ao_blend_type"), + ("WorldLighting", "error_tolerance", "error_threshold"), + ("WorldLighting", "use_ambient_occlusion", "use_ambient_occlusian"), + ("WorldLighting", "pixel_cache", "use_cache"), + ("WorldLighting", "use_environment_lighting", "use_environment_light"), + ("WorldLighting", "use_indirect_lighting", "use_indirect_light"), + ("WorldStarsSettings", "color_randomization", "color_random"), + ("WorldStarsSettings", "min_distance", "distance_min"), + ] + + +import bpy + + +class UpdateAnimData(bpy.types.Operator): + '''''' + bl_idname = "anim.update_data_paths" + bl_label = "Update Animation Data" + + def execute(self, context): + import animsys_refactor + reload(animsys_refactor) + animsys_refactor.update_data_paths(data_path_update) + return {'FINISHED'} + + +if __name__ == "__main__": + bpy.ops.anim.update_data_paths() + +def register(): + pass
\ No newline at end of file diff --git a/release/scripts/op/presets.py b/release/scripts/op/presets.py index be68a7f1609..43e2cda5d53 100644 --- a/release/scripts/op/presets.py +++ b/release/scripts/op/presets.py @@ -125,7 +125,7 @@ class AddPresetSSS(AddPresetBase, bpy.types.Operator): "bpy.context.material.subsurface_scattering.color[1]", "bpy.context.material.subsurface_scattering.color[2]", "bpy.context.material.subsurface_scattering.color_factor", - "bpy.context.material.subsurface_scattering.error_tolerance", + "bpy.context.material.subsurface_scattering.error_threshold", "bpy.context.material.subsurface_scattering.front", "bpy.context.material.subsurface_scattering.ior", "bpy.context.material.subsurface_scattering.radius[0]", diff --git a/release/scripts/op/sequencer.py b/release/scripts/op/sequencer.py index cbb7d00e659..feedb5cb4a8 100644 --- a/release/scripts/op/sequencer.py +++ b/release/scripts/op/sequencer.py @@ -129,7 +129,7 @@ class SequencerDeinterlaceSelectedMovies(bpy.types.Operator): def execute(self, context): for s in context.scene.sequence_editor.sequences_all: if s.select and s.type == 'MOVIE': - s.de_interlace = True + s.use_deinterlace = True return {'FINISHED'} diff --git a/release/scripts/ui/properties_animviz.py b/release/scripts/ui/properties_animviz.py index bbd849e4daf..9b605d02215 100644 --- a/release/scripts/ui/properties_animviz.py +++ b/release/scripts/ui/properties_animviz.py @@ -41,8 +41,8 @@ class MotionPathButtonsPanel(): col = split.column() sub = col.column(align=True) if (mps.type == 'CURRENT_FRAME'): - sub.prop(mps, "before_current", text="Before") - sub.prop(mps, "after_current", text="After") + sub.prop(mps, "frame_before", text="Before") + sub.prop(mps, "frame_after", text="After") elif (mps.type == 'RANGE'): sub.prop(mps, "frame_start", text="Start") sub.prop(mps, "frame_end", text="End") diff --git a/release/scripts/ui/properties_data_armature.py b/release/scripts/ui/properties_data_armature.py index 767b163d3c2..7de06554751 100644 --- a/release/scripts/ui/properties_data_armature.py +++ b/release/scripts/ui/properties_data_armature.py @@ -67,18 +67,18 @@ class DATA_PT_skeleton(ArmatureButtonsPanel, bpy.types.Panel): col.label(text="Layers:") col.prop(arm, "layers", text="") col.label(text="Protected Layers:") - col.prop(arm, "layer_protection", text="") + col.prop(arm, "layers_protected", text="") col.label(text="Deform:") split = layout.split() col = split.column() - col.prop(arm, "deform_vertexgroups", text="Vertex Groups") - col.prop(arm, "deform_envelope", text="Envelopes") + col.prop(arm, "use_deform_vertex_groups", text="Vertex Groups") + col.prop(arm, "use_deform_envelopes", text="Envelopes") col = split.column() - col.prop(arm, "deform_quaternion", text="Quaternion") + col.prop(arm, "use_deform_preserve_volume", text="Quaternion") class DATA_PT_display(ArmatureButtonsPanel, bpy.types.Panel): @@ -90,7 +90,7 @@ class DATA_PT_display(ArmatureButtonsPanel, bpy.types.Panel): ob = context.object arm = context.armature - layout.row().prop(arm, "drawtype", expand=True) + layout.row().prop(arm, "draw_type", expand=True) split = layout.split() @@ -102,7 +102,7 @@ class DATA_PT_display(ArmatureButtonsPanel, bpy.types.Panel): col = split.column() col.prop(arm, "show_group_colors", text="Colors") col.prop(ob, "show_x_ray", text="X-Ray") - col.prop(arm, "delay_deform", text="Delay Refresh") + col.prop(arm, "use_deform_delay", text="Delay Refresh") class DATA_PT_bone_groups(ArmatureButtonsPanel, bpy.types.Panel): diff --git a/release/scripts/ui/properties_data_armature_rigify.py b/release/scripts/ui/properties_data_armature_rigify.py index 0dbd964acb5..1c2370cbb28 100644 --- a/release/scripts/ui/properties_data_armature_rigify.py +++ b/release/scripts/ui/properties_data_armature_rigify.py @@ -84,7 +84,7 @@ class DATA_PT_template(bpy.types.Panel): row.operator("pose.metarig_validate", text="Check") row.operator("pose.metarig_graph", text="Graph") row = layout.row() - row.prop(pose_templates, "generate_def_rig") + row.prop(pose_templates, "use_generate_deform_rig") row = layout.row() col = row.column() @@ -151,7 +151,7 @@ class Generate(bpy.types.Operator): import rigify reload(rigify) - meta_def = context.scene.pose_templates.generate_def_rig + meta_def = context.scene.pose_templates.use_generate_deform_rig try: rigify.generate_rig(context, context.object, META_DEF=meta_def) @@ -329,7 +329,7 @@ def register(): min=-1, max=65535) - PoseTemplateSettings.BoolProperty(attr="generate_def_rig", + PoseTemplateSettings.BoolProperty(attr="use_generate_deform_rig", name="Create Deform Rig", description="Create a copy of the metarig, constrainted by the generated rig", default=False) diff --git a/release/scripts/ui/properties_data_bone.py b/release/scripts/ui/properties_data_bone.py index 4c0f8a3e52c..663d576a9c0 100644 --- a/release/scripts/ui/properties_data_bone.py +++ b/release/scripts/ui/properties_data_bone.py @@ -233,12 +233,12 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, bpy.types.Panel): split = layout.split(percentage=0.25) sub = split.row() - sub.prop(pchan, "ik_limit_x", text="Limit") + sub.prop(pchan, "use_ik_limit_x", text="Limit") sub.active = pchan.lock_ik_x == False and pchan.is_in_ik_chain sub = split.row(align=True) sub.prop(pchan, "ik_min_x", text="") sub.prop(pchan, "ik_max_x", text="") - sub.active = pchan.lock_ik_x == False and pchan.ik_limit_x and pchan.is_in_ik_chain + sub.active = pchan.lock_ik_x == False and pchan.use_ik_limit_x and pchan.is_in_ik_chain split = layout.split(percentage=0.25) split.prop(pchan, "lock_ik_y", text="Y") @@ -250,13 +250,13 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, bpy.types.Panel): split = layout.split(percentage=0.25) sub = split.row() - sub.prop(pchan, "ik_limit_y", text="Limit") + sub.prop(pchan, "use_ik_limit_y", text="Limit") sub.active = pchan.lock_ik_y == False and pchan.is_in_ik_chain sub = split.row(align=True) sub.prop(pchan, "ik_min_y", text="") sub.prop(pchan, "ik_max_y", text="") - sub.active = pchan.lock_ik_y == False and pchan.ik_limit_y and pchan.is_in_ik_chain + sub.active = pchan.lock_ik_y == False and pchan.use_ik_limit_y and pchan.is_in_ik_chain split = layout.split(percentage=0.25) split.prop(pchan, "lock_ik_z", text="Z") @@ -268,12 +268,12 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, bpy.types.Panel): split = layout.split(percentage=0.25) sub = split.row() - sub.prop(pchan, "ik_limit_z", text="Limit") + sub.prop(pchan, "use_ik_limit_z", text="Limit") sub.active = pchan.lock_ik_z == False and pchan.is_in_ik_chain sub = split.row(align=True) sub.prop(pchan, "ik_min_z", text="") sub.prop(pchan, "ik_max_z", text="") - sub.active = pchan.lock_ik_z == False and pchan.ik_limit_z and pchan.is_in_ik_chain + sub.active = pchan.lock_ik_z == False and pchan.use_ik_limit_z and pchan.is_in_ik_chain split = layout.split() split.prop(pchan, "ik_stretch", text="Stretch", slider=True) split.label() @@ -282,15 +282,15 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, bpy.types.Panel): if ob.pose.ik_solver == 'ITASC': split = layout.split() col = split.column() - col.prop(pchan, "ik_rot_control", text="Control Rotation") + col.prop(pchan, "use_ik_rotation_control", text="Control Rotation") col.active = pchan.is_in_ik_chain col = split.column() - col.prop(pchan, "ik_rot_weight", text="Weight", slider=True) + col.prop(pchan, "ik_rotation_weight", text="Weight", slider=True) col.active = pchan.is_in_ik_chain # not supported yet #row = layout.row() - #row.prop(pchan, "ik_lin_control", text="Joint Size") - #row.prop(pchan, "ik_lin_weight", text="Weight", slider=True) + #row.prop(pchan, "use_ik_linear_control", text="Joint Size") + #row.prop(pchan, "ik_linear_weight", text="Weight", slider=True) class BONE_PT_deform(BoneButtonsPanel, bpy.types.Panel): diff --git a/release/scripts/ui/properties_data_curve.py b/release/scripts/ui/properties_data_curve.py index cd62746c3ab..3008db11b36 100644 --- a/release/scripts/ui/properties_data_curve.py +++ b/release/scripts/ui/properties_data_curve.py @@ -140,7 +140,7 @@ class DATA_PT_geometry_curve(CurveButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Modification:") - col.prop(curve, "width") + col.prop(curve, "offset") col.prop(curve, "extrude") col.label(text="Taper Object:") col.prop(curve, "taper_object", text="") @@ -299,9 +299,9 @@ class DATA_PT_font(CurveButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Character:") - col.prop(char, "bold") - col.prop(char, "italic") - col.prop(char, "underline") + col.prop(char, "use_bold") + col.prop(char, "use_italic") + col.prop(char, "use_underline") split = layout.split() col = split.column() diff --git a/release/scripts/ui/properties_data_lamp.py b/release/scripts/ui/properties_data_lamp.py index 8eb0c275462..8d82f5ef943 100644 --- a/release/scripts/ui/properties_data_lamp.py +++ b/release/scripts/ui/properties_data_lamp.py @@ -99,7 +99,7 @@ class DATA_PT_lamp(DataButtonsPanel, bpy.types.Panel): sub.prop(lamp, "linear_attenuation", slider=True, text="Linear") sub.prop(lamp, "quadratic_attenuation", slider=True, text="Quadratic") - col.prop(lamp, "sphere") + col.prop(lamp, "use_sphere") if lamp.type == 'AREA': col.prop(lamp, "distance") @@ -221,8 +221,8 @@ class DATA_PT_shadow(DataButtonsPanel, bpy.types.Panel): col.prop(lamp, "shadow_color", text="") col = split.column() - col.prop(lamp, "shadow_layer", text="This Layer Only") - col.prop(lamp, "only_shadow") + col.prop(lamp, "use_shadow_layer", text="This Layer Only") + col.prop(lamp, "use_only_shadow") if lamp.shadow_method == 'RAY_SHADOW': split = layout.split() @@ -245,19 +245,19 @@ class DATA_PT_shadow(DataButtonsPanel, bpy.types.Panel): sub.prop(lamp, "shadow_ray_samples_x", text="Samples X") sub.prop(lamp, "shadow_ray_samples_y", text="Samples Y") - col.row().prop(lamp, "shadow_ray_sampling_method", expand=True) + col.row().prop(lamp, "shadow_ray_sample_method", expand=True) split = layout.split() col = split.column() - if lamp.shadow_ray_sampling_method == 'ADAPTIVE_QMC': + if lamp.shadow_ray_sample_method == 'ADAPTIVE_QMC': col.prop(lamp, "shadow_adaptive_threshold", text="Threshold") col = split.column() - if lamp.type == 'AREA' and lamp.shadow_ray_sampling_method == 'CONSTANT_JITTERED': + if lamp.type == 'AREA' and lamp.shadow_ray_sample_method == 'CONSTANT_JITTERED': col = split.column() col = split.column() - col.prop(lamp, "umbra") + col.prop(lamp, "use_umbra") col.prop(lamp, "dither") col.prop(lamp, "jitter") @@ -291,15 +291,15 @@ class DATA_PT_shadow(DataButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(lamp, "auto_clip_start", text="Autoclip Start") + col.prop(lamp, "use_auto_clip_start", text="Autoclip Start") sub = col.column() - sub.active = not lamp.auto_clip_start + sub.active = not lamp.use_auto_clip_start sub.prop(lamp, "shadow_buffer_clip_start", text="Clip Start") col = split.column() - col.prop(lamp, "auto_clip_end", text="Autoclip End") + col.prop(lamp, "use_auto_clip_end", text="Autoclip End") sub = col.column() - sub.active = not lamp.auto_clip_end + sub.active = not lamp.use_auto_clip_end sub.prop(lamp, "shadow_buffer_clip_end", text=" Clip End") diff --git a/release/scripts/ui/properties_data_mesh.py b/release/scripts/ui/properties_data_mesh.py index 1188de7f11c..aaf814ed705 100644 --- a/release/scripts/ui/properties_data_mesh.py +++ b/release/scripts/ui/properties_data_mesh.py @@ -91,10 +91,10 @@ class DATA_PT_normals(MeshButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(mesh, "autosmooth") + col.prop(mesh, "use_auto_smooth") sub = col.column() - sub.active = mesh.autosmooth - sub.prop(mesh, "autosmooth_angle", text="Angle") + sub.active = mesh.use_auto_smooth + sub.prop(mesh, "auto_smooth_angle", text="Angle") col = split.column() @@ -183,7 +183,7 @@ class DATA_PT_shape_keys(MeshButtonsPanel, bpy.types.Panel): enable_edit_value = False if ob.show_shape_key is False: - if enable_edit or (ob.type == 'MESH' and ob.shape_key_edit_mode): + if enable_edit or (ob.type == 'MESH' and ob.use_shape_key_edit_mode): enable_edit_value = True row = layout.row() @@ -220,7 +220,7 @@ class DATA_PT_shape_keys(MeshButtonsPanel, bpy.types.Panel): subsub.active = enable_edit_value subsub.prop(ob, "show_shape_key", text="") subsub.prop(kb, "mute", text="") - sub.prop(ob, "shape_key_edit_mode", text="") + sub.prop(ob, "use_shape_key_edit_mode", text="") sub = row.row() sub.operator("object.shape_key_clear", icon='X', text="") diff --git a/release/scripts/ui/properties_data_modifier.py b/release/scripts/ui/properties_data_modifier.py index 26080951fff..e08c7cb1f23 100644 --- a/release/scripts/ui/properties_data_modifier.py +++ b/release/scripts/ui/properties_data_modifier.py @@ -70,7 +70,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Deformation:") col.prop(md, "quaternion") - col.prop(md, "multi_modifier") + col.prop(md, "use_multi_modifier") def ARRAY(self, layout, ob, md): layout.prop(md, "fit_type") @@ -87,30 +87,30 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(md, "constant_offset") + col.prop(md, "use_constant_offset") sub = col.column() - sub.active = md.constant_offset - sub.prop(md, "constant_offset_displacement", text="") + sub.active = md.use_constant_offset + sub.prop(md, "constant_offset_displace", text="") col.separator() - col.prop(md, "merge_adjacent_vertices", text="Merge") + col.prop(md, "use_merge_vertices", text="Merge") sub = col.column() - sub.active = md.merge_adjacent_vertices - sub.prop(md, "merge_end_vertices", text="First Last") - sub.prop(md, "merge_distance", text="Distance") + sub.active = md.use_merge_vertices + sub.prop(md, "use_merge_vertices_cap", text="First Last") + sub.prop(md, "merge_threshold", text="Distance") col = split.column() - col.prop(md, "relative_offset") + col.prop(md, "use_relative_offset") sub = col.column() - sub.active = md.relative_offset - sub.prop(md, "relative_offset_displacement", text="") + sub.active = md.use_relative_offset + sub.prop(md, "relative_offset_displace", text="") col.separator() - col.prop(md, "add_offset_object") + col.prop(md, "use_object_offset") sub = col.column() - sub.active = md.add_offset_object + sub.active = md.use_object_offset sub.prop(md, "offset_object", text="") layout.separator() @@ -126,7 +126,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col.prop(md, "width") col = split.column() - col.prop(md, "only_vertices") + col.prop(md, "use_only_vertices") layout.label(text="Limit Method:") layout.row().prop(md, "limit_method", expand=True) @@ -176,7 +176,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col.prop(md, "factor") col.prop(md, "radius") col.prop(md, "size") - col.prop(md, "from_radius") + col.prop(md, "use_radius_as_size") split = layout.split() @@ -224,10 +224,10 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col.label(text="Direction:") col.prop(md, "direction", text="") col.label(text="Texture Coordinates:") - col.prop(md, "texture_coordinates", text="") - if md.texture_coordinates == 'OBJECT': + col.prop(md, "texture_coords", text="") + if md.texture_coords == 'OBJECT': layout.prop(md, "texture_coordinate_object", text="Object") - elif md.texture_coordinates == 'UV' and ob.type == 'MESH': + elif md.texture_coords == 'UV' and ob.type == 'MESH': layout.prop_object(md, "uv_layer", ob.data, "uv_textures") layout.separator() @@ -235,7 +235,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(md, "midlevel") + col.prop(md, "mid_level") col = split.column() col.prop(md, "strength") @@ -250,7 +250,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): sub.prop(md, "split_angle") col = split.column() - col.prop(md, "use_sharp", text="Sharp Edges") + col.prop(md, "use_edge_sharp", text="Sharp Edges") def EXPLODE(self, layout, ob, md): split = layout.split() @@ -263,7 +263,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): sub.prop(md, "protect") col = split.column() - col.prop(md, "split_edges") + col.prop(md, "use_edge_split") col.prop(md, "show_unborn") col.prop(md, "show_alive") col.prop(md, "show_dead") @@ -365,7 +365,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col.prop(md, "dynamic") def MIRROR(self, layout, ob, md): - layout.prop(md, "merge_limit") + layout.prop(md, "merge_threshold") split = layout.split(percentage=0.25) col = split.column() @@ -377,12 +377,12 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Options:") col.prop(md, "clip", text="Clipping") - col.prop(md, "mirror_vertex_groups", text="Vertex Groups") + col.prop(md, "use_mirror_vertex_groups", text="Vertex Groups") col = split.column() col.label(text="Textures:") - col.prop(md, "mirror_u", text="U") - col.prop(md, "mirror_v", text="V") + col.prop(md, "use_mirror_u", text="U") + col.prop(md, "use_mirror_v", text="V") col = layout.column() col.label(text="Mirror Object:") @@ -420,7 +420,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): def PARTICLE_INSTANCE(self, layout, ob, md): layout.prop(md, "object") - layout.prop(md, "particle_system_number", text="Particle System") + layout.prop(md, "particle_system_index", text="Particle System") split = layout.split() col = split.column() @@ -443,7 +443,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): split.active = md.use_path col = split.column() col.row().prop(md, "axis", expand=True) - col.prop(md, "keep_shape") + col.prop(md, "use_preserve_shape") col = split.column() col.prop(md, "position", slider=True) @@ -510,14 +510,14 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Cull Faces:") - col.prop(md, "cull_front_faces", text="Front") - col.prop(md, "cull_back_faces", text="Back") + col.prop(md, "use_cull_front_faces", text="Front") + col.prop(md, "use_cull_back_faces", text="Back") layout.label(text="Auxiliary Target:") layout.prop(md, "auxiliary_target", text="") elif md.mode == 'NEAREST_SURFACEPOINT': - layout.prop(md, "keep_above_surface") + layout.prop(md, "use_keep_above_surface") def SIMPLE_DEFORM(self, layout, ob, md): split = layout.split() @@ -544,8 +544,8 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col.prop(md, "factor") col.prop(md, "limits", slider=True) if md.mode in ('TAPER', 'STRETCH'): - col.prop(md, "lock_x_axis") - col.prop(md, "lock_y_axis") + col.prop(md, "lock_x") + col.prop(md, "lock_y") def SMOKE(self, layout, ob, md): layout.label(text="See Smoke panel.") @@ -611,7 +611,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Options:") - col.prop(md, "subsurf_uv") + col.prop(md, "use_subsurf_uv") col.prop(md, "show_only_control_edges") def SURFACE(self, layout, ob, md): @@ -631,8 +631,8 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(md, "override_image") - col.prop(md, "num_projectors", text="Projectors") + col.prop(md, "use_image_override") + col.prop(md, "projector_count", text="Projectors") for proj in md.projectors: col.prop(proj, "object", text="") @@ -658,9 +658,9 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): col.prop(md, "normals") sub = col.column() sub.active = md.normals - sub.prop(md, "x_normal", text="X") - sub.prop(md, "y_normal", text="Y") - sub.prop(md, "z_normal", text="Z") + sub.prop(md, "use_normal_x", text="X") + sub.prop(md, "use_normal_y", text="Y") + sub.prop(md, "use_normal_z", text="Z") split = layout.split() @@ -683,10 +683,10 @@ class DATA_PT_modifiers(ModifierButtonsPanel, bpy.types.Panel): layout.prop(md, "start_position_object") layout.prop_object(md, "vertex_group", ob, "vertex_groups") layout.prop(md, "texture") - layout.prop(md, "texture_coordinates") - if md.texture_coordinates == 'MAP_UV' and ob.type == 'MESH': + layout.prop(md, "texture_coords") + if md.texture_coords == 'MAP_UV' and ob.type == 'MESH': layout.prop_object(md, "uv_layer", ob.data, "uv_textures") - elif md.texture_coordinates == 'OBJECT': + elif md.texture_coords == 'OBJECT': layout.prop(md, "texture_coords_object") layout.separator() diff --git a/release/scripts/ui/properties_game.py b/release/scripts/ui/properties_game.py index ee026a3663a..f90a5446557 100644 --- a/release/scripts/ui/properties_game.py +++ b/release/scripts/ui/properties_game.py @@ -122,25 +122,25 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, bpy.types.Panel): col.label(text="Attributes:") col.prop(game, "mass") col.prop(soft, "weld_threshold") - col.prop(soft, "position_iterations") - col.prop(soft, "linstiff", slider=True) + col.prop(soft, "location_iterations") + col.prop(soft, "linear_stiffness", slider=True) col.prop(soft, "dynamic_friction", slider=True) col.prop(soft, "collision_margin", slider=True) - col.prop(soft, "bending_const", text="Bending Constraints") + col.prop(soft, "use_bending_constraints", text="Bending Constraints") col = split.column() - col.prop(soft, "shape_match") + col.prop(soft, "use_shape_match") sub = col.column() - sub.active = soft.shape_match + sub.active = soft.use_shape_match sub.prop(soft, "shape_threshold", slider=True) col.separator() col.label(text="Cluster Collision:") - col.prop(soft, "cluster_rigid_to_softbody") - col.prop(soft, "cluster_soft_to_softbody") + col.prop(soft, "use_cluster_rigid_to_softbody") + col.prop(soft, "use_cluster_soft_to_softbody") sub = col.column() - sub.active = (soft.cluster_rigid_to_softbody or soft.cluster_soft_to_softbody) + sub.active = (soft.cluster_rigid_to_softbody or soft.use_cluster_soft_to_softbody) sub.prop(soft, "cluster_iterations", text="Iterations") elif game.physics_type == 'STATIC': @@ -236,9 +236,9 @@ class RENDER_PT_game_player(RenderButtonsPanel, bpy.types.Panel): # framing: col = layout.column() col.label(text="Framing:") - col.row().prop(gs, "framing_type", expand=True) - if gs.framing_type == 'LETTERBOX': - col.prop(gs, "framing_color", text="") + col.row().prop(gs, "frame_type", expand=True) + if gs.frame_type == 'LETTERBOX': + col.prop(gs, "frame_color", text="") class RENDER_PT_game_stereo(RenderButtonsPanel, bpy.types.Panel): @@ -257,7 +257,7 @@ class RENDER_PT_game_stereo(RenderButtonsPanel, bpy.types.Panel): # stereo: if stereo_mode == 'STEREO': layout.prop(gs, "stereo_mode") - layout.prop(gs, "eye_separation") + layout.prop(gs, "stereo_eye_separation") # dome: elif stereo_mode == 'DOME': @@ -310,14 +310,14 @@ class RENDER_PT_game_shading(RenderButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(gs, "glsl_lights", text="Lights") - col.prop(gs, "glsl_shaders", text="Shaders") - col.prop(gs, "glsl_shadows", text="Shadows") + col.prop(gs, "use_glsl_lights", text="Lights") + col.prop(gs, "use_glsl_shaders", text="Shaders") + col.prop(gs, "use_glsl_shadows", text="Shadows") col = split.column() - col.prop(gs, "glsl_ramps", text="Ramps") - col.prop(gs, "glsl_nodes", text="Nodes") - col.prop(gs, "glsl_extra_textures", text="Extra Textures") + col.prop(gs, "use_glsl_ramps", text="Ramps") + col.prop(gs, "use_glsl_nodes", text="Nodes") + col.prop(gs, "use_glsl_extra_textures", text="Extra Textures") class RENDER_PT_game_performance(RenderButtonsPanel, bpy.types.Panel): diff --git a/release/scripts/ui/properties_material.py b/release/scripts/ui/properties_material.py index 2ecaeff7c90..d4e07f8333b 100644 --- a/release/scripts/ui/properties_material.py +++ b/release/scripts/ui/properties_material.py @@ -149,16 +149,16 @@ class MATERIAL_PT_diffuse(MaterialButtonsPanel, bpy.types.Panel): col = split.column() col.prop(mat, "diffuse_color", text="") sub = col.column() - sub.active = (not mat.shadeless) + sub.active = (not mat.use_shadeless) sub.prop(mat, "diffuse_intensity", text="Intensity") col = split.column() - col.active = (not mat.shadeless) + col.active = (not mat.use_shadeless) col.prop(mat, "diffuse_shader", text="") col.prop(mat, "use_diffuse_ramp", text="Ramp") col = layout.column() - col.active = (not mat.shadeless) + col.active = (not mat.use_shadeless) if mat.diffuse_shader == 'OREN_NAYAR': col.prop(mat, "roughness") elif mat.diffuse_shader == 'MINNAERT': @@ -211,7 +211,7 @@ class MATERIAL_PT_specular(MaterialButtonsPanel, bpy.types.Panel): mat = active_node_mat(context.material) - layout.active = (not mat.shadeless) + layout.active = (not mat.use_shadeless) split = layout.split() @@ -281,17 +281,17 @@ class MATERIAL_PT_shading(MaterialButtonsPanel, bpy.types.Panel): col = split.column() sub = col.column() - sub.active = not mat.shadeless + sub.active = not mat.use_shadeless sub.prop(mat, "emit") sub.prop(mat, "ambient") sub = col.column() sub.prop(mat, "translucency") col = split.column() - col.prop(mat, "shadeless") + col.prop(mat, "use_shadeless") sub = col.column() - sub.active = not mat.shadeless - sub.prop(mat, "tangent_shading") + sub.active = not mat.use_shadeless + sub.prop(mat, "use_tangent_shading") sub.prop(mat, "cubic") elif mat.type == 'HALO': @@ -312,7 +312,7 @@ class MATERIAL_PT_transp(MaterialButtonsPanel, bpy.types.Panel): def draw_header(self, context): mat = active_node_mat(context.material) - self.layout.prop(mat, "transparency", text="") + self.layout.prop(mat, "use_transparency", text="") def draw(self, context): layout = self.layout @@ -321,7 +321,7 @@ class MATERIAL_PT_transp(MaterialButtonsPanel, bpy.types.Panel): rayt = mat.raytrace_transparency row = layout.row() - row.active = mat.transparency and (not mat.shadeless) + row.active = mat.use_transparency and (not mat.use_shadeless) row.prop(mat, "transparency_method", expand=True) split = layout.split() @@ -329,11 +329,11 @@ class MATERIAL_PT_transp(MaterialButtonsPanel, bpy.types.Panel): col = split.column() col.prop(mat, "alpha") row = col.row() - row.active = mat.transparency and (not mat.shadeless) + row.active = mat.use_transparency and (not mat.use_shadeless) row.prop(mat, "specular_alpha", text="Specular") col = split.column() - col.active = (not mat.shadeless) + col.active = (not mat.use_shadeless) col.prop(rayt, "fresnel") sub = col.column() sub.active = rayt.fresnel > 0 @@ -342,7 +342,7 @@ class MATERIAL_PT_transp(MaterialButtonsPanel, bpy.types.Panel): if mat.transparency_method == 'RAYTRACE': layout.separator() split = layout.split() - split.active = mat.transparency + split.active = mat.use_transparency col = split.column() col.prop(rayt, "ior") @@ -433,7 +433,7 @@ class MATERIAL_PT_sss(MaterialButtonsPanel, bpy.types.Panel): mat = active_node_mat(context.material) sss = mat.subsurface_scattering - self.layout.active = (not mat.shadeless) + self.layout.active = (not mat.use_shadeless) self.layout.prop(sss, "use", text="") def draw(self, context): @@ -442,7 +442,7 @@ class MATERIAL_PT_sss(MaterialButtonsPanel, bpy.types.Panel): mat = active_node_mat(context.material) sss = mat.subsurface_scattering - layout.active = (sss.use) and (not mat.shadeless) + layout.active = (sss.use) and (not mat.use_shadeless) row = layout.row().split() sub = row.row(align=True).split(percentage=0.75) @@ -466,7 +466,7 @@ class MATERIAL_PT_sss(MaterialButtonsPanel, bpy.types.Panel): sub.prop(sss, "front") sub.prop(sss, "back") col.separator() - col.prop(sss, "error_tolerance", text="Error") + col.prop(sss, "error_threshold", text="Error") class MATERIAL_PT_halo(MaterialButtonsPanel, bpy.types.Panel): @@ -494,8 +494,8 @@ class MATERIAL_PT_halo(MaterialButtonsPanel, bpy.types.Panel): col.prop(halo, "add") col.label(text="Options:") col.prop(halo, "texture") - col.prop(halo, "vertex_normal") - col.prop(halo, "xalpha") + col.prop(halo, "use_vertex_normal") + col.prop(halo, "use_extreme_alpha") col.prop(halo, "shaded") col.prop(halo, "soft") @@ -503,19 +503,19 @@ class MATERIAL_PT_halo(MaterialButtonsPanel, bpy.types.Panel): col.prop(halo, "ring") sub = col.column() sub.active = halo.ring - sub.prop(halo, "rings") + sub.prop(halo, "ring_count") sub.prop(mat, "mirror_color", text="") col.separator() col.prop(halo, "lines") sub = col.column() sub.active = halo.lines - sub.prop(halo, "line_number", text="Lines") + sub.prop(halo, "line_count", text="Lines") sub.prop(mat, "specular_color", text="") col.separator() col.prop(halo, "star") sub = col.column() sub.active = halo.star - sub.prop(halo, "star_tips") + sub.prop(halo, "star_tip_count") class MATERIAL_PT_flare(MaterialButtonsPanel, bpy.types.Panel): @@ -531,7 +531,7 @@ class MATERIAL_PT_flare(MaterialButtonsPanel, bpy.types.Panel): def draw_header(self, context): halo = context.material.halo - self.layout.prop(halo, "flare_mode", text="") + self.layout.prop(halo, "use_flare_mode", text="") def draw(self, context): layout = self.layout @@ -539,7 +539,7 @@ class MATERIAL_PT_flare(MaterialButtonsPanel, bpy.types.Panel): mat = context.material # dont use node material halo = mat.halo - layout.active = halo.flare_mode + layout.active = halo.use_flare_mode split = layout.split() @@ -549,8 +549,8 @@ class MATERIAL_PT_flare(MaterialButtonsPanel, bpy.types.Panel): col.prop(halo, "flare_seed", text="Seed") col = split.column() - col.prop(halo, "flares_sub", text="Subflares") - col.prop(halo, "flare_subsize", text="Subsize") + col.prop(halo, "flare_subflare_count", text="Subflares") + col.prop(halo, "flare_subflare_size", text="Subsize") class MATERIAL_PT_physics(MaterialButtonsPanel, bpy.types.Panel): @@ -571,7 +571,7 @@ class MATERIAL_PT_physics(MaterialButtonsPanel, bpy.types.Panel): col = split.column() col.prop(phys, "distance") col.prop(phys, "friction") - col.prop(phys, "align_to_normal") + col.prop(phys, "use_normal_align") col = split.column() col.prop(phys, "force", slider=True) @@ -603,11 +603,11 @@ class MATERIAL_PT_strand(MaterialButtonsPanel, bpy.types.Panel): sub.label(text="Size:") sub.prop(tan, "root_size", text="Root") sub.prop(tan, "tip_size", text="Tip") - sub.prop(tan, "min_size", text="Minimum") - sub.prop(tan, "blender_units") + sub.prop(tan, "size_min", text="Minimum") + sub.prop(tan, "use_blender_units") sub = col.column() - sub.active = (not mat.shadeless) - sub.prop(tan, "tangent_shading") + sub.active = (not mat.use_shadeless) + sub.prop(tan, "use_tangent_shading") col.prop(tan, "shape") col = split.column() @@ -620,10 +620,10 @@ class MATERIAL_PT_strand(MaterialButtonsPanel, bpy.types.Panel): col.prop(tan, "uv_layer", text="") col.separator() sub = col.column() - sub.active = (not mat.shadeless) - sub.prop(tan, "surface_diffuse") + sub.active = (not mat.use_shadeless) + sub.prop(tan, "use_surface_diffuse") sub = col.column() - sub.active = tan.surface_diffuse + sub.active = tan.use_surface_diffuse sub.prop(tan, "blend_distance", text="Distance") @@ -645,30 +645,30 @@ class MATERIAL_PT_options(MaterialButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(mat, "traceable") - col.prop(mat, "full_oversampling") + col.prop(mat, "use_raytrace") + col.prop(mat, "use_full_oversampling") col.prop(mat, "use_sky") col.prop(mat, "use_mist") col.prop(mat, "invert_z") sub = col.row() - sub.prop(mat, "z_offset") - sub.active = mat.transparency and mat.transparency_method == 'Z_TRANSPARENCY' + sub.prop(mat, "offset_z") + sub.active = mat.use_transparency and mat.transparency_method == 'Z_TRANSPARENCY' sub = col.column(align=True) sub.label(text="Light Group:") sub.prop(mat, "light_group", text="") row = sub.row() row.active = bool(mat.light_group) - row.prop(mat, "light_group_exclusive", text="Exclusive") + row.prop(mat, "use_light_group_exclusive", text="Exclusive") col = split.column() - col.prop(mat, "face_texture") + col.prop(mat, "use_face_texture") sub = col.column() - sub.active = mat.face_texture - sub.prop(mat, "face_texture_alpha") + sub.active = mat.use_face_texture + sub.prop(mat, "use_face_texture_alpha") col.separator() - col.prop(mat, "vertex_color_paint") - col.prop(mat, "vertex_color_light") - col.prop(mat, "object_color") + col.prop(mat, "use_vertex_color_paint") + col.prop(mat, "use_vertex_color_light") + col.prop(mat, "use_object_color") class MATERIAL_PT_shadow(MaterialButtonsPanel, bpy.types.Panel): @@ -691,21 +691,21 @@ class MATERIAL_PT_shadow(MaterialButtonsPanel, bpy.types.Panel): col = split.column() col.prop(mat, "shadows", text="Receive") - col.prop(mat, "receive_transparent_shadows", text="Receive Transparent") - col.prop(mat, "only_shadow", text="Shadows Only") - col.prop(mat, "cast_shadows_only", text="Cast Only") - col.prop(mat, "shadow_casting_alpha", text="Casting Alpha") + col.prop(mat, "use_transparent_shadows", text="Receive Transparent") + col.prop(mat, "use_only_shadow", text="Shadows Only") + col.prop(mat, "use_cast_shadows_only", text="Cast Only") + col.prop(mat, "shadow_cast_alpha", text="Casting Alpha") col = split.column() - col.prop(mat, "cast_buffer_shadows") + col.prop(mat, "use_cast_buffer_shadows") sub = col.column() - sub.active = mat.cast_buffer_shadows + sub.active = mat.use_cast_buffer_shadows sub.prop(mat, "shadow_buffer_bias", text="Buffer Bias") - col.prop(mat, "ray_shadow_bias", text="Auto Ray Bias") + col.prop(mat, "use_ray_shadow_bias", text="Auto Ray Bias") sub = col.column() - sub.active = (not mat.ray_shadow_bias) + sub.active = (not mat.use_ray_shadow_bias) sub.prop(mat, "shadow_ray_bias", text="Ray Bias") - col.prop(mat, "cast_approximate") + col.prop(mat, "use_cast_approximate") class MATERIAL_PT_transp_game(MaterialButtonsPanel, bpy.types.Panel): @@ -722,7 +722,7 @@ class MATERIAL_PT_transp_game(MaterialButtonsPanel, bpy.types.Panel): def draw_header(self, context): mat = active_node_mat(context.material) - self.layout.prop(mat, "transparency", text="") + self.layout.prop(mat, "use_transparency", text="") def draw(self, context): layout = self.layout @@ -731,7 +731,7 @@ class MATERIAL_PT_transp_game(MaterialButtonsPanel, bpy.types.Panel): rayt = mat.raytrace_transparency row = layout.row() - row.active = mat.transparency and (not mat.shadeless) + row.active = mat.use_transparency and (not mat.use_shadeless) row.prop(mat, "transparency_method", expand=True) split = layout.split() @@ -810,21 +810,21 @@ class MATERIAL_PT_volume_lighting(VolumeButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(vol, "lighting_mode", text="") + col.prop(vol, "light_method", text="") col = split.column() - if vol.lighting_mode == 'SHADED': - col.prop(vol, "external_shadows") - col.prop(vol, "light_cache") + if vol.light_method == 'SHADED': + col.prop(vol, "use_external_shadows") + col.prop(vol, "use_light_cache") sub = col.column() - sub.active = vol.light_cache + sub.active = vol.use_light_cache sub.prop(vol, "cache_resolution") - elif vol.lighting_mode in ('MULTIPLE_SCATTERING', 'SHADED_PLUS_MULTIPLE_SCATTERING'): + elif vol.light_method in ('MULTIPLE_SCATTERING', 'SHADED_PLUS_MULTIPLE_SCATTERING'): sub = col.column() sub.enabled = True sub.active = False - sub.prop(vol, "light_cache") + sub.prop(vol, "use_light_cache") col.prop(vol, "cache_resolution") sub = col.column(align=True) @@ -859,13 +859,13 @@ class MATERIAL_PT_volume_integration(VolumeButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Step Calculation:") - col.prop(vol, "step_calculation", text="") + col.prop(vol, "step_method", text="") col = col.column(align=True) col.prop(vol, "step_size") col = split.column() col.label() - col.prop(vol, "depth_cutoff") + col.prop(vol, "depth_threshold") class MATERIAL_PT_volume_options(VolumeButtonsPanel, bpy.types.Panel): @@ -881,8 +881,8 @@ class MATERIAL_PT_volume_options(VolumeButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(mat, "traceable") - col.prop(mat, "full_oversampling") + col.prop(mat, "use_raytrace") + col.prop(mat, "use_full_oversampling") col.prop(mat, "use_mist") col = split.column() @@ -890,7 +890,7 @@ class MATERIAL_PT_volume_options(VolumeButtonsPanel, bpy.types.Panel): col.prop(mat, "light_group", text="") row = col.row() row.active = bool(mat.light_group) - row.prop(mat, "light_group_exclusive", text="Exclusive") + row.prop(mat, "use_light_group_exclusive", text="Exclusive") class MATERIAL_PT_custom_props(MaterialButtonsPanel, PropertyPanel, bpy.types.Panel): diff --git a/release/scripts/ui/properties_object.py b/release/scripts/ui/properties_object.py index 2bc685d972a..a87a43a7998 100644 --- a/release/scripts/ui/properties_object.py +++ b/release/scripts/ui/properties_object.py @@ -172,7 +172,7 @@ class OBJECT_PT_display(ObjectButtonsPanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(ob, "max_draw_type", text="Type") + col.prop(ob, "draw_type", text="Type") col = split.column() row = col.row() @@ -219,7 +219,7 @@ class OBJECT_PT_duplication(ObjectButtonsPanel, bpy.types.Panel): layout.prop(ob, "use_dupli_frames_speed", text="Speed") elif ob.dupli_type == 'VERTS': - layout.prop(ob, "use_dupli_verts_rotation", text="Rotation") + layout.prop(ob, "use_dupli_vertices_rotation", text="Rotation") elif ob.dupli_type == 'FACES': split = layout.split() @@ -249,15 +249,15 @@ class OBJECT_PT_animation(ObjectButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Time Offset:") - col.prop(ob, "time_offset_edit", text="Edit") + col.prop(ob, "use_time_offset_edit", text="Edit") row = col.row() - row.prop(ob, "time_offset_particle", text="Particle") + row.prop(ob, "use_time_offset_particle", text="Particle") row.active = bool(ob.particle_systems) row = col.row() - row.prop(ob, "time_offset_parent", text="Parent") + row.prop(ob, "use_time_offset_parent", text="Parent") row.active = (ob.parent is not None) row = col.row() - row.prop(ob, "slow_parent") + row.prop(ob, "use_slow_parent") row.active = (ob.parent is not None) col.prop(ob, "time_offset", text="Offset") diff --git a/release/scripts/ui/properties_object_constraint.py b/release/scripts/ui/properties_object_constraint.py index 59eb8e40e78..be102a17103 100644 --- a/release/scripts/ui/properties_object_constraint.py +++ b/release/scripts/ui/properties_object_constraint.py @@ -86,7 +86,7 @@ class ConstraintButtonsPanel(): col.prop(con, "use_stretch") col = split.column() - col.prop(con, "chain_length") + col.prop(con, "chain_count") col.prop(con, "use_target") def CHILD_OF(self, context, layout, con): @@ -133,7 +133,7 @@ class ConstraintButtonsPanel(): col.prop(con, "up", text="Up") col = split.column() - col.prop(con, "target_z") + col.prop(con, "use_target_z") self.space_template(layout, con) @@ -157,7 +157,7 @@ class ConstraintButtonsPanel(): split = layout.split() col = split.column() col.prop(con, "iterations") - col.prop(con, "chain_length") + col.prop(con, "chain_count") col.label(text="Weight:") col.prop(con, "weight", text="Position", slider=True) @@ -178,20 +178,20 @@ class ConstraintButtonsPanel(): row = layout.row() row.label(text="Axis Ref:") - row.prop(con, "axis_reference", expand=True) + row.prop(con, "reference_axis", expand=True) split = layout.split(percentage=0.33) - split.row().prop(con, "use_position") + split.row().prop(con, "use_location") row = split.row() row.prop(con, "weight", text="Weight", slider=True) - row.active = con.use_position + row.active = con.use_location split = layout.split(percentage=0.33) row = split.row() row.label(text="Lock:") row = split.row() - row.prop(con, "pos_lock_x", text="X") - row.prop(con, "pos_lock_y", text="Y") - row.prop(con, "pos_lock_z", text="Z") - split.active = con.use_position + row.prop(con, "lock_location_x", text="X") + row.prop(con, "lock_location_y", text="Y") + row.prop(con, "lock_location_z", text="Z") + split.active = con.use_location split = layout.split(percentage=0.33) split.row().prop(con, "use_rotation") @@ -202,9 +202,9 @@ class ConstraintButtonsPanel(): row = split.row() row.label(text="Lock:") row = split.row() - row.prop(con, "rot_lock_x", text="X") - row.prop(con, "rot_lock_y", text="Y") - row.prop(con, "rot_lock_z", text="Z") + row.prop(con, "lock_rotation_x", text="X") + row.prop(con, "lock_rotation_y", text="Y") + row.prop(con, "lock_rotation_z", text="Z") split.active = con.use_rotation def IK_DISTANCE(self, context, layout, con): @@ -226,8 +226,8 @@ class ConstraintButtonsPanel(): col.prop(con, "use_curve_radius") col = split.column() - col.prop(con, "use_fixed_position") - if con.use_fixed_position: + col.prop(con, "use_fixed_location") + if con.use_fixed_location: col.prop(con, "offset_factor", text="Offset") else: col.prop(con, "offset") @@ -248,25 +248,25 @@ class ConstraintButtonsPanel(): col.prop(con, "use_limit_x") sub = col.column() sub.active = con.use_limit_x - sub.prop(con, "minimum_x", text="Min") - sub.prop(con, "maximum_x", text="Max") + sub.prop(con, "min_x", text="Min") + sub.prop(con, "max_x", text="Max") col = split.column(align=True) col.prop(con, "use_limit_y") sub = col.column() sub.active = con.use_limit_y - sub.prop(con, "minimum_y", text="Min") - sub.prop(con, "maximum_y", text="Max") + sub.prop(con, "min_y", text="Min") + sub.prop(con, "max_y", text="Max") col = split.column(align=True) col.prop(con, "use_limit_z") sub = col.column() sub.active = con.use_limit_z - sub.prop(con, "minimum_z", text="Min") - sub.prop(con, "maximum_z", text="Max") + sub.prop(con, "min_z", text="Min") + sub.prop(con, "max_z", text="Max") row = layout.row() - row.prop(con, "limit_transform") + row.prop(con, "use_transform_limit") row.label() row = layout.row() @@ -277,37 +277,37 @@ class ConstraintButtonsPanel(): split = layout.split() col = split.column() - col.prop(con, "use_minimum_x") + col.prop(con, "use_min_x") sub = col.column() - sub.active = con.use_minimum_x - sub.prop(con, "minimum_x", text="") - col.prop(con, "use_maximum_x") + sub.active = con.use_min_x + sub.prop(con, "min_x", text="") + col.prop(con, "use_max_x") sub = col.column() - sub.active = con.use_maximum_x - sub.prop(con, "maximum_x", text="") + sub.active = con.use_max_x + sub.prop(con, "max_x", text="") col = split.column() - col.prop(con, "use_minimum_y") + col.prop(con, "use_min_y") sub = col.column() - sub.active = con.use_minimum_y - sub.prop(con, "minimum_y", text="") - col.prop(con, "use_maximum_y") + sub.active = con.use_min_y + sub.prop(con, "min_y", text="") + col.prop(con, "use_max_y") sub = col.column() - sub.active = con.use_maximum_y - sub.prop(con, "maximum_y", text="") + sub.active = con.use_max_y + sub.prop(con, "max_y", text="") col = split.column() - col.prop(con, "use_minimum_z") + col.prop(con, "use_min_z") sub = col.column() - sub.active = con.use_minimum_z - sub.prop(con, "minimum_z", text="") - col.prop(con, "use_maximum_z") + sub.active = con.use_min_z + sub.prop(con, "min_z", text="") + col.prop(con, "use_max_z") sub = col.column() - sub.active = con.use_maximum_z - sub.prop(con, "maximum_z", text="") + sub.active = con.use_max_z + sub.prop(con, "max_z", text="") row = layout.row() - row.prop(con, "limit_transform") + row.prop(con, "use_transform_limit") row.label() row = layout.row() @@ -318,37 +318,37 @@ class ConstraintButtonsPanel(): split = layout.split() col = split.column() - col.prop(con, "use_minimum_x") + col.prop(con, "use_min_x") sub = col.column() - sub.active = con.use_minimum_x - sub.prop(con, "minimum_x", text="") - col.prop(con, "use_maximum_x") + sub.active = con.use_min_x + sub.prop(con, "min_x", text="") + col.prop(con, "use_max_x") sub = col.column() - sub.active = con.use_maximum_x - sub.prop(con, "maximum_x", text="") + sub.active = con.use_max_x + sub.prop(con, "max_x", text="") col = split.column() - col.prop(con, "use_minimum_y") + col.prop(con, "use_min_y") sub = col.column() - sub.active = con.use_minimum_y - sub.prop(con, "minimum_y", text="") - col.prop(con, "use_maximum_y") + sub.active = con.use_min_y + sub.prop(con, "min_y", text="") + col.prop(con, "use_max_y") sub = col.column() - sub.active = con.use_maximum_y - sub.prop(con, "maximum_y", text="") + sub.active = con.use_max_y + sub.prop(con, "max_y", text="") col = split.column() - col.prop(con, "use_minimum_z") + col.prop(con, "use_min_z") sub = col.column() - sub.active = con.use_minimum_z - sub.prop(con, "minimum_z", text="") - col.prop(con, "use_maximum_z") + sub.active = con.use_min_z + sub.prop(con, "min_z", text="") + col.prop(con, "use_max_z") sub = col.column() - sub.active = con.use_maximum_z - sub.prop(con, "maximum_z", text="") + sub.active = con.use_max_z + sub.prop(con, "max_z", text="") row = layout.row() - row.prop(con, "limit_transform") + row.prop(con, "use_transform_limit") row.label() row = layout.row() @@ -454,8 +454,8 @@ class ConstraintButtonsPanel(): col = split.column(align=True) col.label(text="Target Range:") - col.prop(con, "minimum", text="Min") - col.prop(con, "maximum", text="Max") + col.prop(con, "min", text="Min") + col.prop(con, "max", text="Max") row = layout.row() row.label(text="Convert:") @@ -489,7 +489,7 @@ class ConstraintButtonsPanel(): split = layout.split() col = split.column() - col.prop(con, "original_length", text="Rest Length") + col.prop(con, "rest_length", text="Rest Length") col = split.column() col.operator("constraint.stretchto_reset", text="Reset") @@ -566,7 +566,7 @@ class ConstraintButtonsPanel(): def TRANSFORM(self, context, layout, con): self.target_template(layout, con) - layout.prop(con, "extrapolate_motion", text="Extrapolate") + layout.prop(con, "use_motion_extrapolate", text="Extrapolate") col = layout.column() col.row().label(text="Source:") @@ -647,14 +647,14 @@ class ConstraintButtonsPanel(): col = layout.column() col.label(text="Spline Fitting:") - col.prop(con, "chain_length") - col.prop(con, "even_divisions") - col.prop(con, "chain_offset") + col.prop(con, "chain_count") + col.prop(con, "use_even_divisions") + col.prop(con, "use_chain_offset") col = layout.column() col.label(text="Chain Scaling:") - col.prop(con, "y_stretch") - col.prop(con, "xz_scaling_mode") + col.prop(con, "use_y_stretch") + col.prop(con, "xz_scale_mode") col.prop(con, "use_curve_radius") def PIVOT(self, context, layout, con): @@ -665,14 +665,14 @@ class ConstraintButtonsPanel(): col.prop(con, "offset", text="Pivot Offset") else: col = layout.column() - col.prop(con, "use_relative_position") - if con.use_relative_position: + col.prop(con, "use_relative_location") + if con.use_relative_location: col.prop(con, "offset", text="Relative Pivot Point") else: col.prop(con, "offset", text="Absolute Pivot Point") col = layout.column() - col.prop(con, "enabled_rotation_range", text="Pivot When") + col.prop(con, "rotation_range", text="Pivot When") class OBJECT_PT_constraints(ConstraintButtonsPanel, bpy.types.Panel): bl_label = "Object Constraints" diff --git a/release/scripts/ui/properties_particle.py b/release/scripts/ui/properties_particle.py index 618d8e5486e..65070772d09 100644 --- a/release/scripts/ui/properties_particle.py +++ b/release/scripts/ui/properties_particle.py @@ -168,7 +168,7 @@ class PARTICLE_PT_emission(ParticleButtonsPanel, bpy.types.Panel): col = split.column(align=True) col.prop(part, "lifetime") - col.prop(part, "random_lifetime", slider=True) + col.prop(part, "lifetime_random", slider=True) layout.row().label(text="Emit From:") @@ -178,7 +178,7 @@ class PARTICLE_PT_emission(ParticleButtonsPanel, bpy.types.Panel): row = layout.row() row.prop(part, "trand") if part.distribution != 'GRID': - row.prop(part, "even_distribution") + row.prop(part, "use_even_distribution") if part.emit_from == 'FACE' or part.emit_from == 'VOLUME': row = layout.row() @@ -213,9 +213,9 @@ class PARTICLE_PT_hair_dynamics(ParticleButtonsPanel, bpy.types.Panel): #cloth = context.cloth.collision_settings #self.layout.active = cloth_panel_enabled(context.cloth) - #self.layout.prop(cloth, "enable_collision", text="") + #self.layout.prop(cloth, "use_collision", text="") psys = context.particle_system - self.layout.prop(psys, "hair_dynamics", text="") + self.layout.prop(psys, "use_hair_dynamics", text="") def draw(self, context): layout = self.layout @@ -228,7 +228,7 @@ class PARTICLE_PT_hair_dynamics(ParticleButtonsPanel, bpy.types.Panel): #part = psys.settings cloth = psys.cloth.settings - layout.enabled = psys.hair_dynamics + layout.enabled = psys.use_hair_dynamics split = layout.split() @@ -268,12 +268,12 @@ class PARTICLE_PT_cache(ParticleButtonsPanel, bpy.types.Panel): phystype = psys.settings.physics_type if phystype == 'NO' or phystype == 'KEYED': return False - return (psys.settings.type in ('EMITTER', 'REACTOR') or (psys.settings.type == 'HAIR' and psys.hair_dynamics)) and engine in cls.COMPAT_ENGINES + return (psys.settings.type in ('EMITTER', 'REACTOR') or (psys.settings.type == 'HAIR' and psys.use_hair_dynamics)) and engine in cls.COMPAT_ENGINES def draw(self, context): psys = context.particle_system - point_cache_ui(self, context, psys.point_cache, True, 'HAIR' if psys.hair_dynamics else 'PSYS') + point_cache_ui(self, context, psys.point_cache, True, 'HAIR' if psys.use_hair_dynamics else 'PSYS') class PARTICLE_PT_velocity(ParticleButtonsPanel, bpy.types.Panel): @@ -307,7 +307,7 @@ class PARTICLE_PT_velocity(ParticleButtonsPanel, bpy.types.Panel): sub = split.column() sub.label(text="Emitter Object") - sub.prop(part, "object_aligned_factor", text="") + sub.prop(part, "object_align_factor", text="") layout.row().label(text="Other:") split = layout.split() @@ -317,7 +317,7 @@ class PARTICLE_PT_velocity(ParticleButtonsPanel, bpy.types.Panel): else: sub.prop(part, "object_factor", slider=True) sub = split.column() - sub.prop(part, "random_factor") + sub.prop(part, "factor_random") #if part.type=='REACTOR': # sub.prop(part, "reactor_factor") @@ -346,16 +346,16 @@ class PARTICLE_PT_rotation(ParticleButtonsPanel, bpy.types.Panel): split = layout.split() split.label(text="Initial Rotation:") - split.prop(part, "rotation_dynamic") + split.prop(part, "use_dynamic_rotation") split = layout.split() sub = split.column(align=True) sub.prop(part, "rotation_mode", text="") - sub.prop(part, "random_rotation_factor", slider=True, text="Random") + sub.prop(part, "rotation_factor_random", slider=True, text="Random") sub = split.column(align=True) sub.prop(part, "phase_factor", slider=True) - sub.prop(part, "random_phase_factor", text="Random", slider=True) + sub.prop(part, "phase_factor_random", text="Random", slider=True) layout.row().label(text="Angular Velocity:") layout.row().prop(part, "angular_velocity_mode", expand=True) @@ -392,12 +392,12 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, bpy.types.Panel): row = layout.row() col = row.column(align=True) col.prop(part, "particle_size") - col.prop(part, "random_size", slider=True) + col.prop(part, "size_random", slider=True) if part.physics_type != 'NO': col = row.column(align=True) col.prop(part, "mass") - col.prop(part, "sizemass", text="Multiply mass with size") + col.prop(part, "use_multiply_size_mass", text="Multiply mass with size") if part.physics_type == 'NEWTON': split = layout.split() @@ -406,15 +406,15 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, bpy.types.Panel): sub.label(text="Forces:") sub.prop(part, "brownian_factor") sub.prop(part, "drag_factor", slider=True) - sub.prop(part, "damp_factor", slider=True) + sub.prop(part, "damping", slider=True) sub = split.column() sub.label(text="Integration:") sub.prop(part, "integrator", text="") sub.prop(part, "time_tweak") sub.prop(part, "subframes") sub = layout.row() - sub.prop(part, "size_deflect") - sub.prop(part, "die_on_collision") + sub.prop(part, "use_size_deflect") + sub.prop(part, "use_die_on_collision") elif part.physics_type == 'FLUID': fluid = part.fluid @@ -424,22 +424,22 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, bpy.types.Panel): sub.label(text="Forces:") sub.prop(part, "brownian_factor") sub.prop(part, "drag_factor", slider=True) - sub.prop(part, "damp_factor", slider=True) + sub.prop(part, "damping", slider=True) sub = split.column() sub.label(text="Integration:") sub.prop(part, "integrator", text="") sub.prop(part, "time_tweak") sub.prop(part, "subframes") sub = layout.row() - sub.prop(part, "size_deflect") - sub.prop(part, "die_on_collision") + sub.prop(part, "use_size_deflect") + sub.prop(part, "use_die_on_collision") split = layout.split() sub = split.column() sub.label(text="Fluid Interaction:") sub.prop(fluid, "fluid_radius", slider=True) - sub.prop(fluid, "stiffness_k") - sub.prop(fluid, "stiffness_knear") + sub.prop(fluid, "stiffness") + sub.prop(fluid, "stiffness_near") sub.prop(fluid, "rest_density") sub.label(text="Viscosity:") @@ -449,7 +449,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, bpy.types.Panel): sub = split.column() sub.label(text="Springs:") - sub.prop(fluid, "spring_k", text="Force", slider=True) + sub.prop(fluid, "spring_force", text="Force", slider=True) sub.prop(fluid, "rest_length", slider=True) layout.label(text="Multiple fluids interactions:") @@ -462,9 +462,9 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, bpy.types.Panel): row = layout.row() col = row.column() - col.active = not psys.keyed_timing + col.active = not psys.use_keyed_timing col.prop(part, "keyed_loops", text="Loops") - row.prop(psys, "keyed_timing", text="Use Timing") + row.prop(psys, "use_keyed_timing", text="Use Timing") layout.label(text="Keys:") elif part.physics_type == 'BOIDS': @@ -542,7 +542,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, bpy.types.Panel): col.prop(key, "object", text="") col.prop(key, "system", text="System") col = row.column() - col.active = psys.keyed_timing + col.active = psys.use_keyed_timing col.prop(key, "time") col.prop(key, "duration") elif part.physics_type == 'BOIDS': @@ -693,47 +693,47 @@ class PARTICLE_PT_render(ParticleButtonsPanel, bpy.types.Panel): sub.prop(part, "parent") sub = split.column() sub.prop(part, "show_unborn") - sub.prop(part, "died") + sub.prop(part, "use_dead") row = layout.row() - row.prop(part, "ren_as", expand=True) + row.prop(part, "render_type", expand=True) split = layout.split() sub = split.column() - if part.ren_as == 'LINE': + if part.render_type == 'LINE': sub.prop(part, "line_length_tail") sub.prop(part, "line_length_head") sub = split.column() - sub.prop(part, "velocity_length") - elif part.ren_as == 'PATH': - sub.prop(part, "render_strand") + sub.prop(part, "use_velocity_length") + elif part.render_type == 'PATH': + sub.prop(part, "use_strand_primitive") subsub = sub.column() - subsub.active = (part.render_strand is False) - subsub.prop(part, "render_adaptive") + subsub.active = (part.use_strand_primitive is False) + subsub.prop(part, "use_render_adaptive") subsub = sub.column() - subsub.active = part.render_adaptive or part.render_strand == True + subsub.active = part.render_adaptive or part.use_strand_primitive == True subsub.prop(part, "adaptive_angle") subsub = sub.column() - subsub.active = (part.render_adaptive is True and part.render_strand is False) - subsub.prop(part, "adaptive_pix") - sub.prop(part, "hair_bspline") + subsub.active = (part.render_adaptive is True and part.use_strand_primitive is False) + subsub.prop(part, "adaptive_pixel") + sub.prop(part, "use_hair_bspline") sub.prop(part, "render_step", text="Steps") sub = split.column() sub.label(text="Timing:") - sub.prop(part, "abs_path_time") - sub.prop(part, "path_start", text="Start", slider=not part.abs_path_time) - sub.prop(part, "path_end", text="End", slider=not part.abs_path_time) - sub.prop(part, "random_length", text="Random", slider=True) + sub.prop(part, "use_absolute_path_time") + sub.prop(part, "path_start", text="Start", slider=not part.use_absolute_path_time) + sub.prop(part, "path_end", text="End", slider=not part.use_absolute_path_time) + sub.prop(part, "length_random", text="Random", slider=True) row = layout.row() col = row.column() - if part.type == 'HAIR' and part.render_strand == True and part.child_type == 'FACES': - layout.prop(part, "enable_simplify") - if part.enable_simplify == True: + if part.type == 'HAIR' and part.use_strand_primitive == True and part.child_type == 'FACES': + layout.prop(part, "use_simplify") + if part.use_simplify == True: row = layout.row() row.prop(part, "simplify_refsize") row.prop(part, "simplify_rate") @@ -744,25 +744,25 @@ class PARTICLE_PT_render(ParticleButtonsPanel, bpy.types.Panel): sub.active = part.viewport == True sub.prop(part, "simplify_viewport") - elif part.ren_as == 'OBJECT': + elif part.render_type == 'OBJECT': sub.prop(part, "dupli_object") sub.prop(part, "use_global_dupli") - elif part.ren_as == 'GROUP': + elif part.render_type == 'GROUP': sub.prop(part, "dupli_group") split = layout.split() sub = split.column() - sub.prop(part, "whole_group") + sub.prop(part, "use_whole_group") subsub = sub.column() - subsub.active = (part.whole_group is False) + subsub.active = (part.use_whole_group is False) subsub.prop(part, "use_group_count") sub = split.column() subsub = sub.column() - subsub.active = (part.whole_group is False) + subsub.active = (part.use_whole_group is False) subsub.prop(part, "use_global_dupli") - subsub.prop(part, "rand_group") + subsub.prop(part, "use_group_pick_random") - if part.use_group_count and not part.whole_group: + if part.use_group_count and not part.use_whole_group: row = layout.row() row.template_list(part, "dupli_weights", part, "active_dupliweight_index") @@ -779,12 +779,12 @@ class PARTICLE_PT_render(ParticleButtonsPanel, bpy.types.Panel): row = layout.row() row.prop(weight, "count") - elif part.ren_as == 'BILLBOARD': + elif part.render_type == 'BILLBOARD': sub.label(text="Align:") row = layout.row() row.prop(part, "billboard_align", expand=True) - row.prop(part, "billboard_lock", text="Lock") + row.prop(part, "lock_billboard", text="Lock") row = layout.row() row.prop(part, "billboard_object") @@ -792,7 +792,7 @@ class PARTICLE_PT_render(ParticleButtonsPanel, bpy.types.Panel): col = row.column(align=True) col.label(text="Tilt:") col.prop(part, "billboard_tilt", text="Angle", slider=True) - col.prop(part, "billboard_random_tilt", slider=True) + col.prop(part, "billboard_tilt_random", slider=True) col = row.column() col.prop(part, "billboard_offset") @@ -810,17 +810,17 @@ class PARTICLE_PT_render(ParticleButtonsPanel, bpy.types.Panel): row.label(text="Animate:") row.prop(part, "billboard_animation", text="") row.label(text="Offset:") - row.prop(part, "billboard_split_offset", text="") + row.prop(part, "billboard_offset_split", text="") - if part.ren_as == 'HALO' or part.ren_as == 'LINE' or part.ren_as == 'BILLBOARD': + if part.render_type == 'HALO' or part.render_type == 'LINE' or part.render_type == 'BILLBOARD': row = layout.row() col = row.column() col.prop(part, "trail_count") if part.trail_count > 1: - col.prop(part, "abs_path_time", text="Length in frames") + col.prop(part, "use_absolute_path_time", text="Length in frames") col = row.column() - col.prop(part, "path_end", text="Length", slider=not part.abs_path_time) - col.prop(part, "random_length", text="Random", slider=True) + col.prop(part, "path_end", text="Length", slider=not part.use_absolute_path_time) + col.prop(part, "length_random", text="Random", slider=True) else: col = row.column() col.label(text="") @@ -848,16 +848,16 @@ class PARTICLE_PT_draw(ParticleButtonsPanel, bpy.types.Panel): part = psys.settings row = layout.row() - row.prop(part, "draw_as", expand=True) + row.prop(part, "draw_method", expand=True) - if part.draw_as == 'NONE' or (part.ren_as == 'NONE' and part.draw_as == 'RENDER'): + if part.draw_method == 'NONE' or (part.render_type == 'NONE' and part.draw_method == 'RENDER'): return - path = (part.ren_as == 'PATH' and part.draw_as == 'RENDER') or part.draw_as == 'PATH' + path = (part.render_type == 'PATH' and part.draw_method == 'RENDER') or part.draw_method == 'PATH' row = layout.row() row.prop(part, "display", slider=True) - if part.draw_as != 'RENDER' or part.ren_as == 'HALO': + if part.draw_method != 'RENDER' or part.render_type == 'HALO': row.prop(part, "draw_size") else: row.label(text="") @@ -906,7 +906,7 @@ class PARTICLE_PT_children(ParticleButtonsPanel, bpy.types.Panel): col = row.column(align=True) col.prop(part, "child_nbr", text="Display") - col.prop(part, "rendered_child_nbr", text="Render") + col.prop(part, "rendered_child_count", text="Render") col = row.column(align=True) @@ -918,7 +918,7 @@ class PARTICLE_PT_children(ParticleButtonsPanel, bpy.types.Panel): col = row.column(align=True) col.prop(part, "child_size", text="Size") - col.prop(part, "child_random_size", text="Random") + col.prop(part, "child_size_random", text="Random") layout.row().label(text="Effects:") @@ -926,27 +926,27 @@ class PARTICLE_PT_children(ParticleButtonsPanel, bpy.types.Panel): col = row.column(align=True) col.prop(part, "clump_factor", slider=True) - col.prop(part, "clumppow", slider=True) + col.prop(part, "clump_shape", slider=True) col = row.column(align=True) - col.prop(part, "rough_endpoint") - col.prop(part, "rough_end_shape") + col.prop(part, "roughness_endpoint") + col.prop(part, "roughness_end_shape") row = layout.row() col = row.column(align=True) - col.prop(part, "rough1") - col.prop(part, "rough1_size") + col.prop(part, "roughness_1") + col.prop(part, "roughness_1_size") col = row.column(align=True) - col.prop(part, "rough2") - col.prop(part, "rough2_size") - col.prop(part, "rough2_thres", slider=True) + col.prop(part, "roughness_2") + col.prop(part, "roughness_2_size") + col.prop(part, "roughness_2_threshold", slider=True) row = layout.row() col = row.column(align=True) col.prop(part, "child_length", slider=True) - col.prop(part, "child_length_thres", slider=True) + col.prop(part, "child_length_threshold", slider=True) col = row.column(align=True) col.label(text="Space reserved for") @@ -987,7 +987,7 @@ class PARTICLE_PT_force_fields(ParticleButtonsPanel, bpy.types.Panel): part = context.particle_system.settings - layout.prop(part, "self_effect") + layout.prop(part, "use_self_effect") split = layout.split(percentage=0.2) split.label(text="Type 1:") @@ -1026,51 +1026,51 @@ class PARTICLE_PT_vertexgroups(ParticleButtonsPanel, bpy.types.Panel): row = layout.row() row.prop_object(psys, "vertex_group_density", ob, "vertex_groups", text="Density") - row.prop(psys, "vertex_group_density_negate", text="") + row.prop(psys, "invert_vertex_group_density", text="") row = layout.row() row.prop_object(psys, "vertex_group_velocity", ob, "vertex_groups", text="Velocity") - row.prop(psys, "vertex_group_velocity_negate", text="") + row.prop(psys, "invert_vertex_group_velocity", text="") row = layout.row() row.prop_object(psys, "vertex_group_length", ob, "vertex_groups", text="Length") - row.prop(psys, "vertex_group_length_negate", text="") + row.prop(psys, "invert_vertex_group_length", text="") row = layout.row() row.prop_object(psys, "vertex_group_clump", ob, "vertex_groups", text="Clump") - row.prop(psys, "vertex_group_clump_negate", text="") + row.prop(psys, "invert_vertex_group_clump", text="") row = layout.row() row.prop_object(psys, "vertex_group_kink", ob, "vertex_groups", text="Kink") - row.prop(psys, "vertex_group_kink_negate", text="") + row.prop(psys, "invert_vertex_group_kink", text="") row = layout.row() - row.prop_object(psys, "vertex_group_roughness1", ob, "vertex_groups", text="Roughness 1") - row.prop(psys, "vertex_group_roughness1_negate", text="") + row.prop_object(psys, "vertex_group_roughness_1", ob, "vertex_groups", text="Roughness 1") + row.prop(psys, "invert_vertex_group_roughness_1", text="") row = layout.row() - row.prop_object(psys, "vertex_group_roughness2", ob, "vertex_groups", text="Roughness 2") - row.prop(psys, "vertex_group_roughness2_negate", text="") + row.prop_object(psys, "vertex_group_roughness_2", ob, "vertex_groups", text="Roughness 2") + row.prop(psys, "invert_vertex_group_roughness_2", text="") row = layout.row() row.prop_object(psys, "vertex_group_roughness_end", ob, "vertex_groups", text="Roughness End") - row.prop(psys, "vertex_group_roughness_end_negate", text="") + row.prop(psys, "invert_vertex_group_roughness_end", text="") row = layout.row() row.prop_object(psys, "vertex_group_size", ob, "vertex_groups", text="Size") - row.prop(psys, "vertex_group_size_negate", text="") + row.prop(psys, "invert_vertex_group_size", text="") row = layout.row() row.prop_object(psys, "vertex_group_tangent", ob, "vertex_groups", text="Tangent") - row.prop(psys, "vertex_group_tangent_negate", text="") + row.prop(psys, "invert_vertex_group_tangent", text="") row = layout.row() row.prop_object(psys, "vertex_group_rotation", ob, "vertex_groups", text="Rotation") - row.prop(psys, "vertex_group_rotation_negate", text="") + row.prop(psys, "invert_vertex_group_rotation", text="") row = layout.row() row.prop_object(psys, "vertex_group_field", ob, "vertex_groups", text="Field") - row.prop(psys, "vertex_group_field_negate", text="") + row.prop(psys, "invert_vertex_group_field", text="") class PARTICLE_PT_custom_props(ParticleButtonsPanel, PropertyPanel, bpy.types.Panel): diff --git a/release/scripts/ui/properties_physics_cloth.py b/release/scripts/ui/properties_physics_cloth.py index 8a770066b0b..30619de5814 100644 --- a/release/scripts/ui/properties_physics_cloth.py +++ b/release/scripts/ui/properties_physics_cloth.py @@ -102,9 +102,9 @@ class PHYSICS_PT_cloth(PhysicButtonsPanel, bpy.types.Panel): col.prop(cloth, "spring_damping", text="Spring") col.prop(cloth, "air_damping", text="Air") - col.prop(cloth, "pin_cloth", text="Pinning") + col.prop(cloth, "use_pin_cloth", text="Pinning") sub = col.column() - sub.active = cloth.pin_cloth + sub.active = cloth.use_pin_cloth sub.prop_object(cloth, "mass_vertex_group", ob, "vertex_groups", text="") sub.prop(cloth, "pin_stiffness", text="Stiffness") @@ -154,7 +154,7 @@ class PHYSICS_PT_cloth_collision(PhysicButtonsPanel, bpy.types.Panel): cloth = context.cloth.collision_settings self.layout.active = cloth_panel_enabled(context.cloth) - self.layout.prop(cloth, "enable_collision", text="") + self.layout.prop(cloth, "use_collision", text="") def draw(self, context): layout = self.layout @@ -162,21 +162,21 @@ class PHYSICS_PT_cloth_collision(PhysicButtonsPanel, bpy.types.Panel): cloth = context.cloth.collision_settings md = context.cloth - layout.active = cloth.enable_collision and cloth_panel_enabled(md) + layout.active = cloth.use_collision and cloth_panel_enabled(md) split = layout.split() col = split.column() col.prop(cloth, "collision_quality", slider=True, text="Quality") - col.prop(cloth, "min_distance", slider=True, text="Distance") + col.prop(cloth, "distance_min", slider=True, text="Distance") col.prop(cloth, "friction") col = split.column() - col.prop(cloth, "enable_self_collision", text="Self Collision") + col.prop(cloth, "use_self_collision", text="Self Collision") sub = col.column() - sub.active = cloth.enable_self_collision + sub.active = cloth.use_self_collision sub.prop(cloth, "self_collision_quality", slider=True, text="Quality") - sub.prop(cloth, "self_min_distance", slider=True, text="Distance") + sub.prop(cloth, "self_distance_min", slider=True, text="Distance") layout.prop(cloth, "group") @@ -193,7 +193,7 @@ class PHYSICS_PT_cloth_stiffness(PhysicButtonsPanel, bpy.types.Panel): cloth = context.cloth.settings self.layout.active = cloth_panel_enabled(context.cloth) - self.layout.prop(cloth, "stiffness_scaling", text="") + self.layout.prop(cloth, "use_stiffness_scale", text="") def draw(self, context): layout = self.layout @@ -202,7 +202,7 @@ class PHYSICS_PT_cloth_stiffness(PhysicButtonsPanel, bpy.types.Panel): ob = context.object cloth = context.cloth.settings - layout.active = cloth.stiffness_scaling and cloth_panel_enabled(md) + layout.active = cloth.use_stiffness_scale and cloth_panel_enabled(md) split = layout.split() diff --git a/release/scripts/ui/properties_physics_common.py b/release/scripts/ui/properties_physics_common.py index b4f54e687f3..fb9f2f981ae 100644 --- a/release/scripts/ui/properties_physics_common.py +++ b/release/scripts/ui/properties_physics_common.py @@ -172,20 +172,20 @@ def basic_force_field_settings_ui(self, context, field): col.prop(field, "noise") col.prop(field, "seed") if field.type == 'TURBULENCE': - col.prop(field, "global_coordinates", text="Global") + col.prop(field, "use_global_coords", text="Global") elif field.type == 'HARMONIC': - col.prop(field, "multiple_springs") + col.prop(field, "use_multiple_springs") split = layout.split() col = split.column() col.label(text="Effect point:") - col.prop(field, "do_location") - col.prop(field, "do_rotation") + col.prop(field, "apply_to_location") + col.prop(field, "apply_to_rotation") col = split.column() col.label(text="Collision:") - col.prop(field, "do_absorption") + col.prop(field, "use_absorption") def basic_force_field_falloff_ui(self, context, field): @@ -209,11 +209,11 @@ def basic_force_field_falloff_ui(self, context, field): sub = col.column() sub.active = field.use_min_distance - sub.prop(field, "minimum_distance", text="Distance") + sub.prop(field, "distance_min", text="Distance") sub = col.column() sub.active = field.use_max_distance - sub.prop(field, "maximum_distance", text="Distance") + sub.prop(field, "distance_max", text="Distance") def register(): diff --git a/release/scripts/ui/properties_physics_field.py b/release/scripts/ui/properties_physics_field.py index e09734b9980..80ea999eedb 100644 --- a/release/scripts/ui/properties_physics_field.py +++ b/release/scripts/ui/properties_physics_field.py @@ -63,7 +63,7 @@ class PHYSICS_PT_field(PhysicButtonsPanel, bpy.types.Panel): col.prop(field, "guide_minimum") col.prop(field, "guide_free") col.prop(field, "falloff_power") - col.prop(field, "guide_path_add") + col.prop(field, "use_guide_path_add") col.prop(field, "use_guide_path_weight") col = split.column() @@ -75,7 +75,7 @@ class PHYSICS_PT_field(PhysicButtonsPanel, bpy.types.Panel): row.prop(field, "use_max_distance") sub = row.row() sub.active = field.use_max_distance - sub.prop(field, "maximum_distance") + sub.prop(field, "distance_max") layout.separator() @@ -100,9 +100,9 @@ class PHYSICS_PT_field(PhysicButtonsPanel, bpy.types.Panel): col.prop(field, "texture_nabla") col = split.column() - col.prop(field, "use_coordinates") - col.prop(field, "root_coordinates") - col.prop(field, "force_2d") + col.prop(field, "use_object_coords") + col.prop(field, "use_root_coords") + col.prop(field, "use_2d_force") else: basic_force_field_settings_ui(self, context, field) @@ -128,11 +128,11 @@ class PHYSICS_PT_field(PhysicButtonsPanel, bpy.types.Panel): sub = col.column() sub.active = field.use_radial_min - sub.prop(field, "radial_minimum", text="Angle") + sub.prop(field, "radial_min", text="Angle") sub = col.column() sub.active = field.use_radial_max - sub.prop(field, "radial_maximum", text="Angle") + sub.prop(field, "radial_max", text="Angle") elif field.falloff_type == 'TUBE': layout.separator() @@ -149,11 +149,11 @@ class PHYSICS_PT_field(PhysicButtonsPanel, bpy.types.Panel): sub = col.column() sub.active = field.use_radial_min - sub.prop(field, "radial_minimum", text="Distance") + sub.prop(field, "radial_min", text="Distance") sub = col.column() sub.active = field.use_radial_max - sub.prop(field, "radial_maximum", text="Distance") + sub.prop(field, "radial_max", text="Distance") class PHYSICS_PT_collision(PhysicButtonsPanel, bpy.types.Panel): @@ -203,22 +203,22 @@ class PHYSICS_PT_collision(PhysicButtonsPanel, bpy.types.Panel): col.label(text="Particle:") col.prop(settings, "permeability", slider=True) col.prop(settings, "stickness") - col.prop(settings, "kill_particles") + col.prop(settings, "use_particle_kill") col.label(text="Particle Damping:") sub = col.column(align=True) sub.prop(settings, "damping_factor", text="Factor", slider=True) - sub.prop(settings, "random_damping", text="Random", slider=True) + sub.prop(settings, "damping_random", text="Random", slider=True) col.label(text="Particle Friction:") sub = col.column(align=True) sub.prop(settings, "friction_factor", text="Factor", slider=True) - sub.prop(settings, "random_friction", text="Random", slider=True) + sub.prop(settings, "friction_random", text="Random", slider=True) col = split.column() col.label(text="Soft Body and Cloth:") sub = col.column(align=True) - sub.prop(settings, "outer_thickness", text="Outer", slider=True) - sub.prop(settings, "inner_thickness", text="Inner", slider=True) + sub.prop(settings, "thickness_outer", text="Outer", slider=True) + sub.prop(settings, "thickness_inner", text="Inner", slider=True) col.label(text="Soft Body Damping:") col.prop(settings, "damping", text="Factor", slider=True) diff --git a/release/scripts/ui/properties_physics_fluid.py b/release/scripts/ui/properties_physics_fluid.py index 35934ebfb32..035eefe6c2a 100644 --- a/release/scripts/ui/properties_physics_fluid.py +++ b/release/scripts/ui/properties_physics_fluid.py @@ -97,8 +97,8 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label() - col.prop(fluid, "generate_speed_vectors") - col.prop(fluid, "reverse_frames") + col.prop(fluid, "use_speed_vectors") + col.prop(fluid, "use_reverse_frames") layout.prop(fluid, "filepath", text="") @@ -108,7 +108,7 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Volume Initialization:") col.prop(fluid, "volume_initialization", text="") - col.prop(fluid, "export_animated_mesh") + col.prop(fluid, "use_animated_mesh") col = split.column() col.label(text="Initial Velocity:") @@ -120,7 +120,7 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Volume Initialization:") col.prop(fluid, "volume_initialization", text="") - col.prop(fluid, "export_animated_mesh") + col.prop(fluid, "use_animated_mesh") col = split.column() col.label(text="Slip Type:") @@ -137,8 +137,8 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Volume Initialization:") col.prop(fluid, "volume_initialization", text="") - col.prop(fluid, "export_animated_mesh") - col.prop(fluid, "local_coordinates") + col.prop(fluid, "use_animated_mesh") + col.prop(fluid, "use_local_coords") col = split.column() col.label(text="Inflow Velocity:") @@ -150,7 +150,7 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Volume Initialization:") col.prop(fluid, "volume_initialization", text="") - col.prop(fluid, "export_animated_mesh") + col.prop(fluid, "use_animated_mesh") split.column() @@ -164,8 +164,8 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Type:") - col.prop(fluid, "drops") - col.prop(fluid, "floats") + col.prop(fluid, "use_drops") + col.prop(fluid, "use_floats") col.prop(fluid, "show_tracer") layout.prop(fluid, "filepath", text="") @@ -176,7 +176,7 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="") col.prop(fluid, "quality", slider=True) - col.prop(fluid, "reverse_frames") + col.prop(fluid, "use_reverse_frames") col = split.column() col.label(text="Time:") @@ -230,10 +230,10 @@ class PHYSICS_PT_domain_gravity(PhysicButtonsPanel, bpy.types.Panel): col.label(text="Using Scene Size Units", icon="SCENE_DATA") sub = col.column() sub.enabled = False - sub.prop(fluid, "real_world_size", text="Metres") + sub.prop(fluid, "simulation_scale", text="Metres") else: col.label(text="Real World Size:") - col.prop(fluid, "real_world_size", text="Metres") + col.prop(fluid, "simulation_scale", text="Metres") col = split.column() col.label(text="Viscosity Presets:") @@ -273,7 +273,7 @@ class PHYSICS_PT_domain_boundary(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Surface:") - col.prop(fluid, "surface_smoothing", text="Smoothing") + col.prop(fluid, "surface_smooth", text="Smoothing") col.prop(fluid, "surface_subdivisions", text="Subdivisions") diff --git a/release/scripts/ui/properties_physics_smoke.py b/release/scripts/ui/properties_physics_smoke.py index 263832b3a3c..f924c1df301 100644 --- a/release/scripts/ui/properties_physics_smoke.py +++ b/release/scripts/ui/properties_physics_smoke.py @@ -71,22 +71,22 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, bpy.types.Panel): col = split.column() col.label(text="Resolution:") - col.prop(domain, "maxres", text="Divisions") + col.prop(domain, "resolution_max", text="Divisions") col.label(text="Time:") col.prop(domain, "time_scale", text="Scale") col.label(text="Border Collisions:") - col.prop(domain, "smoke_domain_colli", text="") + col.prop(domain, "collision_extents", text="") col = split.column() col.label(text="Behavior:") col.prop(domain, "alpha") col.prop(domain, "beta") col.prop(domain, "vorticity") - col.prop(domain, "dissolve_smoke", text="Dissolve") + col.prop(domain, "use_dissolve_smoke", text="Dissolve") sub = col.column() - sub.active = domain.dissolve_smoke + sub.active = domain.use_dissolve_smoke sub.prop(domain, "dissolve_speed", text="Time") - sub.prop(domain, "dissolve_smoke_log", text="Slow") + sub.prop(domain, "use_dissolve_smoke_log", text="Slow") elif md.smoke_type == 'FLOW': @@ -163,7 +163,7 @@ class PHYSICS_PT_smoke_cache(PhysicButtonsPanel, bpy.types.Panel): cache = md.point_cache_low layout.label(text="Compression:") - layout.prop(md, "smoke_cache_comp", expand=True) + layout.prop(md, "point_cache_compress_type", expand=True) point_cache_ui(self, context, cache, (cache.is_baked is False), 'SMOKE') @@ -180,21 +180,21 @@ class PHYSICS_PT_smoke_highres(PhysicButtonsPanel, bpy.types.Panel): def draw_header(self, context): md = context.smoke.domain_settings - self.layout.prop(md, "highres", text="") + self.layout.prop(md, "use_high_resolution", text="") def draw(self, context): layout = self.layout md = context.smoke.domain_settings - layout.active = md.highres + layout.active = md.use_high_resolution split = layout.split() col = split.column() col.label(text="Resolution:") col.prop(md, "amplify", text="Divisions") - col.prop(md, "smoothemitter") + col.prop(md, "smooth_emitter") col.prop(md, "show_high_resolution") col = split.column() @@ -210,7 +210,7 @@ class PHYSICS_PT_smoke_cache_highres(PhysicButtonsPanel, bpy.types.Panel): @classmethod def poll(cls, context): md = context.smoke - return md and (md.smoke_type == 'DOMAIN') and md.domain_settings.highres + return md and (md.smoke_type == 'DOMAIN') and md.domain_settings.use_high_resolution def draw(self, context): layout = self.layout @@ -219,7 +219,7 @@ class PHYSICS_PT_smoke_cache_highres(PhysicButtonsPanel, bpy.types.Panel): cache = md.point_cache_high layout.label(text="Compression:") - layout.prop(md, "smoke_cache_high_comp", expand=True) + layout.prop(md, "point_cache_compress_high_type", expand=True) point_cache_ui(self, context, cache, (cache.is_baked is False), 'SMOKE') diff --git a/release/scripts/ui/properties_physics_softbody.py b/release/scripts/ui/properties_physics_softbody.py index b377f0b6027..865003531db 100644 --- a/release/scripts/ui/properties_physics_softbody.py +++ b/release/scripts/ui/properties_physics_softbody.py @@ -171,14 +171,14 @@ class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, bpy.types.Panel): col.prop(softbody, "push") col.prop(softbody, "damp") col.prop(softbody, "plastic") - col.prop(softbody, "bending") + col.prop(softbody, "bend") col.prop(softbody, "spring_length", text="Length") col.prop_object(softbody, "spring_vertex_group", ob, "vertex_groups", text="Springs:") col = split.column() - col.prop(softbody, "stiff_quads") + col.prop(softbody, "use_stiff_quads") sub = col.column() - sub.active = softbody.stiff_quads + sub.active = softbody.use_stiff_quads sub.prop(softbody, "shear") col.label(text="Aerodynamics:") @@ -190,8 +190,8 @@ class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, bpy.types.Panel): col.label(text="Collision:") - col.prop(softbody, "edge_collision", text="Edge") - col.prop(softbody, "face_collision", text="Face") + col.prop(softbody, "use_edge_collision", text="Edge") + col.prop(softbody, "use_face_collision", text="Face") class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, bpy.types.Panel): @@ -206,7 +206,7 @@ class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, bpy.types.Panel): softbody = context.soft_body.settings self.layout.active = softbody_panel_enabled(context.soft_body) - self.layout.prop(softbody, "self_collision", text="") + self.layout.prop(softbody, "use_self_collision", text="") def draw(self, context): layout = self.layout @@ -214,7 +214,7 @@ class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, bpy.types.Panel): md = context.soft_body softbody = md.settings - layout.active = softbody.self_collision and softbody_panel_enabled(md) + layout.active = softbody.use_self_collision and softbody_panel_enabled(md) layout.label(text="Collision Ball Size Calculation:") layout.prop(softbody, "collision_type", expand=True) @@ -247,19 +247,19 @@ class PHYSICS_PT_softbody_solver(PhysicButtonsPanel, bpy.types.Panel): col = split.column(align=True) col.label(text="Step Size:") - col.prop(softbody, "minstep") - col.prop(softbody, "maxstep") + col.prop(softbody, "step_min") + col.prop(softbody, "step_max") col.prop(softbody, "use_auto_step", text="Auto-Step") col = split.column() - col.prop(softbody, "error_limit") + col.prop(softbody, "error_threshold") col.label(text="Helpers:") col.prop(softbody, "choke") col.prop(softbody, "fuzzy") layout.label(text="Diagnostics:") - layout.prop(softbody, "diagnose") - layout.prop(softbody, "estimate_matrix") + layout.prop(softbody, "use_diagnose") + layout.prop(softbody, "use_estimate_matrix") class PHYSICS_PT_softbody_field_weights(PhysicButtonsPanel, bpy.types.Panel): diff --git a/release/scripts/ui/properties_render.py b/release/scripts/ui/properties_render.py index a0e284ab1f3..2072aa00b76 100644 --- a/release/scripts/ui/properties_render.py +++ b/release/scripts/ui/properties_render.py @@ -320,7 +320,7 @@ class RENDER_PT_output(RenderButtonsPanel, bpy.types.Panel): subsplit = split.split() col = subsplit.column() - col.prop(rd, "exr_half") + col.prop(rd, "use_exr_half") col.prop(rd, "exr_zbuf") col = subsplit.column() diff --git a/release/scripts/ui/properties_texture.py b/release/scripts/ui/properties_texture.py index 9f759e24f53..7996e162b8e 100644 --- a/release/scripts/ui/properties_texture.py +++ b/release/scripts/ui/properties_texture.py @@ -228,9 +228,9 @@ class TEXTURE_PT_mapping(TextureSlotPanel, bpy.types.Panel): col = split.column() col.label(text="Coordinates:") col = split.column() - col.prop(tex, "texture_coordinates", text="") + col.prop(tex, "texture_coords", text="") - if tex.texture_coordinates == 'ORCO': + if tex.texture_coords == 'ORCO': """ ob = context.object if ob and ob.type == 'MESH': @@ -238,7 +238,7 @@ class TEXTURE_PT_mapping(TextureSlotPanel, bpy.types.Panel): split.label(text="Mesh:") split.prop(ob.data, "texco_mesh", text="") """ - elif tex.texture_coordinates == 'UV': + elif tex.texture_coords == 'UV': split = layout.split(percentage=0.3) split.label(text="Layer:") ob = context.object @@ -247,7 +247,7 @@ class TEXTURE_PT_mapping(TextureSlotPanel, bpy.types.Panel): else: split.prop(tex, "uv_layer", text="") - elif tex.texture_coordinates == 'OBJECT': + elif tex.texture_coords == 'OBJECT': split = layout.split(percentage=0.3) split.label(text="Object:") split.prop(tex, "object", text="") @@ -269,18 +269,18 @@ class TEXTURE_PT_mapping(TextureSlotPanel, bpy.types.Panel): split = layout.split() col = split.column() - if tex.texture_coordinates in ('ORCO', 'UV'): - col.prop(tex, "from_dupli") - elif tex.texture_coordinates == 'OBJECT': - col.prop(tex, "from_original") + if tex.texture_coords in ('ORCO', 'UV'): + col.prop(tex, "use_from_dupli") + elif tex.texture_coords == 'OBJECT': + col.prop(tex, "use_from_original") else: col.label() col = split.column() row = col.row() - row.prop(tex, "x_mapping", text="") - row.prop(tex, "y_mapping", text="") - row.prop(tex, "z_mapping", text="") + row.prop(tex, "mapping_x", text="") + row.prop(tex, "mapping_y", text="") + row.prop(tex, "mapping_z", text="") split = layout.split() @@ -330,66 +330,66 @@ class TEXTURE_PT_influence(TextureSlotPanel, bpy.types.Panel): col = split.column() col.label(text="Diffuse:") - factor_but(col, tex.map_diffuse, "map_diffuse", "diffuse_factor", "Intensity") - factor_but(col, tex.map_colordiff, "map_colordiff", "colordiff_factor", "Color") - factor_but(col, tex.map_alpha, "map_alpha", "alpha_factor", "Alpha") - factor_but(col, tex.map_translucency, "map_translucency", "translucency_factor", "Translucency") + factor_but(col, tex.use_map_diffuse, "use_map_diffuse", "diffuse_factor", "Intensity") + factor_but(col, tex.use_map_color_diff, "use_map_color_diff", "diffuse_color_factor", "Color") + factor_but(col, tex.use_map_alpha, "use_map_alpha", "alpha_factor", "Alpha") + factor_but(col, tex.use_map_translucency, "use_map_translucency", "translucency_factor", "Translucency") col.label(text="Specular:") - factor_but(col, tex.map_specular, "map_specular", "specular_factor", "Intensity") - factor_but(col, tex.map_colorspec, "map_colorspec", "colorspec_factor", "Color") - factor_but(col, tex.map_hardness, "map_hardness", "hardness_factor", "Hardness") + factor_but(col, tex.use_map_specular, "use_map_specular", "specular_factor", "Intensity") + factor_but(col, tex.use_map_color_spec, "use_map_color_spec", "specular_color_factor", "Color") + factor_but(col, tex.use_map_hardness, "use_map_hardness", "hardness_factor", "Hardness") col = split.column() col.label(text="Shading:") - factor_but(col, tex.map_ambient, "map_ambient", "ambient_factor", "Ambient") - factor_but(col, tex.map_emit, "map_emit", "emit_factor", "Emit") - factor_but(col, tex.map_mirror, "map_mirror", "mirror_factor", "Mirror") - factor_but(col, tex.map_raymir, "map_raymir", "raymir_factor", "Ray Mirror") + factor_but(col, tex.use_map_ambient, "use_map_ambient", "ambient_factor", "Ambient") + factor_but(col, tex.use_map_emit, "use_map_emit", "emit_factor", "Emit") + factor_but(col, tex.use_map_mirror, "use_map_mirror", "mirror_factor", "Mirror") + factor_but(col, tex.use_map_raymir, "use_map_raymir", "raymir_factor", "Ray Mirror") col.label(text="Geometry:") # XXX replace 'or' when displacement is fixed to not rely on normal influence value. - factor_but(col, (tex.map_normal or tex.map_displacement), "map_normal", "normal_factor", "Normal") - factor_but(col, tex.map_warp, "map_warp", "warp_factor", "Warp") - factor_but(col, tex.map_displacement, "map_displacement", "displacement_factor", "Displace") + factor_but(col, (tex.use_map_normal or tex.use_map_displacement), "use_map_normal", "normal_factor", "Normal") + factor_but(col, tex.use_map_warp, "use_map_warp", "warp_factor", "Warp") + factor_but(col, tex.use_map_displacement, "use_map_displacement", "displacement_factor", "Displace") #sub = col.column() - #sub.active = tex.map_translucency or tex.map_emit or tex.map_alpha or tex.map_raymir or tex.map_hardness or tex.map_ambient or tex.map_specularity or tex.map_reflection or tex.map_mirror + #sub.active = tex.use_map_translucency or tex.map_emit or tex.map_alpha or tex.map_raymir or tex.map_hardness or tex.map_ambient or tex.map_specularity or tex.map_reflection or tex.map_mirror #sub.prop(tex, "default_value", text="Amount", slider=True) elif idblock.type == 'VOLUME': split = layout.split() col = split.column() - factor_but(col, tex.map_density, "map_density", "density_factor", "Density") - factor_but(col, tex.map_emission, "map_emission", "emission_factor", "Emission") - factor_but(col, tex.map_scattering, "map_scattering", "scattering_factor", "Scattering") - factor_but(col, tex.map_reflection, "map_reflection", "reflection_factor", "Reflection") + factor_but(col, tex.use_map_density, "use_map_density", "density_factor", "Density") + factor_but(col, tex.use_map_emission, "use_map_emission", "emission_factor", "Emission") + factor_but(col, tex.use_map_scatter, "use_map_scattering", "scattering_factor", "Scattering") + factor_but(col, tex.use_map_reflect, "use_map_reflection", "reflection_factor", "Reflection") col = split.column() col.label(text=" ") - factor_but(col, tex.map_coloremission, "map_coloremission", "coloremission_factor", "Emission Color") - factor_but(col, tex.map_colortransmission, "map_colortransmission", "colortransmission_factor", "Transmission Color") - factor_but(col, tex.map_colorreflection, "map_colorreflection", "colorreflection_factor", "Reflection Color") + factor_but(col, tex.use_map_color_emission, "use_map_color_emission", "emission_color_factor", "Emission Color") + factor_but(col, tex.use_map_color_transmission, "use_map_color_transmission", "transmission_color_factor", "Transmission Color") + factor_but(col, tex.use_map_color_reflection, "use_map_color_reflection", "reflection_color_factor", "Reflection Color") elif type(idblock) == bpy.types.Lamp: split = layout.split() col = split.column() - factor_but(col, tex.map_color, "map_color", "color_factor", "Color") + factor_but(col, tex.use_map_color, "map_color", "color_factor", "Color") col = split.column() - factor_but(col, tex.map_shadow, "map_shadow", "shadow_factor", "Shadow") + factor_but(col, tex.use_map_shadow, "map_shadow", "shadow_factor", "Shadow") elif type(idblock) == bpy.types.World: split = layout.split() col = split.column() - factor_but(col, tex.map_blend, "map_blend", "blend_factor", "Blend") - factor_but(col, tex.map_horizon, "map_horizon", "horizon_factor", "Horizon") + factor_but(col, tex.use_map_blend, "map_blend", "blend_factor", "Blend") + factor_but(col, tex.use_map_horizon, "map_horizon", "horizon_factor", "Horizon") col = split.column() - factor_but(col, tex.map_zenith_up, "map_zenith_up", "zenith_up_factor", "Zenith Up") - factor_but(col, tex.map_zenith_down, "map_zenith_down", "zenith_down_factor", "Zenith Down") + factor_but(col, tex.use_map_zenith_up, "map_zenith_up", "zenith_up_factor", "Zenith Up") + factor_but(col, tex.use_map_zenith_down, "map_zenith_down", "zenith_down_factor", "Zenith Down") layout.separator() @@ -397,14 +397,14 @@ class TEXTURE_PT_influence(TextureSlotPanel, bpy.types.Panel): col = split.column() col.prop(tex, "blend_type", text="Blend") - col.prop(tex, "rgb_to_intensity") + col.prop(tex, "use_rgb_to_intensity") sub = col.column() - sub.active = tex.rgb_to_intensity + sub.active = tex.use_rgb_to_intensity sub.prop(tex, "color", text="") col = split.column() col.prop(tex, "negate", text="Negative") - col.prop(tex, "stencil") + col.prop(tex, "use_stencil") if type(idblock) in (bpy.types.Material, bpy.types.World): col.prop(tex, "default_value", text="DVar", slider=True) @@ -439,7 +439,7 @@ class TEXTURE_PT_clouds(TextureTypePanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(tex, "noise_size", text="Size") + col.prop(tex, "noise_scale", text="Size") col.prop(tex, "noise_depth", text="Depth") col = split.column() @@ -456,7 +456,7 @@ class TEXTURE_PT_wood(TextureTypePanel, bpy.types.Panel): tex = context.texture - layout.prop(tex, "noisebasis2", expand=True) + layout.prop(tex, "noisebasis_2", expand=True) layout.prop(tex, "stype", expand=True) col = layout.column() @@ -469,7 +469,7 @@ class TEXTURE_PT_wood(TextureTypePanel, bpy.types.Panel): split.active = tex.stype in ('RINGNOISE', 'BANDNOISE') col = split.column() - col.prop(tex, "noise_size", text="Size") + col.prop(tex, "noise_scale", text="Size") col.prop(tex, "turbulence") col = split.column() @@ -487,7 +487,7 @@ class TEXTURE_PT_marble(TextureTypePanel, bpy.types.Panel): tex = context.texture layout.prop(tex, "stype", expand=True) - layout.prop(tex, "noisebasis2", expand=True) + layout.prop(tex, "noisebasis_2", expand=True) layout.label(text="Noise:") layout.prop(tex, "noise_type", text="Type", expand=True) layout.prop(tex, "noise_basis", text="Basis") @@ -495,7 +495,7 @@ class TEXTURE_PT_marble(TextureTypePanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(tex, "noise_size", text="Size") + col.prop(tex, "noise_scale", text="Size") col.prop(tex, "noise_depth", text="Depth") col = split.column() @@ -537,7 +537,7 @@ class TEXTURE_PT_blend(TextureTypePanel, bpy.types.Panel): sub = layout.row() sub.active = (tex.progression in ('LINEAR', 'QUADRATIC', 'EASING', 'RADIAL')) - sub.prop(tex, "flip_axis", expand=True) + sub.prop(tex, "use_flip_axis", expand=True) class TEXTURE_PT_stucci(TextureTypePanel, bpy.types.Panel): @@ -558,7 +558,7 @@ class TEXTURE_PT_stucci(TextureTypePanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(tex, "noise_size", text="Size") + col.prop(tex, "noise_scale", text="Size") col = split.column() col.prop(tex, "turbulence") @@ -587,7 +587,7 @@ def texture_filter_common(tex, layout): layout.prop(tex, "filter_eccentricity", text="Eccentricity") layout.prop(tex, "filter_size") - layout.prop(tex, "filter_size_minimum") + layout.prop(tex, "use_filter_size_min") class TEXTURE_PT_image_sampling(TextureTypePanel, bpy.types.Panel): @@ -607,22 +607,22 @@ class TEXTURE_PT_image_sampling(TextureTypePanel, bpy.types.Panel): col = split.column() col.label(text="Alpha:") col.prop(tex, "use_alpha", text="Use") - col.prop(tex, "calculate_alpha", text="Calculate") + col.prop(tex, "use_calculate_alpha", text="Calculate") col.prop(tex, "invert_alpha", text="Invert") col.separator() - col.prop(tex, "flip_axis", text="Flip X/Y Axis") + col.prop(tex, "use_flip_axis", text="Flip X/Y Axis") col = split.column() - col.prop(tex, "normal_map") + col.prop(tex, "use_normal_map") row = col.row() - row.active = tex.normal_map + row.active = tex.use_normal_map row.prop(tex, "normal_space", text="") col.prop(tex, "mipmap") row = col.row() row.active = tex.mipmap - row.prop(tex, "mipmap_gauss") + row.prop(tex, "use_mipmap_gauss") col.prop(tex, "interpolation") texture_filter_common(tex, col) @@ -651,15 +651,15 @@ class TEXTURE_PT_image_mapping(TextureTypePanel, bpy.types.Panel): col = split.column(align=True) col.label(text="Mirror:") - col.prop(tex, "mirror_x", text="X") - col.prop(tex, "mirror_y", text="Y") + col.prop(tex, "use_mirror_x", text="X") + col.prop(tex, "use_mirror_y", text="Y") layout.separator() elif tex.extension == 'CHECKER': col = split.column(align=True) row = col.row() - row.prop(tex, "checker_even", text="Even") - row.prop(tex, "checker_odd", text="Odd") + row.prop(tex, "use_checker_even", text="Even") + row.prop(tex, "use_checker_odd", text="Odd") col = split.column() col.prop(tex, "checker_distance", text="Distance") @@ -748,7 +748,7 @@ class TEXTURE_PT_musgrave(TextureTypePanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(tex, "highest_dimension", text="Dimension") + col.prop(tex, "dimension_max", text="Dimension") col.prop(tex, "lacunarity") col.prop(tex, "octaves") @@ -766,7 +766,7 @@ class TEXTURE_PT_musgrave(TextureTypePanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(tex, "noise_size", text="Size") + col.prop(tex, "noise_scale", text="Size") col = split.column() col.prop(tex, "nabla") @@ -791,7 +791,7 @@ class TEXTURE_PT_voronoi(TextureTypePanel, bpy.types.Panel): sub.active = tex.distance_metric == 'MINKOVSKY' sub.prop(tex, "minkovsky_exponent", text="Exponent") col.label(text="Coloring:") - col.prop(tex, "coloring", text="") + col.prop(tex, "color_mode", text="") col.prop(tex, "noise_intensity", text="Intensity") col = split.column() @@ -807,7 +807,7 @@ class TEXTURE_PT_voronoi(TextureTypePanel, bpy.types.Panel): split = layout.split() col = split.column() - col.prop(tex, "noise_size", text="Size") + col.prop(tex, "noise_scale", text="Size") col = split.column() col.prop(tex, "nabla") @@ -830,7 +830,7 @@ class TEXTURE_PT_distortednoise(TextureTypePanel, bpy.types.Panel): col = split.column() col.prop(tex, "distortion", text="Distortion") - col.prop(tex, "noise_size", text="Size") + col.prop(tex, "noise_scale", text="Size") col = split.column() col.prop(tex, "nabla") @@ -854,7 +854,7 @@ class TEXTURE_PT_voxeldata(TextureButtonsPanel, bpy.types.Panel): layout.prop(vd, "file_format") if vd.file_format in ('BLENDER_VOXEL', 'RAW_8BIT'): - layout.prop(vd, "source_path") + layout.prop(vd, "filepath") if vd.file_format == 'RAW_8BIT': layout.prop(vd, "resolution") elif vd.file_format == 'SMOKE': @@ -868,7 +868,7 @@ class TEXTURE_PT_voxeldata(TextureButtonsPanel, bpy.types.Panel): layout.prop(vd, "still") row = layout.row() row.active = vd.still - row.prop(vd, "still_frame_number") + row.prop(vd, "still_frame") layout.prop(vd, "interpolation") layout.prop(vd, "extension") @@ -906,12 +906,12 @@ class TEXTURE_PT_pointdensity(TextureButtonsPanel, bpy.types.Panel): sub.label(text="System:") sub.prop_object(pd, "particle_system", pd.object, "particle_systems", text="") sub.label(text="Cache:") - sub.prop(pd, "particle_cache", text="") + sub.prop(pd, "particle_cache_space", text="") else: col.label(text="Object:") col.prop(pd, "object", text="") col.label(text="Cache:") - col.prop(pd, "vertices_cache", text="") + col.prop(pd, "vertex_cache_space", text="") col.separator() @@ -928,7 +928,7 @@ class TEXTURE_PT_pointdensity(TextureButtonsPanel, bpy.types.Panel): col.label(text="Falloff:") col.prop(pd, "falloff", text="") if pd.falloff == 'SOFT': - col.prop(pd, "falloff_softness") + col.prop(pd, "falloff_soft") class TEXTURE_PT_pointdensity_turbulence(TextureButtonsPanel, bpy.types.Panel): @@ -947,14 +947,14 @@ class TEXTURE_PT_pointdensity_turbulence(TextureButtonsPanel, bpy.types.Panel): tex = context.texture pd = tex.point_density - layout.prop(pd, "turbulence", text="") + layout.prop(pd, "use_turbulence", text="") def draw(self, context): layout = self.layout tex = context.texture pd = tex.point_density - layout.active = pd.turbulence + layout.active = pd.use_turbulence split = layout.split() @@ -966,7 +966,7 @@ class TEXTURE_PT_pointdensity_turbulence(TextureButtonsPanel, bpy.types.Panel): col = split.column() col.label() - col.prop(pd, "turbulence_size") + col.prop(pd, "turbulence_scale") col.prop(pd, "turbulence_depth") col.prop(pd, "turbulence_strength") diff --git a/release/scripts/ui/properties_world.py b/release/scripts/ui/properties_world.py index bb5758ff902..f9906fa628e 100644 --- a/release/scripts/ui/properties_world.py +++ b/release/scripts/ui/properties_world.py @@ -78,15 +78,15 @@ class WORLD_PT_world(WorldButtonsPanel, bpy.types.Panel): world = context.world row = layout.row() - row.prop(world, "paper_sky") - row.prop(world, "blend_sky") - row.prop(world, "real_sky") + row.prop(world, "use_sky_paper") + row.prop(world, "use_sky_blend") + row.prop(world, "use_sky_real") row = layout.row() row.column().prop(world, "horizon_color") col = row.column() col.prop(world, "zenith_color") - col.active = world.blend_sky + col.active = world.use_sky_blend row.column().prop(world, "ambient_color") @@ -106,7 +106,7 @@ class WORLD_PT_ambient_occlusion(WorldButtonsPanel, bpy.types.Panel): split = layout.split() split.prop(light, "ao_factor", text="Factor") - split.prop(light, "ao_blend_mode", text="") + split.prop(light, "ao_blend_type", text="") class WORLD_PT_environment_lighting(WorldButtonsPanel, bpy.types.Panel): @@ -115,13 +115,13 @@ class WORLD_PT_environment_lighting(WorldButtonsPanel, bpy.types.Panel): def draw_header(self, context): light = context.world.lighting - self.layout.prop(light, "use_environment_lighting", text="") + self.layout.prop(light, "use_environment_light", text="") def draw(self, context): layout = self.layout light = context.world.lighting - layout.active = light.use_environment_lighting + layout.active = light.use_environment_light split = layout.split() split.prop(light, "environment_energy", text="Energy") @@ -139,13 +139,13 @@ class WORLD_PT_indirect_lighting(WorldButtonsPanel, bpy.types.Panel): def draw_header(self, context): light = context.world.lighting - self.layout.prop(light, "use_indirect_lighting", text="") + self.layout.prop(light, "use_indirect_light", text="") def draw(self, context): layout = self.layout light = context.world.lighting - layout.active = light.use_indirect_lighting + layout.active = light.use_indirect_light split = layout.split() split.prop(light, "indirect_factor", text="Factor") @@ -160,7 +160,7 @@ class WORLD_PT_gather(WorldButtonsPanel, bpy.types.Panel): layout = self.layout light = context.world.lighting - layout.active = light.use_ambient_occlusion or light.use_environment_lighting or light.use_indirect_lighting + layout.active = light.use_ambient_occlusion or light.use_environment_light or light.use_indirect_light layout.prop(light, "gather_method", expand=True) @@ -195,8 +195,8 @@ class WORLD_PT_gather(WorldButtonsPanel, bpy.types.Panel): col.label(text="Sampling:") col.prop(light, "passes") - col.prop(light, "error_tolerance", text="Error") - col.prop(light, "pixel_cache") + col.prop(light, "error_threshold", text="Error") + col.prop(light, "use_cache") col.prop(light, "correction") @@ -249,10 +249,10 @@ class WORLD_PT_stars(WorldButtonsPanel, bpy.types.Panel): col = split.column() col.prop(world.stars, "size") - col.prop(world.stars, "color_randomization", text="Colors") + col.prop(world.stars, "color_random", text="Colors") col = split.column() - col.prop(world.stars, "min_distance", text="Min. Dist") + col.prop(world.stars, "distance_min", text="Min. Dist") col.prop(world.stars, "average_separation", text="Separation") diff --git a/release/scripts/ui/space_image.py b/release/scripts/ui/space_image.py index bcb227b55ec..891637e7121 100644 --- a/release/scripts/ui/space_image.py +++ b/release/scripts/ui/space_image.py @@ -381,24 +381,24 @@ class IMAGE_PT_game_properties(bpy.types.Panel): col = split.column() sub = col.column(align=True) - sub.prop(ima, "animated") + sub.prop(ima, "use_animation") subsub = sub.column() - subsub.active = ima.animated - subsub.prop(ima, "animation_start", text="Start") - subsub.prop(ima, "animation_end", text="End") - subsub.prop(ima, "animation_speed", text="Speed") + subsub.active = ima.use_animation + subsub.prop(ima, "frame_start", text="Start") + subsub.prop(ima, "frame_end", text="End") + subsub.prop(ima, "fps", text="Speed") col.prop(ima, "tiles") sub = col.column(align=True) - sub.active = ima.tiles or ima.animated + sub.active = ima.tiles or ima.use_animation sub.prop(ima, "tiles_x", text="X") sub.prop(ima, "tiles_y", text="Y") col = split.column() col.label(text="Clamp:") - col.prop(ima, "clamp_x", text="X") - col.prop(ima, "clamp_y", text="Y") + col.prop(ima, "use_clamp_x", text="X") + col.prop(ima, "use_clamp_y", text="Y") col.separator() col.prop(ima, "mapping", expand=True) diff --git a/release/scripts/ui/space_info.py b/release/scripts/ui/space_info.py index 62c021354db..500e80fe120 100644 --- a/release/scripts/ui/space_info.py +++ b/release/scripts/ui/space_info.py @@ -277,7 +277,7 @@ class INFO_MT_game(bpy.types.Menu): layout.prop(gs, "use_deprecation_warnings") layout.prop(gs, "use_animation_record") layout.separator() - layout.prop(gs, "auto_start") + layout.prop(gs, "use_auto_start") class INFO_MT_render(bpy.types.Menu): diff --git a/release/scripts/ui/space_sequencer.py b/release/scripts/ui/space_sequencer.py index a331e747fdb..1906f3312e1 100644 --- a/release/scripts/ui/space_sequencer.py +++ b/release/scripts/ui/space_sequencer.py @@ -358,12 +358,12 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel, bpy.types.Panel): split = layout.split(percentage=0.3) split.label(text="Blend:") - split.prop(strip, "blend_mode", text="") + split.prop(strip, "blend_type", text="") row = layout.row(align=True) sub = row.row() sub.active = (not strip.mute) - sub.prop(strip, "blend_opacity", text="Opacity", slider=True) + sub.prop(strip, "blend_alpha", text="Opacity", slider=True) row.prop(strip, "mute", toggle=True, icon='RESTRICT_VIEW_ON' if strip.mute else 'RESTRICT_VIEW_OFF', text="") row.prop(strip, "lock", toggle=True, icon='LOCKED' if strip.lock else 'UNLOCKED', text="") @@ -372,11 +372,11 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel, bpy.types.Panel): sub.enabled = not strip.lock sub.prop(strip, "channel") sub.prop(strip, "frame_start") - sub.prop(strip, "frame_final_length") + sub.prop(strip, "frame_final_duration") col = layout.column(align=True) row = col.row() - row.label(text="Final Length: %s" % bpy.utils.smpte_from_frame(strip.frame_final_length)) + row.label(text="Final Length: %s" % bpy.utils.smpte_from_frame(strip.frame_final_duration)) row = col.row() row.active = (frame_current >= strip.frame_start and frame_current <= strip.frame_start + strip.frame_duration) row.label(text="Playhead: %d" % (frame_current - strip.frame_start)) @@ -428,19 +428,19 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, bpy.types.Panel): flow.prop(strip, "threshold", slider=True) flow.prop(strip, "clamp", slider=True) flow.prop(strip, "boost_factor") - flow.prop(strip, "blur_distance") + flow.prop(strip, "blur_radius") row = layout.row() row.prop(strip, "quality", slider=True) - row.prop(strip, "only_boost") + row.prop(strip, "use_only_boost") elif strip.type == 'SPEED': layout.prop(strip, "global_speed") flow = layout.column_flow() - flow.prop(strip, "curve_velocity") - flow.prop(strip, "curve_compress_y") - flow.prop(strip, "frame_blending") + flow.prop(strip, "use_curve_velocity") + flow.prop(strip, "use_curve_compress_y") + flow.prop(strip, "use_frame_blend") elif strip.type == 'TRANSFORM': self.draw_panel_transform(strip) @@ -463,8 +463,8 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, bpy.types.Panel): if strip.type == 'SPEED': col.prop(strip, "speed_fader", text="Speed fader") elif strip.type in ('CROSS', 'GAMMA_CROSS', 'PLUGIN', 'WIPE'): - col.prop(strip, "use_effect_default_fade", "Default fade") - if not strip.use_effect_default_fade: + col.prop(strip, "use_default_fade", "Default fade") + if not strip.use_default_fade: col.prop(strip, "effect_fader", text="Effect fader") layout.prop(strip, "use_translation", text="Image Offset:") @@ -495,8 +495,8 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, bpy.types.Panel): layout.separator() col = layout.column(align=True) - col.prop(strip, "uniform_scale") - if (strip.uniform_scale): + col.prop(strip, "use_uniform_scale") + if (strip.use_uniform_scale): col = layout.column(align=True) col.prop(strip, "scale_start_x", text="Scale") else: @@ -624,8 +624,8 @@ class SEQUENCER_PT_sound(SequencerButtonsPanel, bpy.types.Panel): col = layout.column(align=True) col.label(text="Trim Duration:") - col.prop(strip, "animation_start_offset", text="Start") - col.prop(strip, "animation_end_offset", text="End") + col.prop(strip, "animation_offset_start", text="Start") + col.prop(strip, "animation_offset_end", text="End") class SEQUENCER_PT_scene(SequencerButtonsPanel, bpy.types.Panel): @@ -683,19 +683,19 @@ class SEQUENCER_PT_filter(SequencerButtonsPanel, bpy.types.Panel): row = layout.row() row.label(text="Flip:") - row.prop(strip, "flip_x", text="X") - row.prop(strip, "flip_y", text="Y") + row.prop(strip, "use_flip_x", text="X") + row.prop(strip, "use_flip_y", text="Y") col = layout.column() - col.prop(strip, "reverse_frames", text="Backwards") - col.prop(strip, "de_interlace") + col.prop(strip, "use_reverse_frames", text="Backwards") + col.prop(strip, "use_deinterlace") col = layout.column() col.label(text="Colors:") col.prop(strip, "color_saturation", text="Saturation") - col.prop(strip, "multiply_colors", text="Multiply") - col.prop(strip, "premultiply") - col.prop(strip, "convert_float") + col.prop(strip, "color_multiply", text="Multiply") + col.prop(strip, "use_premultiply") + col.prop(strip, "use_float") layout.prop(strip, "use_color_balance") if strip.use_color_balance and strip.color_balance: # TODO - need to add this somehow @@ -704,15 +704,15 @@ class SEQUENCER_PT_filter(SequencerButtonsPanel, bpy.types.Panel): col = row.column() col.template_color_wheel(strip.color_balance, "lift", value_slider=False, cubic=True) col.row().prop(strip.color_balance, "lift") - col.prop(strip.color_balance, "inverse_lift", text="Inverse") + col.prop(strip.color_balance, "invert_lift", text="Inverse") col = row.column() col.template_color_wheel(strip.color_balance, "gamma", value_slider=False, lock_luminosity=True, cubic=True) col.row().prop(strip.color_balance, "gamma") - col.prop(strip.color_balance, "inverse_gamma", text="Inverse") + col.prop(strip.color_balance, "invert_gamma", text="Inverse") col = row.column() col.template_color_wheel(strip.color_balance, "gain", value_slider=False, lock_luminosity=True, cubic=True) col.row().prop(strip.color_balance, "gain") - col.prop(strip.color_balance, "inverse_gain", text="Inverse") + col.prop(strip.color_balance, "invert_gain", text="Inverse") class SEQUENCER_PT_proxy(SequencerButtonsPanel, bpy.types.Panel): @@ -740,12 +740,12 @@ class SEQUENCER_PT_proxy(SequencerButtonsPanel, bpy.types.Panel): strip = act_strip(context) flow = layout.column_flow() - flow.prop(strip, "proxy_custom_directory") - flow.prop(strip, "proxy_custom_file") + flow.prop(strip, "use_proxy_custom_directory") + flow.prop(strip, "use_proxy_custom_file") if strip.proxy: # TODO - need to add this somehow - if strip.proxy_custom_directory and not strip.proxy_custom_file: + if strip.proxy_custom_directory and not strip.use_proxy_custom_file: flow.prop(strip.proxy, "directory") - if strip.proxy_custom_file: + if strip.use_proxy_custom_file: flow.prop(strip.proxy, "filepath") diff --git a/release/scripts/ui/space_userpref_keymap.py b/release/scripts/ui/space_userpref_keymap.py index f966f8a7e8b..5536be0586c 100644 --- a/release/scripts/ui/space_userpref_keymap.py +++ b/release/scripts/ui/space_userpref_keymap.py @@ -152,7 +152,7 @@ class InputKeyMapPanel(bpy.types.Panel): indentpx = 16 if level == 0: level = 0.0001 # Tweak so that a percentage of 0 won't split by half - indent = level * indentpx / bpy.context.region.width + indent = level * indentpx / bpy.context.region.offset split = layout.split(percentage=indent) col = split.column() diff --git a/release/scripts/ui/space_view3d.py b/release/scripts/ui/space_view3d.py index 2dc4b9cfabb..428a840b4f7 100644 --- a/release/scripts/ui/space_view3d.py +++ b/release/scripts/ui/space_view3d.py @@ -68,7 +68,7 @@ class VIEW3D_HT_header(bpy.types.Header): if obj: # Particle edit if obj.mode == 'PARTICLE_EDIT': - row.prop(toolsettings.particle_edit, "selection_mode", text="", expand=True, toggle=True) + row.prop(toolsettings.particle_edit, "select_mode", text="", expand=True, toggle=True) # Occlude geometry if view.viewport_shade in ('SOLID', 'SHADED', 'TEXTURED') and (obj.mode == 'PARTICLE_EDIT' or (obj.mode == 'EDIT' and obj.type == 'MESH')): @@ -748,7 +748,7 @@ class VIEW3D_MT_object_specials(bpy.types.Menu): props = layout.operator("wm.context_modal_mouse", text="Width Size") props.data_path_iter = "selected_editable_objects" - props.data_path_item = "data.width" + props.data_path_item = "data.offset" props.input_scale = 0.01 if obj.type == 'EMPTY': @@ -1063,7 +1063,7 @@ class VIEW3D_MT_particle(bpy.types.Menu): layout.operator("particle.remove_doubles") layout.operator("particle.delete") - if particle_edit.selection_mode == 'POINT': + if particle_edit.select_mode == 'POINT': layout.operator("particle.subdivide") layout.operator("particle.rekey") @@ -1084,7 +1084,7 @@ class VIEW3D_MT_particle_specials(bpy.types.Menu): layout.operator("particle.rekey") layout.separator() - if particle_edit.selection_mode == 'POINT': + if particle_edit.select_mode == 'POINT': layout.operator("particle.subdivide") layout.operator("particle.select_roots") layout.operator("particle.select_tips") @@ -1108,7 +1108,7 @@ class VIEW3D_MT_pose(bpy.types.Menu): layout.menu("VIEW3D_MT_transform") layout.menu("VIEW3D_MT_snap") - if arm.drawtype in ('BBONE', 'ENVELOPE'): + if arm.draw_type in ('BBONE', 'ENVELOPE'): layout.operator("transform.transform", text="Scale Envelope Distance").mode = 'BONESIZE' layout.menu("VIEW3D_MT_pose_transform") @@ -1843,7 +1843,7 @@ class VIEW3D_MT_edit_armature(bpy.types.Menu): layout.menu("VIEW3D_MT_snap") layout.menu("VIEW3D_MT_edit_armature_roll") - if arm.drawtype == 'ENVELOPE': + if arm.draw_type == 'ENVELOPE': layout.operator("transform.transform", text="Scale Envelope Distance").mode = 'BONESIZE' else: layout.operator("transform.transform", text="Scale B-Bone Width").mode = 'BONESIZE' @@ -1852,7 +1852,7 @@ class VIEW3D_MT_edit_armature(bpy.types.Menu): layout.operator("armature.extrude_move") - if arm.x_axis_mirror: + if arm.use_mirror_x: layout.operator("armature.extrude_forked") layout.operator("armature.duplicate_move") @@ -2167,7 +2167,7 @@ class VIEW3D_PT_background_image(bpy.types.Panel): if (bg.image): box.template_image(bg, "image", bg.image_user, compact=True) - box.prop(bg, "transparency", slider=True) + box.prop(bg, "use_transparency", slider=True) if bg.view_axis != 'CAMERA': box.prop(bg, "size") row = box.row(align=True) diff --git a/release/scripts/ui/space_view3d_toolbar.py b/release/scripts/ui/space_view3d_toolbar.py index f99044281b5..e47dbceed8f 100644 --- a/release/scripts/ui/space_view3d_toolbar.py +++ b/release/scripts/ui/space_view3d_toolbar.py @@ -339,7 +339,7 @@ class VIEW3D_PT_tools_armatureedit_options(View3DPanel, bpy.types.Panel): arm = context.active_object.data col = layout.column(align=True) - col.prop(arm, "x_axis_mirror") + col.prop(arm, "use_mirror_x") # ********** default tools for editmode_mball **************** @@ -462,8 +462,8 @@ class VIEW3D_PT_tools_posemode_options(View3DPanel, bpy.types.Panel): arm = context.active_object.data col = layout.column(align=True) - col.prop(arm, "x_axis_mirror") - col.prop(arm, "auto_ik") + col.prop(arm, "use_mirror_x") + col.prop(arm, "use_auto_ik") # ********** default tools for paint modes **************** @@ -523,11 +523,11 @@ class VIEW3D_PT_tools_brush(PaintPanel, bpy.types.Panel): if settings.tool == 'ADD': col.prop(brush, "count") col = layout.column() - col.prop(settings, "add_interpolate") + col.prop(settings, "use_default_interpolate") sub = col.column(align=True) - sub.active = settings.add_interpolate + sub.active = settings.use_default_interpolate sub.prop(brush, "steps", slider=True) - sub.prop(settings, "add_keys", slider=True) + sub.prop(settings, "default_key_count", slider=True) elif settings.tool == 'LENGTH': layout.prop(brush, "length_mode", expand=True) elif settings.tool == 'PUFF': @@ -1116,9 +1116,9 @@ class VIEW3D_PT_tools_weightpaint_options(View3DPanel, bpy.types.Panel): wpaint = tool_settings.weight_paint col = layout.column() - col.prop(wpaint, "all_faces") + col.prop(wpaint, "use_all_faces") col.prop(wpaint, "normals") - col.prop(wpaint, "spray") + col.prop(wpaint, "use_spray") obj = context.weight_paint_object if obj.type == 'MESH': @@ -1154,9 +1154,9 @@ class VIEW3D_PT_tools_vertexpaint(View3DPanel, bpy.types.Panel): col = layout.column() #col.prop(vpaint, "mode", text="") - col.prop(vpaint, "all_faces") + col.prop(vpaint, "use_all_faces") col.prop(vpaint, "normals") - col.prop(vpaint, "spray") + col.prop(vpaint, "use_spray") col.label(text="Unified Settings:") col.prop(tool_settings, "sculpt_paint_use_unified_size", text="Size") @@ -1319,19 +1319,19 @@ class VIEW3D_PT_tools_particlemode(View3DPanel, bpy.types.Panel): col = layout.column(align=True) if pe.is_hair: col.active = pe.is_editable - col.prop(pe, "emitter_deflect", text="Deflect emitter") + col.prop(pe, "use_emitter_deflect", text="Deflect emitter") sub = col.row() - sub.active = pe.emitter_deflect + sub.active = pe.use_emitter_deflect sub.prop(pe, "emitter_distance", text="Distance") col = layout.column(align=True) col.active = pe.is_editable col.label(text="Keep:") - col.prop(pe, "keep_lengths", text="Lengths") - col.prop(pe, "keep_root", text="Root") + col.prop(pe, "use_preserve_length", text="Lengths") + col.prop(pe, "use_preserve_root", text="Root") if not pe.is_hair: col.label(text="Correct:") - col.prop(pe, "auto_velocity", text="Velocity") + col.prop(pe, "use_auto_velocity", text="Velocity") col.prop(ob.data, "use_mirror_x") col = layout.column(align=True) @@ -1343,9 +1343,9 @@ class VIEW3D_PT_tools_particlemode(View3DPanel, bpy.types.Panel): else: if pe.type == 'PARTICLES': col.prop(pe, "show_particles", text="Particles") - col.prop(pe, "fade_time") + col.prop(pe, "use_fade_time") sub = col.row() - sub.active = pe.fade_time + sub.active = pe.use_fade_time sub.prop(pe, "fade_frames", slider=True) |