rna data path names which are more likely to break animations.
authorCampbell Barton <ideasman42@gmail.com>
Fri, 20 Aug 2010 06:09:58 +0000 (06:09 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Fri, 20 Aug 2010 06:09:58 +0000 (06:09 +0000)
Added an operator "Update Animation Data",
access from the search menu to update drivers and fcurves.

85 files changed:
release/scripts/io/export_fbx.py
release/scripts/io/export_obj.py
release/scripts/io/export_x3d.py
release/scripts/io/import_scene_obj.py
release/scripts/io/netrender/client.py
release/scripts/io/netrender/repath.py
release/scripts/io/netrender/slave.py
release/scripts/io/netrender/ui.py
release/scripts/modules/animsys_refactor.py
release/scripts/modules/bpy/__init__.py
release/scripts/modules/rigify/__init__.py
release/scripts/modules/rigify/arm_biped.py
release/scripts/modules/rigify/eye_balls.py
release/scripts/modules/rigify/eye_lid.py
release/scripts/modules/rigify/leg_biped.py
release/scripts/modules/rigify/leg_quadruped.py
release/scripts/modules/rigify/mouth.py
release/scripts/modules/rigify/stretch.py
release/scripts/modules/rigify/stretch_twist.py
release/scripts/modules/rigify_utils.py
release/scripts/op/animsys_update.py [new file with mode: 0644]
release/scripts/op/presets.py
release/scripts/op/sequencer.py
release/scripts/ui/properties_animviz.py
release/scripts/ui/properties_data_armature.py
release/scripts/ui/properties_data_armature_rigify.py
release/scripts/ui/properties_data_bone.py
release/scripts/ui/properties_data_curve.py
release/scripts/ui/properties_data_lamp.py
release/scripts/ui/properties_data_mesh.py
release/scripts/ui/properties_data_modifier.py
release/scripts/ui/properties_game.py
release/scripts/ui/properties_material.py
release/scripts/ui/properties_object.py
release/scripts/ui/properties_object_constraint.py
release/scripts/ui/properties_particle.py
release/scripts/ui/properties_physics_cloth.py
release/scripts/ui/properties_physics_common.py
release/scripts/ui/properties_physics_field.py
release/scripts/ui/properties_physics_fluid.py
release/scripts/ui/properties_physics_smoke.py
release/scripts/ui/properties_physics_softbody.py
release/scripts/ui/properties_render.py
release/scripts/ui/properties_texture.py
release/scripts/ui/properties_world.py
release/scripts/ui/space_image.py
release/scripts/ui/space_info.py
release/scripts/ui/space_sequencer.py
release/scripts/ui/space_userpref_keymap.py
release/scripts/ui/space_view3d.py
release/scripts/ui/space_view3d_toolbar.py
source/blender/editors/mesh/editmesh_add.c
source/blender/editors/screen/screen_ops.c
source/blender/editors/space_image/image_buttons.c
source/blender/editors/space_nla/nla_buttons.c
source/blender/editors/space_node/drawnode.c
source/blender/makesrna/intern/rna_animviz.c
source/blender/makesrna/intern/rna_armature.c
source/blender/makesrna/intern/rna_cloth.c
source/blender/makesrna/intern/rna_constraint.c
source/blender/makesrna/intern/rna_curve.c
source/blender/makesrna/intern/rna_fluidsim.c
source/blender/makesrna/intern/rna_image.c
source/blender/makesrna/intern/rna_lamp.c
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_material_api.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_modifier.c
source/blender/makesrna/intern/rna_nla.c
source/blender/makesrna/intern/rna_nodetree.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_object_force.c
source/blender/makesrna/intern/rna_particle.c
source/blender/makesrna/intern/rna_pose.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_sculpt_paint.c
source/blender/makesrna/intern/rna_sequencer.c
source/blender/makesrna/intern/rna_smoke.c
source/blender/makesrna/intern/rna_texture.c
source/blender/makesrna/intern/rna_world.c
source/blender/makesrna/rna_cleanup/rna_properties.txt
source/gameengine/Converter/BL_ArmatureChannel.cpp
source/gameengine/GamePlayer/ghost/GPG_ghost.cpp
source/gameengine/Ketsji/KX_BlenderMaterial.cpp
source/gameengine/Ketsji/KX_Scene.cpp

index 54b63ccfa2f6961d3e6f375ff285e34730fadb09..60e9e90e11b0d7147cba91d8bbff28b3dc3002ec 100644 (file)
@@ -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}')
index 319d459e4c25ab27c2927ea83b84744b80793780..53c4a324ed17266e802d58aa8e1d8e1f405691e5 100644 (file)
@@ -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.
index 3b396011378fe3e0ce34629736e22bab2ebe55d3..aafb7c922a18f81f259d89bce3eb46da65d4647f 100644 (file)
@@ -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()
index cb56fb62bdc693fd1cf4a568aa1615f328b54b8d..2b5a3f06832c98df3d469d2870e1070a8d1f4f20 100644 (file)
@@ -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
index 42fea33889112548ea2160ddc64275914cec7797..6f0f6460ae1deccd1df8e004b2cdf16eac3af217 100644 (file)
@@ -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):
index e7fcad836826acc4a36b956acb072f44925c3319..3ac9636b6281153c68d87e8883ad5d0bea9d2062 100644 (file)
@@ -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)
index 7528ea1053a4c6d9364a90b76511019667d2f19a..a44309d5634ffbb0aebf293ed4533689115bdf47 100644 (file)
@@ -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__":
index cacc35ad48dc1cf25b046e9446981420863b399f..c2d943f63f8a599b6bfca127cad9a95e06089b13 100644 (file)
@@ -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)
index 3959904e0c5793b8200ae91a8befc297d78b517a..8cc91873b0ed5a7828c2d0b0dc8a332cbf82e4ac 100644 (file)
@@ -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)
index 3431054413eb07b9160e7169381c6555ae751d7a..5b7d5a76336e2c32f7026c86ccb32daad50f29a6 100644 (file)
@@ -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
index 2eed5bbb74e694af57347830ca1a8049356c819e..98d9bb235a208fef0d150b9f7726c8a6e407fc8f 100644 (file)
@@ -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
index ec36210e61d56f5e557ffb3906f71d3a423d995a..ac878c3c07633b5297c7af2f9dbb7fe26e8cc759 100644 (file)
@@ -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
index b1889d7c36fdebd0852f62e2eb2c29634e9b850e..f65d56b9f2b232acc77ae6926eadbbeea4177b9d 100644 (file)
@@ -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'
     
     
index 2d7e3e0e61ff48d6dcf73969aa89540aba780fdf..3f336e268c66d210d7c57b1c44802e649ed443ce 100644 (file)
@@ -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
index 2ea70402d36aac22805051111bf6a43ea8812e58..d2ddba9f54992801bf46666990a052eb23977407 100644 (file)
@@ -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
index 640e1766ca6af5a21e4f3130b802d7595090de70..739a6402c4bdec9ccf6c61c5c1f11e4a7b2674bc 100644 (file)
@@ -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
index fff58861e02c66c358eee79fae4bf741bd8ae96c..ce232b91e7b04dde050f6aeb00f95a71608a9179 100644 (file)
@@ -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
index 67ceeb39954e561f27191d75b8ca9f41aa717f06..6a498e5aa2903a9857b394bdba0214fd719a4d59 100644 (file)
@@ -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:
index 5250c5a9735bbb63e33d1b19447e9392afa76c79..07ce031967f570f86a56b257a8dd866eb4686f15 100644 (file)
@@ -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:
index 39481b37f598805cbc93b2e00a9fee32b124d2e4..a270af949da4cc65c7c816466bb60eeedf18066f 100644 (file)
@@ -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 (file)
index 0000000..0350eee
--- /dev/null
@@ -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
index be68a7f1609e9ece613fb6b62b3a5bc4387979ca..43e2cda5d53dadf824effe2b92ca530585707ece 100644 (file)
@@ -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]",
index cbb7d00e659720d10b9f30dae73fd0cd7de6ba5b..feedb5cb4a8e05dff5e1d26237db0afd0aac8017 100644 (file)
@@ -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'}
 
index bbd849e4daf2c973f370566f008c26b09e932cb6..9b605d022159900c4f3701e23c3c48dc64a8c7cf 100644 (file)
@@ -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")
index 767b163d3c2c803a18386a3c8cd3857a8c9e872c..7de0655475140f5924cf4851e5ab96e6ae476c3b 100644 (file)
@@ -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):
index 0dbd964acb596c08c2bf27a6e338b0ea11ae5288..1c2370cbb28b043cc30be9a66633d889cdd52b6e 100644 (file)
@@ -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)
index 4c0f8a3e52c97c6ced8fa170f9140f5b49a28bd7..663d576a9c00048c4afebb851f5f8b89df663077 100644 (file)
@@ -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):
index cd62746c3abddedfeb515ef76a537df984f8e60a..3008db11b36c2ed72062c2a5bebb99ea9b7a1450 100644 (file)
@@ -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()
index 8eb0c275462dffe9f43126f3690e8e20df956403..8d82f5ef9436f0672838e27e530d4b5d803988ba 100644 (file)
@@ -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")
 
 
index 1188de7f11ccedbe8ffb73422499b616f70708d3..aaf814ed705c8859a2782c0fbea426d45a897dc3 100644 (file)
@@ -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="")
index 26080951fffd5ef97aa3c463c3419f7246eaf4a4..e08c7cb1f2373528fd757430e9bc33a68bec25ee 100644 (file)
@@ -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()
index ee026a3663abf13894cd63d30d5a47604f87b753..f90a54465576a4b4ed34dc3503ab1476cda3db0b 100644 (file)
@@ -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):
index 2ecaeff7c90e6a7b06e6c446d13cea4726792cec..d4e07f8333b4a3c95f940265e1409b7983ef7d8b 100644 (file)
@@ -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):
index 2bc685d972aaaf1ee06c7b169432fb8a655daaf3..a87a43a7998bbfaac38fc1d23dbcd4ef05f40f21 100644 (file)
@@ -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")
 
index 59eb8e40e7800f4fc0a354755f90b2fee6cb96a7..be102a171032d02ea2392e50825aeb10110f03f0 100644 (file)
@@ -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"
index 618d8e5486e0768c187811f8fec4d6200e7542cc..65070772d09bc7bda06ae32914f0562e6574a994 100644 (file)
@@ -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):
index 8a770066b0b3ab2ec985436dcff7830605a1307f..30619de5814cae42903b2d531a886cbb0f53cd00 100644 (file)
@@ -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()
 
index b4f54e687f3605f3a6c29e3835ecbf6f2f354a31..fb9f2f981aed82c95a64169063f17687eeabb5a8 100644 (file)
@@ -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():
index e09734b99803c8c96f24bd98a70622005b53e744..80ea999eedb405f766ee13728b9d9c7e87e93cfd 100644 (file)
@@ -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)
index 35934ebfb320fd346d06d54fa1fdb6f80a970f90..035eefe6c2a87fb87d59d6828b0f02c52233788d 100644 (file)
@@ -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")
 
 
index 263832b3a3cd3c82e1cda44a7b1710fbda558d4b..f924c1df3015465f536b6f636c60fd59637b3483 100644 (file)
@@ -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')
 
index b377f0b6027b29c58a8bc8c25dd36df3fea025d1..865003531dbdaca4a2818fdaae15cd46794c6297 100644 (file)
@@ -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):
index a0e284ab1f3d95900e0a9efd0aceb250d69ed5c1..2072aa00b764d592ecd7433ef512238da2c6dfcd 100644 (file)
@@ -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()
index 9f759e24f538a6e9f778df7458694eceb60069c2..7996e162b8e1f6aa5e243e8f24b9490f0f6a07bd 100644 (file)
@@ -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")
 
index bb5758ff902967cff16f5d6c86532b6399f38d5d..f9906fa628eb96f8c3df31e03a1c0fb325c127a5 100644 (file)
@@ -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")
 
 
index bcb227b55ec34e017f7ee3481de3d8201e416043..891637e7121cb127c86d22563673397a7fabb13f 100644 (file)
@@ -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)
 
index 62c021354dba42e8ca3064feb50733210d178b3b..500e80fe120d932af3ee882f4a557aea639f737d 100644 (file)
@@ -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):
index a331e747fdb12418f01e03da11f1971b60d2656e..1906f3312e175c0bdefd54a27de622237b4ee01b 100644 (file)
@@ -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")
 
 
index f966f8a7e8b3eacd6ed7646854d6dcdfd4a12b34..5536be0586c30d1c2273f51841640af4dc2e62bd 100644 (file)
@@ -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()
index 2dc4b9cfabb4f1bf840dd9b4da037cbf0a71ca11..428a840b4f7f808f2dfc31cf6d24997a848f8eb8 100644 (file)
@@ -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)
index f99044281b5174e1030a5b24df1ff1c55af9f84c..e47dbceed8f8663978d8bec0eb9f0df8f9a8cd73 100644 (file)
@@ -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)
 
 
index 8ad768f265832859456c7c01b7c26399d49cfcc4..ca1a80110f33b072b229e8b28dc0b1d304f27c53 100644 (file)
@@ -1587,7 +1587,7 @@ static int add_primitive_uvsphere_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
 
        make_prim_ext(C, loc, rot, enter_editmode, layer,
-                       PRIM_UVSPHERE, RNA_int_get(op->ptr, "rings"),
+                       PRIM_UVSPHERE, RNA_int_get(op->ptr, "ring_count"),
                        RNA_int_get(op->ptr, "segments"), 0,
                        RNA_float_get(op->ptr,"size"), 0.0f, 0, 0);
 
@@ -1611,7 +1611,7 @@ void MESH_OT_primitive_uv_sphere_add(wmOperatorType *ot)
        
        /* props */
        RNA_def_int(ot->srna, "segments", 32, INT_MIN, INT_MAX, "Segments", "", 3, 500);
-       RNA_def_int(ot->srna, "rings", 16, INT_MIN, INT_MAX, "Rings", "", 3, 500);
+       RNA_def_int(ot->srna, "ring_count", 16, INT_MIN, INT_MAX, "Rings", "", 3, 500);
        RNA_def_float(ot->srna, "size", 1.0f, 0.0, FLT_MAX, "Size", "", 0.001, 100.00);
 
        ED_object_add_generic_props(ot, TRUE);
index 3daacd8f68e53ff4e8bbc830f9991130d984c3f6..c96306dde14ad44aa537cae297c87e44331ee581 100644 (file)
@@ -1748,10 +1748,10 @@ static int area_join_init(bContext *C, wmOperator *op)
        int x2, y2;
        
        /* required properties, make negative to get return 0 if not set by caller */
-       x1= RNA_int_get(op->ptr, "x1");
-       y1= RNA_int_get(op->ptr, "y1");
-       x2= RNA_int_get(op->ptr, "x2");
-       y2= RNA_int_get(op->ptr, "y2");
+       x1= RNA_int_get(op->ptr, "min_x");
+       y1= RNA_int_get(op->ptr, "min_y");
+       x2= RNA_int_get(op->ptr, "max_x");
+       y2= RNA_int_get(op->ptr, "max_y");
        
        sa1 = screen_areahascursor(CTX_wm_screen(C), x1, y1);
        sa2 = screen_areahascursor(CTX_wm_screen(C), x2, y2);
@@ -1832,10 +1832,10 @@ static int area_join_invoke(bContext *C, wmOperator *op, wmEvent *event)
                        return OPERATOR_PASS_THROUGH;
                
                /* prepare operator state vars */
-               RNA_int_set(op->ptr, "x1", sad->x);
-               RNA_int_set(op->ptr, "y1", sad->y);
-               RNA_int_set(op->ptr, "x2", event->x);
-               RNA_int_set(op->ptr, "y2", event->y);
+               RNA_int_set(op->ptr, "min_x", sad->x);
+               RNA_int_set(op->ptr, "min_y", sad->y);
+               RNA_int_set(op->ptr, "max_x", event->x);
+               RNA_int_set(op->ptr, "max_y", event->y);
                
                if(!area_join_init(C, op)) 
                        return OPERATOR_PASS_THROUGH;
@@ -1977,10 +1977,10 @@ static void SCREEN_OT_area_join(wmOperatorType *ot)
        ot->flag= OPTYPE_BLOCKING;
        
        /* rna */
-       RNA_def_int(ot->srna, "x1", -100, INT_MIN, INT_MAX, "X 1", "", INT_MIN, INT_MAX);
-       RNA_def_int(ot->srna, "y1", -100, INT_MIN, INT_MAX, "Y 1", "", INT_MIN, INT_MAX);
-       RNA_def_int(ot->srna, "x2", -100, INT_MIN, INT_MAX, "X 2", "", INT_MIN, INT_MAX);
-       RNA_def_int(ot->srna, "y2", -100, INT_MIN, INT_MAX, "Y 2", "", INT_MIN, INT_MAX);
+       RNA_def_int(ot->srna, "min_x", -100, INT_MIN, INT_MAX, "X 1", "", INT_MIN, INT_MAX);
+       RNA_def_int(ot->srna, "min_y", -100, INT_MIN, INT_MAX, "Y 1", "", INT_MIN, INT_MAX);
+       RNA_def_int(ot->srna, "max_x", -100, INT_MIN, INT_MAX, "X 2", "", INT_MIN, INT_MAX);
+       RNA_def_int(ot->srna, "max_y", -100, INT_MIN, INT_MAX, "Y 2", "", INT_MIN, INT_MAX);
 }
 
 /* ************** repeat last operator ***************************** */
index 06ed4d6165752eb8d3c8107eb4645359e6506dbc..4f9163bc32c4cc48deb12dfac961012a5a34ede4 100644 (file)
@@ -884,7 +884,7 @@ void uiTemplateImage(uiLayout *layout, bContext *C, PointerRNA *ptr, char *propn
                                        uiLayoutSetActive(row, RNA_boolean_get(&imaptr, "use_fields"));
 
                                        col= uiLayoutColumn(split, 0);
-                                       uiItemR(col, &imaptr, "premultiply", 0, NULL, 0);
+                                       uiItemR(col, &imaptr, "use_premultiply", 0, NULL, 0);
                                }
                        }
 
@@ -909,7 +909,7 @@ void uiTemplateImage(uiLayout *layout, bContext *C, PointerRNA *ptr, char *propn
 
                                col= uiLayoutColumn(split, 0);
                                uiItemR(col, userptr, "fields_per_frame", 0, "Fields", 0);
-                               uiItemR(col, userptr, "auto_refresh", 0, NULL, 0);
+                               uiItemR(col, userptr, "use_auto_refresh", 0, NULL, 0);
                                uiItemR(col, userptr, "cyclic", 0, NULL, 0);
                        }
                        else if(ima->source==IMA_SRC_GENERATED) {
index 6ff9922c55557229a17d29f1fc62634025066368..5ad21f7c9cade49855e9b46128911ddbeec4fa55 100644 (file)
@@ -293,23 +293,23 @@ static void nla_panel_properties(const bContext *C, Panel *pa)
        
        /* blending */
        row= uiLayoutRow(layout, 1);
-               uiItemR(row, &strip_ptr, "blending", 0, NULL, 0);
+               uiItemR(row, &strip_ptr, "blend_type", 0, NULL, 0);
                
        /* blend in/out + autoblending
         *      - blend in/out can only be set when autoblending is off
         */
        column= uiLayoutColumn(layout, 1);
-               uiLayoutSetActive(column, RNA_boolean_get(&strip_ptr, "animated_influence")==0); 
-               uiItemR(column, &strip_ptr, "auto_blending", 0, NULL, 0); // XXX as toggle?
+               uiLayoutSetActive(column, RNA_boolean_get(&strip_ptr, "use_animated_influence")==0); 
+               uiItemR(column, &strip_ptr, "use_auto_blend", 0, NULL, 0); // XXX as toggle?
                
                subcol= uiLayoutColumn(column, 1);
-                       uiLayoutSetActive(subcol, RNA_boolean_get(&strip_ptr, "auto_blending")==0); 
+                       uiLayoutSetActive(subcol, RNA_boolean_get(&strip_ptr, "use_auto_blend")==0); 
                        uiItemR(subcol, &strip_ptr, "blend_in", 0, NULL, 0);
                        uiItemR(subcol, &strip_ptr, "blend_out", 0, NULL, 0);
                
        /* settings */
        column= uiLayoutColumn(layout, 1);
-               uiLayoutSetActive(column, !(RNA_boolean_get(&strip_ptr, "animated_influence") || RNA_boolean_get(&strip_ptr, "animated_time"))); 
+               uiLayoutSetActive(column, !(RNA_boolean_get(&strip_ptr, "animated_influence") || RNA_boolean_get(&strip_ptr, "use_animated_time"))); 
                uiItemL(column, "Playback Settings:", 0);
                uiItemR(column, &strip_ptr, "mute", 0, NULL, 0);
                uiItemR(column, &strip_ptr, "reversed", 0, NULL, 0);
@@ -346,7 +346,7 @@ static void nla_panel_actclip(const bContext *C, Panel *pa)
                
        /* action usage */
        column= uiLayoutColumn(layout, 1);
-               uiLayoutSetActive(column, RNA_boolean_get(&strip_ptr, "animated_time")==0); 
+               uiLayoutSetActive(column, RNA_boolean_get(&strip_ptr, "use_animated_time")==0); 
                uiItemL(column, "Playback Settings:", 0);
                uiItemR(column, &strip_ptr, "scale", 0, NULL, 0);
                uiItemR(column, &strip_ptr, "repeat", 0, NULL, 0);
@@ -368,21 +368,21 @@ static void nla_panel_evaluation(const bContext *C, Panel *pa)
        uiBlockSetHandleFunc(block, do_nla_region_buttons, NULL);
                
        column= uiLayoutColumn(layout, 1);
-               uiItemR(column, &strip_ptr, "animated_influence", 0, NULL, 0);
+               uiItemR(column, &strip_ptr, "use_animated_influence", 0, NULL, 0);
                
                subcolumn= uiLayoutColumn(column, 1);
-               uiLayoutSetEnabled(subcolumn, RNA_boolean_get(&strip_ptr, "animated_influence"));       
+               uiLayoutSetEnabled(subcolumn, RNA_boolean_get(&strip_ptr, "use_animated_influence"));   
                        uiItemR(subcolumn, &strip_ptr, "influence", 0, NULL, 0);
                
        
        column= uiLayoutColumn(layout, 1);
                subrow= uiLayoutRow(column, 0);
-               uiItemR(subrow, &strip_ptr, "animated_time", 0, NULL, 0);
-               uiItemR(subrow, &strip_ptr, "animated_time_cyclic", 0, NULL, 0);
+               uiItemR(subrow, &strip_ptr, "use_animated_time", 0, NULL, 0);
+               uiItemR(subrow, &strip_ptr, "use_animated_time_cyclic", 0, NULL, 0);
 
                subcolumn= uiLayoutColumn(column, 1);
                subrow= uiLayoutRow(subcolumn, 0);
-               uiLayoutSetEnabled(subrow, RNA_boolean_get(&strip_ptr, "animated_time"));
+               uiLayoutSetEnabled(subrow, RNA_boolean_get(&strip_ptr, "use_animated_time"));
                        uiItemR(subcolumn, &strip_ptr, "strip_time", 0, NULL, 0);
 }
 
index f04cefc6d2b95feb672aaae8e88cfe9465b9ab6e..e3013cc250717d1c2df69a2156c0cb3158d82181 100644 (file)
@@ -329,12 +329,12 @@ static void node_shader_buts_mapping(uiLayout *layout, bContext *C, PointerRNA *
        uiItemR(row, ptr, "scale", 0, "", 0);
        
        row= uiLayoutRow(layout, 1);
-       uiItemR(row, ptr, "clamp_minimum", 0, "Min", 0);
-       uiItemR(row, ptr, "minimum", 0, "", 0);
+       uiItemR(row, ptr, "use_min", 0, "Min", 0);
+       uiItemR(row, ptr, "min", 0, "", 0);
        
        row= uiLayoutRow(layout, 1);
-       uiItemR(row, ptr, "clamp_maximum", 0, "Max", 0);
-       uiItemR(row, ptr, "maximum", 0, "", 0);
+       uiItemR(row, ptr, "use_max", 0, "Max", 0);
+       uiItemR(row, ptr, "max", 0, "", 0);
        
 }
 
@@ -482,7 +482,7 @@ static void node_composit_buts_image(uiLayout *layout, bContext *C, PointerRNA *
                uiItemR(col, ptr, "start", 0, NULL, 0);
                uiItemR(col, ptr, "offset", 0, NULL, 0);
                uiItemR(col, ptr, "cyclic", 0, NULL, 0);
-               uiItemR(col, ptr, "auto_refresh", UI_ITEM_R_ICON_ONLY, NULL, 0);
+               uiItemR(col, ptr, "use_auto_refresh", UI_ITEM_R_ICON_ONLY, NULL, 0);
        }
 
        col= uiLayoutColumn(layout, 0);
@@ -543,8 +543,8 @@ static void node_composit_buts_blur(uiLayout *layout, bContext *C, PointerRNA *p
                uiItemR(col, ptr, "factor_y", 0, "Y", 0);
        }
        else {
-               uiItemR(col, ptr, "sizex", 0, "X", 0);
-               uiItemR(col, ptr, "sizey", 0, "Y", 0);
+               uiItemR(col, ptr, "size_x", 0, "X", 0);
+               uiItemR(col, ptr, "size_y", 0, "Y", 0);
        }
 }
 
@@ -591,13 +591,13 @@ static void node_composit_buts_defocus(uiLayout *layout, bContext *C, PointerRNA
        uiItemR(col, ptr, "bokeh", 0, "", 0);
        uiItemR(col, ptr, "angle", 0, NULL, 0);
 
-       uiItemR(layout, ptr, "gamma_correction", 0, NULL, 0);
+       uiItemR(layout, ptr, "use_gamma_correction", 0, NULL, 0);
 
        col = uiLayoutColumn(layout, 0);
        uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_zbuffer")==1);
        uiItemR(col, ptr, "f_stop", 0, NULL, 0);
 
-       uiItemR(layout, ptr, "max_blur", 0, NULL, 0);
+       uiItemR(layout, ptr, "blur_max", 0, NULL, 0);
        uiItemR(layout, ptr, "threshold", 0, NULL, 0);
 
        col = uiLayoutColumn(layout, 0);
@@ -637,7 +637,7 @@ static void node_composit_buts_glare(uiLayout *layout, bContext *C, PointerRNA *
                uiItemR(layout, ptr, "fade", UI_ITEM_R_SLIDER, NULL, 0);
                
                if (RNA_enum_get(ptr, "glare_type")== 0) 
-                       uiItemR(layout, ptr, "rotate_45", 0, NULL, 0);
+                       uiItemR(layout, ptr, "use_rotate_45", 0, NULL, 0);
        }
        if (RNA_enum_get(ptr, "glare_type")== 1) {
                uiItemR(layout, ptr, "size", 0, NULL, 0);
@@ -668,10 +668,10 @@ static void node_composit_buts_lensdist(uiLayout *layout, bContext *C, PointerRN
        uiLayout *col;
 
        col= uiLayoutColumn(layout, 0);
-       uiItemR(col, ptr, "projector", 0, NULL, 0);
+       uiItemR(col, ptr, "use_projector", 0, NULL, 0);
 
        col = uiLayoutColumn(col, 0);
-       uiLayoutSetActive(col, RNA_boolean_get(ptr, "projector")==0);
+       uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_projector")==0);
        uiItemR(col, ptr, "jitter", 0, NULL, 0);
        uiItemR(col, ptr, "fit", 0, NULL, 0);
 }
@@ -686,8 +686,8 @@ static void node_composit_buts_vecblur(uiLayout *layout, bContext *C, PointerRNA
        
        col= uiLayoutColumn(layout, 1);
        uiItemL(col, "Speed:", 0);
-       uiItemR(col, ptr, "min_speed", 0, "Min", 0);
-       uiItemR(col, ptr, "max_speed", 0, "Max", 0);
+       uiItemR(col, ptr, "speed_min", 0, "Min", 0);
+       uiItemR(col, ptr, "speed_max", 0, "Max", 0);
 
        uiItemR(layout, ptr, "curved", 0, NULL, 0);
 }
@@ -706,13 +706,13 @@ static void node_composit_buts_crop(uiLayout *layout, bContext *C, PointerRNA *p
 {
        uiLayout *col;
        
-       uiItemR(layout, ptr, "crop_size", 0, NULL, 0);
+       uiItemR(layout, ptr, "use_crop_size", 0, NULL, 0);
        
        col= uiLayoutColumn(layout, 1);
-       uiItemR(col, ptr, "x1", 0, "Left", 0);
-       uiItemR(col, ptr, "x2", 0, "Right", 0);
-       uiItemR(col, ptr, "y1", 0, "Up", 0);
-       uiItemR(col, ptr, "y2", 0, "Down", 0);
+       uiItemR(col, ptr, "min_x", 0, "Left", 0);
+       uiItemR(col, ptr, "max_x", 0, "Right", 0);
+       uiItemR(col, ptr, "min_y", 0, "Up", 0);
+       uiItemR(col, ptr, "max_y", 0, "Down", 0);
 }
 
 static void node_composit_buts_splitviewer(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -751,7 +751,7 @@ static void node_composit_buts_alphaover(uiLayout *layout, bContext *C, PointerR
        uiLayout *col;
        
        col =uiLayoutColumn(layout, 1);
-       uiItemR(col, ptr, "convert_premul", 0, NULL, 0);
+       uiItemR(col, ptr, "use_premultiply", 0, NULL, 0);
        uiItemR(col, ptr, "premul", 0, NULL, 0);
 }
 
@@ -797,17 +797,17 @@ static void node_composit_buts_color_spill(uiLayout *layout, bContext *C, Pointe
        uiItemR(row, ptr, "channel", UI_ITEM_R_EXPAND, NULL, 0);
 
    col= uiLayoutColumn(layout, 0);
-   uiItemR(col, ptr, "algorithm", 0, NULL, 0);
+   uiItemR(col, ptr, "limit_method", 0, NULL, 0);
 
-   if(RNA_enum_get(ptr, "algorithm")==0) {
+   if(RNA_enum_get(ptr, "limit_method")==0) {
          uiItemL(col, "Limiting Channel:", 0);
          row=uiLayoutRow(col,0);
          uiItemR(row, ptr, "limit_channel", UI_ITEM_R_EXPAND, NULL, 0);
    }
 
    uiItemR(col, ptr, "ratio", UI_ITEM_R_SLIDER, NULL, 0);
-   uiItemR(col, ptr, "unspill", 0, NULL, 0);   
-   if (RNA_enum_get(ptr, "unspill")== 1) {
+   uiItemR(col, ptr, "use_unspill", 0, NULL, 0);   
+   if (RNA_enum_get(ptr, "use_unspill")== 1) {
          uiItemR(col, ptr, "unspill_red", UI_ITEM_R_SLIDER, NULL, 0);
          uiItemR(col, ptr, "unspill_green", UI_ITEM_R_SLIDER, NULL, 0);
          uiItemR(col, ptr, "unspill_blue", UI_ITEM_R_SLIDER, NULL, 0);
@@ -819,7 +819,7 @@ static void node_composit_buts_chroma_matte(uiLayout *layout, bContext *C, Point
        uiLayout *col;
        
        col= uiLayoutColumn(layout, 0);
-       uiItemR(col, ptr, "acceptance", 0, NULL, 0);
+       uiItemR(col, ptr, "tolerance", 0, NULL, 0);
        uiItemR(col, ptr, "cutoff", 0, NULL, 0);
        
        col= uiLayoutColumn(layout, 1);
@@ -853,8 +853,8 @@ static void node_composit_buts_channel_matte(uiLayout *layout, bContext *C, Poin
 
        col =uiLayoutColumn(layout, 0);
 
-   uiItemR(col, ptr, "algorithm", 0, NULL, 0);
-   if(RNA_enum_get(ptr, "algorithm")==0) {
+   uiItemR(col, ptr, "limit_method", 0, NULL, 0);
+   if(RNA_enum_get(ptr, "limit_method")==0) {
          uiItemL(col, "Limiting Channel:", 0);
          row=uiLayoutRow(col,0);
          uiItemR(row, ptr, "limit_channel", UI_ITEM_R_EXPAND, NULL, 0);
@@ -893,7 +893,7 @@ static void node_composit_buts_file_output(uiLayout *layout, bContext *C, Pointe
        
        row= uiLayoutRow(layout, 0);
        if (RNA_enum_get(ptr, "image_type")== R_OPENEXR) {
-               uiItemR(row, ptr, "exr_half", 0, NULL, 0);
+               uiItemR(row, ptr, "use_exr_half", 0, NULL, 0);
                uiItemR(row, ptr, "exr_codec", 0, "", 0);
        }
        else if (RNA_enum_get(ptr, "image_type")== R_JPEG90) {
@@ -941,9 +941,9 @@ static void node_composit_buts_colorbalance(uiLayout *layout, bContext *C, Point
 {
        uiLayout *split, *col, *row;
        
-       uiItemR(layout, ptr, "correction_formula", 0, NULL, 0);
+       uiItemR(layout, ptr, "correction_method", 0, NULL, 0);
        
-       if (RNA_enum_get(ptr, "correction_formula")== 0) {
+       if (RNA_enum_get(ptr, "correction_method")== 0) {
        
                split = uiLayoutSplit(layout, 0, 0);
                col = uiLayoutColumn(split, 0);
@@ -1164,7 +1164,7 @@ static void node_texture_buts_proc(uiLayout *layout, bContext *C, PointerRNA *pt
                case TEX_BLEND:
                        uiItemR(col, &tex_ptr, "progression", 0, "", 0);
                        row= uiLayoutRow(col, 0);
-                       uiItemR(row, &tex_ptr, "flip_axis", UI_ITEM_R_EXPAND, NULL, 0);
+                       uiItemR(row, &tex_ptr, "use_flip_axis", UI_ITEM_R_EXPAND, NULL, 0);
                        break;
 
                case TEX_MARBLE:
@@ -1173,14 +1173,14 @@ static void node_texture_buts_proc(uiLayout *layout, bContext *C, PointerRNA *pt
                        row= uiLayoutRow(col, 0);
                        uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, 0);
                        row= uiLayoutRow(col, 0);
-                       uiItemR(row, &tex_ptr, "noisebasis2", UI_ITEM_R_EXPAND, NULL, 0);
+                       uiItemR(row, &tex_ptr, "noisebasis_2", UI_ITEM_R_EXPAND, NULL, 0);
                        break;
 
                case TEX_WOOD:
                        uiItemR(col, &tex_ptr, "noise_basis", 0, "", 0);
                        uiItemR(col, &tex_ptr, "stype", 0, "", 0);
                        row= uiLayoutRow(col, 0);
-                       uiItemR(row, &tex_ptr, "noisebasis2", UI_ITEM_R_EXPAND, NULL, 0);
+                       uiItemR(row, &tex_ptr, "noisebasis_2", UI_ITEM_R_EXPAND, NULL, 0);
                        row= uiLayoutRow(col, 0);
                        uiLayoutSetActive(row, !(RNA_enum_get(&tex_ptr, "stype")==TEX_BAND || RNA_enum_get(&tex_ptr, "stype")==TEX_RING)); 
                        uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, 0);
index 56b1922b90fee12115b68b54fd9234ecd5e8bc59..1fcd53d5d0f73dea436118f383e3fc097b26dc69 100644 (file)
@@ -203,13 +203,13 @@ static void rna_def_animviz_ghosts(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        /* Around Current Ranges */
-       prop= RNA_def_property(srna, "before_current", PROP_INT, PROP_TIME);
+       prop= RNA_def_property(srna, "frame_before", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "ghost_bc");
        RNA_def_property_range(prop, 0, 30);
        RNA_def_property_ui_text(prop, "Before Current", "Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
-       prop= RNA_def_property(srna, "after_current", PROP_INT, PROP_TIME);
+       prop= RNA_def_property(srna, "frame_after", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "ghost_ac");
        RNA_def_property_range(prop, 0, 30);
        RNA_def_property_ui_text(prop, "After Current", "Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)");
@@ -290,13 +290,13 @@ static void rna_def_animviz_paths(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        /* Around Current Ranges */
-       prop= RNA_def_property(srna, "before_current", PROP_INT, PROP_TIME);
+       prop= RNA_def_property(srna, "frame_before", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "path_bc");
        RNA_def_property_range(prop, 1, MAXFRAMEF/2);
        RNA_def_property_ui_text(prop, "Before Current", "Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
-       prop= RNA_def_property(srna, "after_current", PROP_INT, PROP_TIME);
+       prop= RNA_def_property(srna, "frame_after", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "path_ac");
        RNA_def_property_range(prop, 1, MAXFRAMEF/2);
        RNA_def_property_ui_text(prop, "After Current", "Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)");
index a2f75a6316396ba81255be3e8cce072ec06c8a9d..8b21fd2c80acfac5f910c21862facfd66c5d3014 100644 (file)
@@ -765,7 +765,8 @@ static void rna_def_armature(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Pose Position", "Show armature in binding pose or final posed state");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       prop= RNA_def_property(srna, "drawtype", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "draw_type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "drawtype");
        RNA_def_property_enum_items(prop, prop_drawtype_items);
        RNA_def_property_ui_text(prop, "Draw Type", "");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
@@ -791,7 +792,7 @@ static void rna_def_armature(BlenderRNA *brna)
        RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
        
                /* layer protection */
-       prop= RNA_def_property(srna, "layer_protection", PROP_BOOLEAN, PROP_LAYER);
+       prop= RNA_def_property(srna, "layers_protected", PROP_BOOLEAN, PROP_LAYER);
        RNA_def_property_boolean_sdna(prop, NULL, "layer_protected", 1);
        RNA_def_property_array(prop, 32);
        RNA_def_property_ui_text(prop, "Layer Proxy Protection", "Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo"); 
@@ -810,18 +811,18 @@ static void rna_def_armature(BlenderRNA *brna)
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
        RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
        
-       prop= RNA_def_property(srna, "delay_deform", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_deform_delay", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DELAYDEFORM);
        RNA_def_property_ui_text(prop, "Delay Deform", "Don't deform children when manipulating bones in Pose Mode");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       prop= RNA_def_property(srna, "x_axis_mirror", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_MIRROR_EDIT);
        RNA_def_property_ui_text(prop, "X-Axis Mirror", "Apply changes to matching bone on opposite side of X-Axis");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
        RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
        
-       prop= RNA_def_property(srna, "auto_ik", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_auto_ik", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_AUTO_IK);
        RNA_def_property_ui_text(prop, "Auto IK", "Add temporaral IK constraints while grabbing bones in Pose Mode");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
@@ -846,17 +847,17 @@ static void rna_def_armature(BlenderRNA *brna)
 // XXX depreceated ....... old animviz for armatures only
        
                /* deformflag */
-       prop= RNA_def_property(srna, "deform_vertexgroups", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_deform_vertex_groups", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_VGROUP);
        RNA_def_property_ui_text(prop, "Deform Vertex Groups", "Enable Vertex Groups when defining deform");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       prop= RNA_def_property(srna, "deform_envelope", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_deform_envelopes", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_ENVELOPE);
        RNA_def_property_ui_text(prop, "Deform Envelopes", "Enable Bone Envelopes when defining deform");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       prop= RNA_def_property(srna, "deform_quaternion", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_deform_preserve_volume", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_QUATERNION);
        RNA_def_property_ui_text(prop, "Use Dual Quaternion Deformation", "Enable deform rotation with Quaternions");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
index 58ecb78d3b8096516061b926569ef3c3b1de5e87..e40bbcbbf5045f0684efc56940a387ad7f4e0fe6 100644 (file)
@@ -273,7 +273,7 @@ static void rna_def_cloth_sim_settings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Air Damping", "Air has normally some thickness which slows falling things down");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
 
-       prop= RNA_def_property(srna, "pin_cloth", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_pin_cloth", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", CLOTH_SIMSETTINGS_FLAG_GOAL);
        RNA_def_property_ui_text(prop, "Pin Cloth", "Enable pinning of cloth vertices to other objects/positions");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
@@ -292,7 +292,7 @@ static void rna_def_cloth_sim_settings(BlenderRNA *brna)
 
        /* springs */
 
-       prop= RNA_def_property(srna, "stiffness_scaling", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_stiffness_scale", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", CLOTH_SIMSETTINGS_FLAG_SCALING);
        RNA_def_property_ui_text(prop, "Stiffness Scaling", "If enabled, stiffness can be scaled along a weight painted vertex group");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
@@ -407,12 +407,12 @@ static void rna_def_cloth_collision_settings(BlenderRNA *brna)
 
        /* general collision */
 
-       prop= RNA_def_property(srna, "enable_collision", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_collision", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", CLOTH_COLLSETTINGS_FLAG_ENABLED);
        RNA_def_property_ui_text(prop, "Enable Collision", "Enable collisions with other objects");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
        
-       prop= RNA_def_property(srna, "min_distance", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "distance_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "epsilon");
        RNA_def_property_range(prop, 0.001f, 1.0f);
        RNA_def_property_ui_text(prop, "Minimum Distance", "Minimum distance between collision objects before collision response takes in");
@@ -431,12 +431,12 @@ static void rna_def_cloth_collision_settings(BlenderRNA *brna)
 
        /* self collision */
 
-       prop= RNA_def_property(srna, "enable_self_collision", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_self_collision", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", CLOTH_COLLSETTINGS_FLAG_SELF);
        RNA_def_property_ui_text(prop, "Enable Self Collision", "Enable self collisions");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
        
-       prop= RNA_def_property(srna, "self_min_distance", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "self_distance_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "selfepsilon");
        RNA_def_property_range(prop, 0.5f, 1.0f);
        RNA_def_property_ui_text(prop, "Self Minimum Distance", "0.5 means no distance at all, 1.0 is maximum distance");
index d1319d99805d0d79fc17504915c0f7161ab305dd..38242628fd157dce6356833da05986e3e5833251 100644 (file)
@@ -437,7 +437,7 @@ static void rna_def_constraint_python(BlenderRNA *brna)
        RNA_def_property_struct_type(prop, "ConstraintTarget");
        RNA_def_property_ui_text(prop, "Targets", "Target Objects");
 
-       prop= RNA_def_property(srna, "number_of_targets", PROP_INT, PROP_NONE);
+       prop= RNA_def_property(srna, "target_count", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "tarnum");
        RNA_def_property_ui_text(prop, "Number of Targets", "Usually only 1-3 are needed");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
@@ -510,7 +510,7 @@ static void rna_def_constraint_kinematic(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Orientation Weight", "For Tree-IK: Weight of orientation control for this target");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "chain_length", PROP_INT, PROP_NONE);
+       prop= RNA_def_property(srna, "chain_count", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "rootbone");
        RNA_def_property_range(prop, 0, 255);
        RNA_def_property_ui_text(prop, "Chain Length", "How many bones are included in the IK effect - 0 uses all bones");
@@ -521,28 +521,28 @@ static void rna_def_constraint_kinematic(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Use Tail", "Include bone's tail as last element in chain");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
 
-       prop= RNA_def_property(srna, "axis_reference", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "reference_axis", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
        RNA_def_property_enum_items(prop, constraint_ik_axisref_items);
        RNA_def_property_ui_text(prop, "Axis Reference", "Constraint axis Lock options relative to Bone or Target reference");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
 
-       prop= RNA_def_property(srna, "use_position", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_location", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONSTRAINT_IK_POS);
        RNA_def_property_ui_text(prop, "Position", "Chain follows position of target");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
 
-       prop= RNA_def_property(srna, "pos_lock_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_location_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_IK_NO_POS_X);
        RNA_def_property_ui_text(prop, "Lock X Pos", "Constraint position along X axis");
        RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Constraint_dependency_update");
 
-       prop= RNA_def_property(srna, "pos_lock_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_location_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_IK_NO_POS_Y);
        RNA_def_property_ui_text(prop, "Lock Y Pos", "Constraint position along Y axis");
        RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Constraint_dependency_update");
 
-       prop= RNA_def_property(srna, "pos_lock_z", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_location_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_IK_NO_POS_Z);
        RNA_def_property_ui_text(prop, "Lock Z Pos", "Constraint position along Z axis");
        RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Constraint_dependency_update");
@@ -552,17 +552,17 @@ static void rna_def_constraint_kinematic(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Rotation", "Chain follows rotation of target");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
 
-       prop= RNA_def_property(srna, "rot_lock_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_rotation_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_IK_NO_ROT_X);
        RNA_def_property_ui_text(prop, "Lock X Rot", "Constraint rotation along X axis");
        RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Constraint_dependency_update");
 
-       prop= RNA_def_property(srna, "rot_lock_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_rotation_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_IK_NO_ROT_Y);
        RNA_def_property_ui_text(prop, "Lock Y Rot", "Constraint rotation along Y axis");
        RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Constraint_dependency_update");
 
-       prop= RNA_def_property(srna, "rot_lock_z", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_rotation_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_IK_NO_ROT_Z);
        RNA_def_property_ui_text(prop, "Lock Z Rot", "Constraint rotation along Z axis");
        RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Constraint_dependency_update");
@@ -650,7 +650,7 @@ static void rna_def_constraint_track_to(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Up Axis", "Axis that points upward");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "target_z", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_target_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", TARGET_Z_UP);
        RNA_def_property_ui_text(prop, "Target Z", "Target's Z axis, not World Z axis, will constraint the Up direction");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -978,14 +978,14 @@ static void rna_def_constraint_action(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "End Frame", "Last frame of the Action to use");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "max");
        RNA_def_property_range(prop, -1000.f, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum", "Maximum value for target channel range");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_ActionConstraint_minmax_range");
 
-       prop= RNA_def_property(srna, "minimum", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "min");
        RNA_def_property_range(prop, -1000.f, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum", "Minimum value for target channel range");
@@ -1100,7 +1100,7 @@ static void rna_def_constraint_follow_path(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Follow Curve", "Object will follow the heading and banking of the curve");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
-       prop= RNA_def_property(srna, "use_fixed_position", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_fixed_location", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "followflag", FOLLOWPATH_STATIC);
        RNA_def_property_ui_text(prop, "Fixed Position", "Object will stay locked to a single point somewhere along the length of the curve regardless of time");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1161,7 +1161,7 @@ static void rna_def_constraint_stretch_to(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Keep Axis", "Axis to maintain during stretch");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "original_length", PROP_FLOAT, PROP_DISTANCE);
+       prop= RNA_def_property(srna, "rest_length", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "orglength");
        RNA_def_property_range(prop, 0.0, 100.f);
        RNA_def_property_ui_text(prop, "Original Length", "Length at rest position");
@@ -1354,7 +1354,7 @@ static void rna_def_constraint_transform(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Map To Z From", "The source axis constrained object's Z axis uses");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "extrapolate_motion", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_motion_extrapolate", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "expo", CLAMPTO_CYCLIC);
        RNA_def_property_ui_text(prop, "Extrapolate Motion", "Extrapolate ranges");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1441,73 +1441,73 @@ static void rna_def_constraint_location_limit(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Limit Location Constraint", "Limits the location of the constrained object");
        RNA_def_struct_sdna_from(srna, "bLocLimitConstraint", "data");
 
-       prop= RNA_def_property(srna, "use_minimum_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_XMIN);
        RNA_def_property_ui_text(prop, "Minimum X", "Use the minimum X value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_minimum_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_YMIN);
        RNA_def_property_ui_text(prop, "Minimum Y", "Use the minimum Y value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_minimum_z", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_ZMIN);
        RNA_def_property_ui_text(prop, "Minimum Z", "Use the minimum Z value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_maximum_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_XMAX);
        RNA_def_property_ui_text(prop, "Maximum X", "Use the maximum X value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_maximum_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_YMAX);
        RNA_def_property_ui_text(prop, "Maximum Y", "Use the maximum Y value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_maximum_z", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_ZMAX);
        RNA_def_property_ui_text(prop, "Maximum Z", "Use the maximum Z value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_x", PROP_FLOAT, PROP_DISTANCE);
+       prop= RNA_def_property(srna, "min_x", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "xmin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_y", PROP_FLOAT, PROP_DISTANCE);
+       prop= RNA_def_property(srna, "min_y", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "ymin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_z", PROP_FLOAT, PROP_DISTANCE);
+       prop= RNA_def_property(srna, "min_z", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "zmin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum Z", "Lowest Z value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_x", PROP_FLOAT, PROP_DISTANCE);
+       prop= RNA_def_property(srna, "max_x", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "xmax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_y", PROP_FLOAT, PROP_DISTANCE);
+       prop= RNA_def_property(srna, "max_y", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "ymax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_z", PROP_FLOAT, PROP_DISTANCE);
+       prop= RNA_def_property(srna, "max_z", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "zmax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum Z", "Highest Z value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "limit_transform", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_transform_limit", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag2", LIMIT_TRANSFORM);
        RNA_def_property_ui_text(prop, "For Transform", "Transforms are affected by this constraint as well");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1537,43 +1537,43 @@ static void rna_def_constraint_rotation_limit(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Limit Z", "Use the minimum Z value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_x", PROP_FLOAT, PROP_ANGLE);
+       prop= RNA_def_property(srna, "min_x", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "xmin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_y", PROP_FLOAT, PROP_ANGLE);
+       prop= RNA_def_property(srna, "min_y", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "ymin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_z", PROP_FLOAT, PROP_ANGLE);
+       prop= RNA_def_property(srna, "min_z", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "zmin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum Z", "Lowest Z value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_x", PROP_FLOAT, PROP_ANGLE);
+       prop= RNA_def_property(srna, "max_x", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "xmax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_y", PROP_FLOAT, PROP_ANGLE);
+       prop= RNA_def_property(srna, "max_y", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "ymax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_z", PROP_FLOAT, PROP_ANGLE);
+       prop= RNA_def_property(srna, "max_z", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "zmax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum Z", "Highest Z value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "limit_transform", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_transform_limit", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag2", LIMIT_TRANSFORM);
        RNA_def_property_ui_text(prop, "For Transform", "Transforms are affected by this constraint as well");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1588,73 +1588,73 @@ static void rna_def_constraint_size_limit(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Limit Size Constraint", "Limits the scaling of the constrained object");
        RNA_def_struct_sdna_from(srna, "bSizeLimitConstraint", "data");
 
-       prop= RNA_def_property(srna, "use_minimum_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_XMIN);
        RNA_def_property_ui_text(prop, "Minimum X", "Use the minimum X value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_minimum_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_YMIN);
        RNA_def_property_ui_text(prop, "Minimum Y", "Use the minimum Y value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_minimum_z", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_ZMIN);
        RNA_def_property_ui_text(prop, "Minimum Z", "Use the minimum Z value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_maximum_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_XMAX);
        RNA_def_property_ui_text(prop, "Maximum X", "Use the maximum X value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_maximum_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_YMAX);
        RNA_def_property_ui_text(prop, "Maximum Y", "Use the maximum Y value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "use_maximum_z", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LIMIT_ZMAX);
        RNA_def_property_ui_text(prop, "Maximum Z", "Use the maximum Z value");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_x", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "xmin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_y", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "ymin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "minimum_z", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min_z", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "zmin");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Minimum Z", "Lowest Z value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_x", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "xmax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_y", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "ymax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "maximum_z", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max_z", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "zmax");
        RNA_def_property_range(prop, -1000.0, 1000.f);
        RNA_def_property_ui_text(prop, "Maximum Z", "Highest Z value to allow");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-       prop= RNA_def_property(srna, "limit_transform", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_transform_limit", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag2", LIMIT_TRANSFORM);
        RNA_def_property_ui_text(prop, "For Transform", "Transforms are affected by this constraint as well");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1801,7 +1801,7 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna)
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
        
-       prop= RNA_def_property(srna, "chain_length", PROP_INT, PROP_NONE);
+       prop= RNA_def_property(srna, "chain_count", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "chainlen");
        RNA_def_property_range(prop, 1, 255); // TODO: this should really check the max length of the chain the constraint is attached to
        RNA_def_property_ui_text(prop, "Chain Length", "How many bones are included in the chain");
@@ -1818,17 +1818,17 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
        /* settings */
-       prop= RNA_def_property(srna, "chain_offset", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_chain_offset", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONSTRAINT_SPLINEIK_NO_ROOT);
        RNA_def_property_ui_text(prop, "Chain Offset", "Offset the entire chain relative to the root joint");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
-       prop= RNA_def_property(srna, "even_divisions", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_even_divisions", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONSTRAINT_SPLINEIK_EVENSPLITS);
        RNA_def_property_ui_text(prop, "Even Divisions", "Ignore the relative lengths of the bones when fitting to the curve");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
-       prop= RNA_def_property(srna, "y_stretch", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_y_stretch", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_SPLINEIK_SCALE_LIMITED);
        RNA_def_property_ui_text(prop, "Y Stretch", "Stretch the Y axis of the bones to fit the curve");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1838,7 +1838,7 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Use Curve Radius", "Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, on top of XZ Scale mode");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
-       prop= RNA_def_property(srna, "xz_scaling_mode", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "xz_scale_mode", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "xzScaleMode");
        RNA_def_property_enum_items(prop, splineik_xz_scale_mode);
        RNA_def_property_ui_text(prop, "XZ Scale Mode", "Method used for determining the scaling of the X and Z axes of the bones");
@@ -1883,7 +1883,7 @@ static void rna_def_constraint_pivot(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
        
        /* pivot offset */
-       prop= RNA_def_property(srna, "use_relative_position", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_relative_location", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", PIVOTCON_FLAG_OFFSET_ABS);
        RNA_def_property_ui_text(prop, "Use Relative Offset", "Offset will be an absolute point in space instead of relative to the target");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1894,7 +1894,7 @@ static void rna_def_constraint_pivot(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
        /* rotation-based activation */
-       prop= RNA_def_property(srna, "enabled_rotation_range", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "rotation_range", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "rotAxis");
        RNA_def_property_enum_items(prop, pivot_rotAxis_items);
        RNA_def_property_ui_text(prop, "Enabled Rotation Range", "Rotation range on which pivoting should occur");
@@ -1960,7 +1960,7 @@ void RNA_def_constraint(BlenderRNA *brna)
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONSTRAINT_ACTIVE);
        RNA_def_property_ui_text(prop, "Active", "Constraint is the one being edited ");
        
-       prop= RNA_def_property(srna, "proxy_local", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "is_proxy_local", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONSTRAINT_PROXY_LOCAL);
        RNA_def_property_ui_text(prop, "Proxy Local", "Constraint was added in this proxy instance (i.e. did not belong to source Armature)");
        
index e3e907808255872c3a44759d5c8e3162a7c360b1..423e5e4d20356734ebf6ae5234feca878c2842d2 100644 (file)
@@ -909,17 +909,17 @@ static void rna_def_charinfo(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Text Character Format", "Text character formatting settings");
        
        /* flags */
-       prop= RNA_def_property(srna, "bold", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_bold", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_BOLD);
        RNA_def_property_ui_text(prop, "Bold", "");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
        
-       prop= RNA_def_property(srna, "italic", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_italic", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_ITALIC);
        RNA_def_property_ui_text(prop, "Italic", "");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
        
-       prop= RNA_def_property(srna, "underline", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_underline", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_UNDERLINE);
        RNA_def_property_ui_text(prop, "Underline", "");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
@@ -1108,7 +1108,7 @@ static void rna_def_curve(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Bevel Resolution", "Bevel resolution when depth is non-zero and no specific bevel object has been defined");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
        
-       prop= RNA_def_property(srna, "width", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "width");
        RNA_def_property_ui_range(prop, 0, 2.0, 0.1, 0);
        RNA_def_property_ui_text(prop, "Width", "Scale the original width (1.0) based on given factor");
index 6ef41830fa187237b99e84fb7cf49da144451472..68060e2cfe3f84734dfd5788efa0579f94bd9526 100644 (file)
@@ -228,7 +228,7 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
        RNA_def_property_enum_items(prop, quality_items);
        RNA_def_property_ui_text(prop, "Render Display Mode", "How to display the mesh for rendering");
 
-       prop= RNA_def_property(srna, "reverse_frames", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE);
        RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse fluid frames");
 
@@ -250,7 +250,7 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
        RNA_def_property_range(prop, -1000.1, 1000.1);
        RNA_def_property_ui_text(prop, "Gravity", "Gravity in X, Y and Z direction");
        
-       prop= RNA_def_property(srna, "override_time", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_time_override", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_OVERRIDE_TIME);
        RNA_def_property_ui_text(prop, "Override Time", "Use a custom start and end time (in seconds) instead of the scene's timeline");
        
@@ -264,7 +264,7 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
        RNA_def_property_range(prop, 0, 100);
        RNA_def_property_ui_text(prop, "End Time", "Simulation time of the last blender frame (in seconds)");
        
-       prop= RNA_def_property(srna, "real_world_size", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "simulation_scale", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "realsize");
        RNA_def_property_range(prop, 0.001, 10);
        RNA_def_property_ui_text(prop, "Real World Size", "Size of the simulation domain in metres");
@@ -300,7 +300,7 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
 
        rna_def_fluidsim_slip(srna);
 
-       prop= RNA_def_property(srna, "surface_smoothing", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "surface_smooth", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "surfaceSmoothing");
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_range(prop, 0.0, 5.0);
@@ -312,7 +312,7 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
        RNA_def_property_range(prop, 0, 5);
        RNA_def_property_ui_text(prop, "Surface Subdivisions", "Number of isosurface subdivisions. This is necessary for the inclusion of particles into the surface generation. Warning - can lead to longer computation times!");
 
-       prop= RNA_def_property(srna, "generate_speed_vectors", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_speed_vectors", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "domainNovecgen", 0);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_ui_text(prop, "Generate Speed Vectors", "Generate speed vectors for vector blur");
@@ -348,7 +348,7 @@ static void rna_def_fluidsim_volume(StructRNA *srna)
        RNA_def_property_enum_items(prop, volume_type_items);
        RNA_def_property_ui_text(prop, "Volume Initialization", "Volume initialization type");
 
-       prop= RNA_def_property(srna, "export_animated_mesh", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_animated_mesh", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "domainNovecgen", 0);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_ui_text(prop, "Export Animated Mesh", "Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it");
@@ -420,7 +420,7 @@ static void rna_def_fluidsim_inflow(BlenderRNA *brna)
        RNA_def_property_range(prop, -1000.1, 1000.1);
        RNA_def_property_ui_text(prop, "Inflow Velocity", "Initial velocity of fluid");
 
-       prop= RNA_def_property(srna, "local_coordinates", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_local_coords", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSINFLOW_LOCALCOORD);
        RNA_def_property_ui_text(prop, "Local Coordinates", "Use local coordinates for inflow. (e.g. for rotating objects)");
@@ -447,11 +447,11 @@ static void rna_def_fluidsim_particle(BlenderRNA *brna)
        RNA_def_struct_sdna(srna, "FluidsimSettings");
        RNA_def_struct_ui_text(srna, "Particle Fluid Simulation Settings", "Fluid simulation settings for objects storing fluid particles generated by the simulation");
 
-       prop= RNA_def_property(srna, "drops", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_drops", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_DROP);
        RNA_def_property_ui_text(prop, "Drops", "Show drop particles");
 
-       prop= RNA_def_property(srna, "floats", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_floats", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_FLOAT);
        RNA_def_property_ui_text(prop, "Floats", "Show floating foam particles");
 
@@ -523,7 +523,7 @@ static void rna_def_fluidsim_control(BlenderRNA *brna)
        RNA_def_property_range(prop, 5.0, 100.0);
        RNA_def_property_ui_text(prop, "Quality", "Specifies the quality which is used for object sampling. (higher = better but slower)");
 
-       prop= RNA_def_property(srna, "reverse_frames", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse control object movement");
index 7e60572ec801c52d8b7fc2a9e43ac96a7a160e48..ea4821be9d950d7a8eeb148375e86b83e3cc7fcf 100644 (file)
@@ -223,7 +223,7 @@ static void rna_def_imageuser(BlenderRNA *brna)
        srna= RNA_def_struct(brna, "ImageUser", NULL);
        RNA_def_struct_ui_text(srna, "Image User", "Parameters defining how an Image datablock is used by another datablock");
 
-       prop= RNA_def_property(srna, "auto_refresh", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_ANIM_ALWAYS);
        RNA_def_property_ui_text(prop, "Auto Refresh", "Always refresh image on frame changes");
        RNA_def_property_update(prop, 0, "rna_ImageUser_update");
@@ -339,7 +339,7 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Fields", "Use fields of the image");
        RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, "rna_Image_fields_update");
 
-       prop= RNA_def_property(srna, "premultiply", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_premultiply", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_DO_PREMUL);
        RNA_def_property_ui_text(prop, "Premultiply", "Convert RGB from key alpha to premultiplied alpha");
        RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, "rna_Image_reload_update");
@@ -382,24 +382,24 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Display Aspect", "Display Aspect for this image, does not affect rendering");
        RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
 
-       prop= RNA_def_property(srna, "animated", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_animation", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "tpageflag", IMA_TWINANIM);
        RNA_def_property_ui_text(prop, "Animated", "Use as animated texture in the game engine");