change python scripts so modules which register with blender have a register() functi...
[blender.git] / release / scripts / ui / properties_material.py
index e0ff3959117116e92cde98a38d3429453570bbe8..cf705c8d693688ca180101638b41b76bb05d29fe 100644 (file)
@@ -1,10 +1,26 @@
-# This software is distributable under the terms of the GNU
-# General Public License (GPL) v2, the text of which can be found at
-# http://www.gnu.org/copyleft/gpl.html. Installing, importing or otherwise
-# using this module constitutes acceptance of the terms of this License.
+# ##### 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>
 import bpy
+from rna_prop_ui import PropertyPanel
+
+narrowui = 180
 
 
 def active_node_mat(mat):
@@ -20,6 +36,24 @@ def active_node_mat(mat):
     return None
 
 
+class MATERIAL_MT_sss_presets(bpy.types.Menu):
+    bl_label = "SSS Presets"
+    preset_subdir = "sss"
+    preset_operator = "script.python_file_run"
+    draw = bpy.types.Menu.draw_preset
+
+
+class MATERIAL_MT_specials(bpy.types.Menu):
+    bl_label = "Material Specials"
+
+    def draw(self, context):
+        layout = self.layout
+
+        layout.operator("object.material_slot_copy", icon='COPY_ID')
+        layout.operator("material.copy", icon='COPYDOWN')
+        layout.operator("material.paste", icon='PASTEDOWN')
+
+
 class MaterialButtonsPanel(bpy.types.Panel):
     bl_space_type = 'PROPERTIES'
     bl_region_type = 'WINDOW'
@@ -34,7 +68,7 @@ class MaterialButtonsPanel(bpy.types.Panel):
 
 class MATERIAL_PT_preview(MaterialButtonsPanel):
     bl_label = "Preview"
-    COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def draw(self, context):
         self.layout.template_preview(context.material)
@@ -43,7 +77,7 @@ class MATERIAL_PT_preview(MaterialButtonsPanel):
 class MATERIAL_PT_context_material(MaterialButtonsPanel):
     bl_label = ""
     bl_show_header = False
-    COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def poll(self, context):
         # An exception, dont call the parent poll func because
@@ -59,43 +93,59 @@ class MATERIAL_PT_context_material(MaterialButtonsPanel):
         ob = context.object
         slot = context.material_slot
         space = context.space_data
+        wide_ui = context.region.width > narrowui
 
         if ob:
             row = layout.row()
 
-            row.template_list(ob, "materials", ob, "active_material_index", rows=2)
+            row.template_list(ob, "material_slots", ob, "active_material_index", rows=2)
 
             col = row.column(align=True)
-            col.itemO("object.material_slot_add", icon='ICON_ZOOMIN', text="")
-            col.itemO("object.material_slot_remove", icon='ICON_ZOOMOUT', text="")
-            col.itemO("object.material_slot_copy", icon='ICON_COPY_ID', text="")
+            col.operator("object.material_slot_add", icon='ZOOMIN', text="")
+            col.operator("object.material_slot_remove", icon='ZOOMOUT', text="")
+
+            col.menu("MATERIAL_MT_specials", icon='DOWNARROW_HLT', text="")
 
             if ob.mode == 'EDIT':
                 row = layout.row(align=True)
-                row.itemO("object.material_slot_assign", text="Assign")
-                row.itemO("object.material_slot_select", text="Select")
-                row.itemO("object.material_slot_deselect", text="Deselect")
-
-        split = layout.split(percentage=0.65)
+                row.operator("object.material_slot_assign", text="Assign")
+                row.operator("object.material_slot_select", text="Select")
+                row.operator("object.material_slot_deselect", text="Deselect")
+
+        if wide_ui:
+            split = layout.split(percentage=0.65)
+
+            if ob:
+                split.template_ID(ob, "active_material", new="material.new")
+                row = split.row()
+                if slot:
+                    row.prop(slot, "link", text="")
+                else:
+                    row.label()
+            elif mat:
+                split.template_ID(space, "pin_id")
+                split.separator()
+        else:
+            if ob:
+                layout.template_ID(ob, "active_material", new="material.new")
+            elif mat:
+                layout.template_ID(space, "pin_id")
 
-        if ob:
-            split.template_ID(ob, "active_material", new="material.new")
-            row = split.row()
-            if slot:
-                row.itemR(slot, "link", text="")
+        if mat:
+            if wide_ui:
+                layout.prop(mat, "type", expand=True)
             else:
-                row.itemL()
-        elif mat:
-            split.template_ID(space, "pin_id")
-            split.itemS()
+                layout.prop(mat, "type", text="")
 
-        if mat:
-            layout.itemR(mat, "type", expand=True)
+
+class MATERIAL_PT_custom_props(MaterialButtonsPanel, PropertyPanel):
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
+    _context_path = "material"
 
 
 class MATERIAL_PT_shading(MaterialButtonsPanel):
     bl_label = "Shading"
-    COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def poll(self, context):
         mat = active_node_mat(context.material)
@@ -106,6 +156,7 @@ class MATERIAL_PT_shading(MaterialButtonsPanel):
         layout = self.layout
 
         mat = active_node_mat(context.material)
+        wide_ui = context.region.width > narrowui
 
         if mat.type in ('SURFACE', 'WIRE'):
             split = layout.split()
@@ -113,26 +164,27 @@ class MATERIAL_PT_shading(MaterialButtonsPanel):
             col = split.column()
             sub = col.column()
             sub.active = not mat.shadeless
-            sub.itemR(mat, "emit")
-            sub.itemR(mat, "ambient")
+            sub.prop(mat, "emit")
+            sub.prop(mat, "ambient")
             sub = col.column()
-            sub.itemR(mat, "translucency")
+            sub.prop(mat, "translucency")
 
-            col = split.column()
-            col.itemR(mat, "shadeless")
+            if wide_ui:
+                col = split.column()
+            col.prop(mat, "shadeless")
             sub = col.column()
             sub.active = not mat.shadeless
-            sub.itemR(mat, "tangent_shading")
-            sub.itemR(mat, "cubic")
+            sub.prop(mat, "tangent_shading")
+            sub.prop(mat, "cubic")
 
         elif mat.type == 'HALO':
-            layout.itemR(mat, "alpha")
+            layout.prop(mat, "alpha")
 
 
 class MATERIAL_PT_strand(MaterialButtonsPanel):
     bl_label = "Strand"
     bl_default_closed = True
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def poll(self, context):
         mat = context.material
@@ -144,62 +196,67 @@ class MATERIAL_PT_strand(MaterialButtonsPanel):
 
         mat = context.material # dont use node material
         tan = mat.strand
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
-        col = split.column(align=True)
-        col.itemL(text="Size:")
-        col.itemR(tan, "root_size", text="Root")
-        col.itemR(tan, "tip_size", text="Tip")
-        col.itemR(tan, "min_size", text="Minimum")
-        col.itemR(tan, "blender_units")
+        col = split.column()
+        sub = col.column(align=True)
+        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 = col.column()
         sub.active = (not mat.shadeless)
-        sub.itemR(tan, "tangent_shading")
-        col.itemR(tan, "shape")
+        sub.prop(tan, "tangent_shading")
+        col.prop(tan, "shape")
 
-        col = split.column()
-        col.itemL(text="Shading:")
-        col.itemR(tan, "width_fade")
+        if wide_ui:
+            col = split.column()
+        col.label(text="Shading:")
+        col.prop(tan, "width_fade")
         ob = context.object
         if ob and ob.type == 'MESH':
-            col.item_pointerR(tan, "uv_layer", ob.data, "uv_textures", text="")
+            col.prop_object(tan, "uv_layer", ob.data, "uv_textures", text="")
         else:
-            col.itemR(tan, "uv_layer", text="")
-        col.itemS()
+            col.prop(tan, "uv_layer", text="")
+        col.separator()
         sub = col.column()
         sub.active = (not mat.shadeless)
-        sub.itemR(tan, "surface_diffuse")
+        sub.prop(tan, "surface_diffuse")
         sub = col.column()
         sub.active = tan.surface_diffuse
-        sub.itemR(tan, "blend_distance", text="Distance")
+        sub.prop(tan, "blend_distance", text="Distance")
 
 
 class MATERIAL_PT_physics(MaterialButtonsPanel):
     bl_label = "Physics"
-    COMPAT_ENGINES = set(['BLENDER_GAME'])
+    COMPAT_ENGINES = {'BLENDER_GAME'}
 
     def draw(self, context):
         layout = self.layout
 
         phys = context.material.physics # dont use node material
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(phys, "distance")
-        col.itemR(phys, "friction")
-        col.itemR(phys, "align_to_normal")
+        col.prop(phys, "distance")
+        col.prop(phys, "friction")
+        col.prop(phys, "align_to_normal")
 
-        col = split.column()
-        col.itemR(phys, "force", slider=True)
-        col.itemR(phys, "elasticity", slider=True)
-        col.itemR(phys, "damp", slider=True)
+        if wide_ui:
+            col = split.column()
+        col.prop(phys, "force", slider=True)
+        col.prop(phys, "elasticity", slider=True)
+        col.prop(phys, "damp", slider=True)
 
 
 class MATERIAL_PT_options(MaterialButtonsPanel):
     bl_label = "Options"
-    COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def poll(self, context):
         mat = active_node_mat(context.material)
@@ -210,40 +267,42 @@ class MATERIAL_PT_options(MaterialButtonsPanel):
         layout = self.layout
 
         mat = active_node_mat(context.material)
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(mat, "traceable")
-        col.itemR(mat, "full_oversampling")
-        col.itemR(mat, "sky")
-        col.itemR(mat, "exclude_mist")
-        col.itemR(mat, "invert_z")
+        col.prop(mat, "traceable")
+        col.prop(mat, "full_oversampling")
+        col.prop(mat, "use_sky")
+        col.prop(mat, "exclude_mist")
+        col.prop(mat, "invert_z")
         sub = col.row()
-        sub.itemR(mat, "z_offset")
+        sub.prop(mat, "z_offset")
         sub.active = mat.transparency and mat.transparency_method == 'Z_TRANSPARENCY'
         sub = col.column(align=True)
-        sub.itemL(text="Light Group:")
-        sub.itemR(mat, "light_group", text="")
+        sub.label(text="Light Group:")
+        sub.prop(mat, "light_group", text="")
         row = sub.row()
-        row.active = mat.light_group
-        row.itemR(mat, "light_group_exclusive", text="Exclusive")
+        row.active = bool(mat.light_group)
+        row.prop(mat, "light_group_exclusive", text="Exclusive")
 
-        col = split.column()
-        col.itemR(mat, "face_texture")
+        if wide_ui:
+            col = split.column()
+        col.prop(mat, "face_texture")
         sub = col.column()
         sub.active = mat.face_texture
-        sub.itemR(mat, "face_texture_alpha")
-        col.itemS()
-        col.itemR(mat, "vertex_color_paint")
-        col.itemR(mat, "vertex_color_light")
-        col.itemR(mat, "object_color")
+        sub.prop(mat, "face_texture_alpha")
+        col.separator()
+        col.prop(mat, "vertex_color_paint")
+        col.prop(mat, "vertex_color_light")
+        col.prop(mat, "object_color")
 
 
 class MATERIAL_PT_shadow(MaterialButtonsPanel):
     bl_label = "Shadow"
     bl_default_closed = True
-    COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def poll(self, context):
         mat = active_node_mat(context.material)
@@ -254,30 +313,32 @@ class MATERIAL_PT_shadow(MaterialButtonsPanel):
         layout = self.layout
 
         mat = active_node_mat(context.material)
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(mat, "shadows", text="Receive")
-        col.itemR(mat, "receive_transparent_shadows", text="Receive Transparent")
-        col.itemR(mat, "only_shadow", text="Shadows Only")
-        col.itemR(mat, "cast_shadows_only", text="Cast Only")
-        col.itemR(mat, "shadow_casting_alpha", text="Casting Alpha")
+        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 = split.column()
-        col.itemR(mat, "cast_buffer_shadows")
+        if wide_ui:
+            col = split.column()
+        col.prop(mat, "cast_buffer_shadows")
         sub = col.column()
         sub.active = mat.cast_buffer_shadows
-        sub.itemR(mat, "shadow_buffer_bias", text="Buffer Bias")
-        col.itemR(mat, "ray_shadow_bias", text="Auto Ray Bias")
+        sub.prop(mat, "shadow_buffer_bias", text="Buffer Bias")
+        col.prop(mat, "ray_shadow_bias", text="Auto Ray Bias")
         sub = col.column()
         sub.active = (not mat.ray_shadow_bias)
-        sub.itemR(mat, "shadow_ray_bias", text="Ray Bias")
-
+        sub.prop(mat, "shadow_ray_bias", text="Ray Bias")
+        col.prop(mat, "cast_approximate")
 
 class MATERIAL_PT_diffuse(MaterialButtonsPanel):
     bl_label = "Diffuse"
-    COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def poll(self, context):
         mat = active_node_mat(context.material)
@@ -288,53 +349,67 @@ class MATERIAL_PT_diffuse(MaterialButtonsPanel):
         layout = self.layout
 
         mat = active_node_mat(context.material)
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(mat, "diffuse_color", text="")
+        col.prop(mat, "diffuse_color", text="")
         sub = col.column()
         sub.active = (not mat.shadeless)
-        sub.itemR(mat, "diffuse_intensity", text="Intensity")
+        sub.prop(mat, "diffuse_intensity", text="Intensity")
 
-        col = split.column()
+        if wide_ui:
+            col = split.column()
         col.active = (not mat.shadeless)
-        col.itemR(mat, "diffuse_shader", text="")
-        col.itemR(mat, "use_diffuse_ramp", text="Ramp")
+        col.prop(mat, "diffuse_shader", text="")
+        col.prop(mat, "use_diffuse_ramp", text="Ramp")
 
         col = layout.column()
         col.active = (not mat.shadeless)
         if mat.diffuse_shader == 'OREN_NAYAR':
-            col.itemR(mat, "roughness")
+            col.prop(mat, "roughness")
         elif mat.diffuse_shader == 'MINNAERT':
-            col.itemR(mat, "darkness")
+            col.prop(mat, "darkness")
         elif mat.diffuse_shader == 'TOON':
-            row = col.row()
-            row.itemR(mat, "diffuse_toon_size", text="Size")
-            row.itemR(mat, "diffuse_toon_smooth", text="Smooth")
+            split = col.split()
+
+            col = split.column()
+            col.prop(mat, "diffuse_toon_size", text="Size")
+
+            if wide_ui:
+                col = split.column()
+            col.prop(mat, "diffuse_toon_smooth", text="Smooth")
         elif mat.diffuse_shader == 'FRESNEL':
-            row = col.row()
-            row.itemR(mat, "diffuse_fresnel", text="Fresnel")
-            row.itemR(mat, "diffuse_fresnel_factor", text="Factor")
+            split = col.split()
+
+            col = split.column()
+            col.prop(mat, "diffuse_fresnel", text="Fresnel")
+
+            if wide_ui:
+                col = split.column()
+            col.prop(mat, "diffuse_fresnel_factor", text="Factor")
 
         if mat.use_diffuse_ramp:
-            layout.itemS()
+            layout.separator()
             layout.template_color_ramp(mat, "diffuse_ramp", expand=True)
-            layout.itemS()
-            row = layout.row()
-            split = row.split(percentage=0.3)
-            split.itemL(text="Input:")
-            split.itemR(mat, "diffuse_ramp_input", text="")
-            split = row.split(percentage=0.3)
-            split.itemL(text="Blend:")
-            split.itemR(mat, "diffuse_ramp_blend", text="")
+            layout.separator()
+
+            split = layout.split()
+
+            col = split.column()
+            col.prop(mat, "diffuse_ramp_input", text="Input")
+
+            if wide_ui:
+                col = split.column()
+            col.prop(mat, "diffuse_ramp_blend", text="Blend")
             row = layout.row()
-            row.itemR(mat, "diffuse_ramp_factor", text="Factor")
+            row.prop(mat, "diffuse_ramp_factor", text="Factor")
 
 
 class MATERIAL_PT_specular(MaterialButtonsPanel):
     bl_label = "Specular"
-    COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def poll(self, context):
         mat = active_node_mat(context.material)
@@ -345,52 +420,66 @@ class MATERIAL_PT_specular(MaterialButtonsPanel):
         layout = self.layout
 
         mat = active_node_mat(context.material)
+        wide_ui = context.region.width > narrowui
 
         layout.active = (not mat.shadeless)
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(mat, "specular_color", text="")
-        col.itemR(mat, "specular_intensity", text="Intensity")
+        col.prop(mat, "specular_color", text="")
+        col.prop(mat, "specular_intensity", text="Intensity")
 
-        col = split.column()
-        col.itemR(mat, "specular_shader", text="")
-        col.itemR(mat, "use_specular_ramp", text="Ramp")
+        if wide_ui:
+            col = split.column()
+        col.prop(mat, "specular_shader", text="")
+        col.prop(mat, "use_specular_ramp", text="Ramp")
 
         col = layout.column()
         if mat.specular_shader in ('COOKTORR', 'PHONG'):
-            col.itemR(mat, "specular_hardness", text="Hardness")
+            col.prop(mat, "specular_hardness", text="Hardness")
         elif mat.specular_shader == 'BLINN':
-            row = col.row()
-            row.itemR(mat, "specular_hardness", text="Hardness")
-            row.itemR(mat, "specular_ior", text="IOR")
+            split = layout.split()
+
+            col = split.column()
+            col.prop(mat, "specular_hardness", text="Hardness")
+
+            if wide_ui:
+                col = split.column()
+            col.prop(mat, "specular_ior", text="IOR")
         elif mat.specular_shader == 'WARDISO':
-            col.itemR(mat, "specular_slope", text="Slope")
+            col.prop(mat, "specular_slope", text="Slope")
         elif mat.specular_shader == 'TOON':
-            row = col.row()
-            row.itemR(mat, "specular_toon_size", text="Size")
-            row.itemR(mat, "specular_toon_smooth", text="Smooth")
+            split = layout.split()
+
+            col = split.column()
+            col.prop(mat, "specular_toon_size", text="Size")
+
+            if wide_ui:
+                col = split.column()
+            col.prop(mat, "specular_toon_smooth", text="Smooth")
 
         if mat.use_specular_ramp:
-            layout.itemS()
+            layout.separator()
             layout.template_color_ramp(mat, "specular_ramp", expand=True)
-            layout.itemS()
-            row = layout.row()
-            split = row.split(percentage=0.3)
-            split.itemL(text="Input:")
-            split.itemR(mat, "specular_ramp_input", text="")
-            split = row.split(percentage=0.3)
-            split.itemL(text="Blend:")
-            split.itemR(mat, "specular_ramp_blend", text="")
+            layout.separator()
+            split = layout.split()
+
+            col = split.column()
+            col.prop(mat, "specular_ramp_input", text="Input")
+
+            if wide_ui:
+                col = split.column()
+            col.prop(mat, "specular_ramp_blend", text="Blend")
+
             row = layout.row()
-            row.itemR(mat, "specular_ramp_factor", text="Factor")
+            row.prop(mat, "specular_ramp_factor", text="Factor")
 
 
 class MATERIAL_PT_sss(MaterialButtonsPanel):
     bl_label = "Subsurface Scattering"
     bl_default_closed = True
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def poll(self, context):
         mat = active_node_mat(context.material)
@@ -402,41 +491,47 @@ class MATERIAL_PT_sss(MaterialButtonsPanel):
         sss = mat.subsurface_scattering
 
         self.layout.active = (not mat.shadeless)
-        self.layout.itemR(sss, "enabled", text="")
+        self.layout.prop(sss, "enabled", text="")
 
     def draw(self, context):
         layout = self.layout
 
         mat = active_node_mat(context.material)
         sss = mat.subsurface_scattering
+        wide_ui = context.region.width > narrowui
 
-        layout.active = sss.enabled
+        layout.active = (sss.enabled) and (not mat.shadeless)
+
+        row = layout.row().split()
+        sub = row.row(align=True).split(percentage=0.75)
+        sub.menu("MATERIAL_MT_sss_presets", text="Presets")
+        sub.operator("material.sss_preset_add", text="Add")
 
         split = layout.split()
-        split.active = (not mat.shadeless)
 
         col = split.column()
-        col.itemR(sss, "ior")
-        col.itemR(sss, "scale")
-        col.itemR(sss, "color", text="")
-        col.itemR(sss, "radius", text="RGB Radius")
+        col.prop(sss, "ior")
+        col.prop(sss, "scale")
+        col.prop(sss, "color", text="")
+        col.prop(sss, "radius", text="RGB Radius", expand=True)
 
-        col = split.column()
+        if wide_ui:
+            col = split.column()
         sub = col.column(align=True)
-        sub.itemL(text="Blend:")
-        sub.itemR(sss, "color_factor", text="Color")
-        sub.itemR(sss, "texture_factor", text="Texture")
-        sub.itemL(text="Scattering Weight:")
-        sub.itemR(sss, "front")
-        sub.itemR(sss, "back")
-        col.itemS()
-        col.itemR(sss, "error_tolerance", text="Error")
+        sub.label(text="Blend:")
+        sub.prop(sss, "color_factor", text="Color")
+        sub.prop(sss, "texture_factor", text="Texture")
+        sub.label(text="Scattering Weight:")
+        sub.prop(sss, "front")
+        sub.prop(sss, "back")
+        col.separator()
+        col.prop(sss, "error_tolerance", text="Error")
 
 
 class MATERIAL_PT_mirror(MaterialButtonsPanel):
     bl_label = "Mirror"
     bl_default_closed = True
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def poll(self, context):
         mat = active_node_mat(context.material)
@@ -446,53 +541,56 @@ class MATERIAL_PT_mirror(MaterialButtonsPanel):
     def draw_header(self, context):
         raym = active_node_mat(context.material).raytrace_mirror
 
-        self.layout.itemR(raym, "enabled", text="")
+        self.layout.prop(raym, "enabled", text="")
 
     def draw(self, context):
         layout = self.layout
 
         mat = active_node_mat(context.material)
         raym = mat.raytrace_mirror
+        wide_ui = context.region.width > narrowui
 
         layout.active = raym.enabled
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(raym, "reflect_factor")
-        col.itemR(mat, "mirror_color", text="")
+        col.prop(raym, "reflect_factor")
+        col.prop(mat, "mirror_color", text="")
 
-        col = split.column()
-        col.itemR(raym, "fresnel")
+        if wide_ui:
+            col = split.column()
+        col.prop(raym, "fresnel")
         sub = col.column()
         sub.active = raym.fresnel > 0
-        sub.itemR(raym, "fresnel_factor", text="Blend")
+        sub.prop(raym, "fresnel_factor", text="Blend")
 
         split = layout.split()
 
         col = split.column()
-        col.itemS()
-        col.itemR(raym, "distance", text="Max Dist")
-        col.itemR(raym, "depth")
-        col.itemS()
+        col.separator()
+        col.prop(raym, "distance", text="Max Dist")
+        col.prop(raym, "depth")
+        col.separator()
         sub = col.split(percentage=0.4)
-        sub.itemL(text="Fade To:")
-        sub.itemR(raym, "fade_to", text="")
+        sub.label(text="Fade To:")
+        sub.prop(raym, "fade_to", text="")
 
-        col = split.column()
-        col.itemL(text="Gloss:")
-        col.itemR(raym, "gloss_factor", text="Amount")
+        if wide_ui:
+            col = split.column()
+        col.label(text="Gloss:")
+        col.prop(raym, "gloss_factor", text="Amount")
         sub = col.column()
         sub.active = raym.gloss_factor < 1.0
-        sub.itemR(raym, "gloss_threshold", text="Threshold")
-        sub.itemR(raym, "gloss_samples", text="Samples")
-        sub.itemR(raym, "gloss_anisotropic", text="Anisotropic")
+        sub.prop(raym, "gloss_threshold", text="Threshold")
+        sub.prop(raym, "gloss_samples", text="Samples")
+        sub.prop(raym, "gloss_anisotropic", text="Anisotropic")
 
 
 class MATERIAL_PT_transp(MaterialButtonsPanel):
     bl_label = "Transparency"
     bl_default_closed = True
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def poll(self, context):
         mat = active_node_mat(context.material)
@@ -502,57 +600,98 @@ class MATERIAL_PT_transp(MaterialButtonsPanel):
     def draw_header(self, context):
         mat = active_node_mat(context.material)
 
-        self.layout.itemR(mat, "transparency", text="")
+        self.layout.prop(mat, "transparency", text="")
 
     def draw(self, context):
         layout = self.layout
 
         mat = active_node_mat(context.material)
         rayt = mat.raytrace_transparency
+        wide_ui = context.region.width > narrowui
 
         row = layout.row()
         row.active = mat.transparency and (not mat.shadeless)
-        row.itemR(mat, "transparency_method", expand=True)
+        if wide_ui:
+            row.prop(mat, "transparency_method", expand=True)
+        else:
+            row.prop(mat, "transparency_method", text="")
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(mat, "alpha")
+        col.prop(mat, "alpha")
         row = col.row()
         row.active = mat.transparency and (not mat.shadeless)
-        row.itemR(mat, "specular_alpha", text="Specular")
+        row.prop(mat, "specular_alpha", text="Specular")
 
-        col = split.column()
+        if wide_ui:
+            col = split.column()
         col.active = (not mat.shadeless)
-        col.itemR(rayt, "fresnel")
+        col.prop(rayt, "fresnel")
         sub = col.column()
         sub.active = rayt.fresnel > 0
-        sub.itemR(rayt, "fresnel_factor", text="Blend")
+        sub.prop(rayt, "fresnel_factor", text="Blend")
 
         if mat.transparency_method == 'RAYTRACE':
-            layout.itemS()
+            layout.separator()
             split = layout.split()
             split.active = mat.transparency
 
             col = split.column()
-            col.itemR(rayt, "ior")
-            col.itemR(rayt, "filter")
-            col.itemR(rayt, "falloff")
-            col.itemR(rayt, "limit")
-            col.itemR(rayt, "depth")
-
-            col = split.column()
-            col.itemL(text="Gloss:")
-            col.itemR(rayt, "gloss_factor", text="Amount")
+            col.prop(rayt, "ior")
+            col.prop(rayt, "filter")
+            col.prop(rayt, "falloff")
+            col.prop(rayt, "limit")
+            col.prop(rayt, "depth")
+
+            if wide_ui:
+                col = split.column()
+            col.label(text="Gloss:")
+            col.prop(rayt, "gloss_factor", text="Amount")
             sub = col.column()
             sub.active = rayt.gloss_factor < 1.0
-            sub.itemR(rayt, "gloss_threshold", text="Threshold")
-            sub.itemR(rayt, "gloss_samples", text="Samples")
+            sub.prop(rayt, "gloss_threshold", text="Threshold")
+            sub.prop(rayt, "gloss_samples", text="Samples")
+
+
+class MATERIAL_PT_transp_game(MaterialButtonsPanel):
+    bl_label = "Transparency"
+    bl_default_closed = True
+    COMPAT_ENGINES = {'BLENDER_GAME'}
+
+    def poll(self, context):
+        mat = active_node_mat(context.material)
+        engine = context.scene.render_data.engine
+        return mat  and (engine in self.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        mat = active_node_mat(context.material)
+
+        self.layout.prop(mat, "transparency", text="")
+
+    def draw(self, context):
+        layout = self.layout
+
+        mat = active_node_mat(context.material)
+        rayt = mat.raytrace_transparency
+        wide_ui = context.region.width > narrowui
+
+        row = layout.row()
+        row.active = mat.transparency and (not mat.shadeless)
+        if wide_ui:
+            row.prop(mat, "transparency_method", expand=True)
+        else:
+            row.prop(mat, "transparency_method", text="")
+
+        split = layout.split()
+
+        col = split.column()
+        col.prop(mat, "alpha")
 
 
 class MATERIAL_PT_halo(MaterialButtonsPanel):
     bl_label = "Halo"
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def poll(self, context):
         mat = context.material
@@ -564,43 +703,45 @@ class MATERIAL_PT_halo(MaterialButtonsPanel):
 
         mat = context.material # dont use node material
         halo = mat.halo
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(mat, "diffuse_color", text="")
-        col.itemR(halo, "size")
-        col.itemR(halo, "hardness")
-        col.itemR(halo, "add")
-        col.itemL(text="Options:")
-        col.itemR(halo, "texture")
-        col.itemR(halo, "vertex_normal")
-        col.itemR(halo, "xalpha")
-        col.itemR(halo, "shaded")
-        col.itemR(halo, "soft")
-
-        col = split.column()
-        col.itemR(halo, "ring")
+        col.prop(mat, "diffuse_color", text="")
+        col.prop(halo, "size")
+        col.prop(halo, "hardness")
+        col.prop(halo, "add")
+        col.label(text="Options:")
+        col.prop(halo, "texture")
+        col.prop(halo, "vertex_normal")
+        col.prop(halo, "xalpha")
+        col.prop(halo, "shaded")
+        col.prop(halo, "soft")
+
+        if wide_ui:
+            col = split.column()
+        col.prop(halo, "ring")
         sub = col.column()
         sub.active = halo.ring
-        sub.itemR(halo, "rings")
-        sub.itemR(mat, "mirror_color", text="")
-        col.itemS()
-        col.itemR(halo, "lines")
+        sub.prop(halo, "rings")
+        sub.prop(mat, "mirror_color", text="")
+        col.separator()
+        col.prop(halo, "lines")
         sub = col.column()
         sub.active = halo.lines
-        sub.itemR(halo, "line_number", text="Lines")
-        sub.itemR(mat, "specular_color", text="")
-        col.itemS()
-        col.itemR(halo, "star")
+        sub.prop(halo, "line_number", text="Lines")
+        sub.prop(mat, "specular_color", text="")
+        col.separator()
+        col.prop(halo, "star")
         sub = col.column()
         sub.active = halo.star
-        sub.itemR(halo, "star_tips")
+        sub.prop(halo, "star_tips")
 
 
 class MATERIAL_PT_flare(MaterialButtonsPanel):
     bl_label = "Flare"
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def poll(self, context):
         mat = context.material
@@ -610,40 +751,27 @@ class MATERIAL_PT_flare(MaterialButtonsPanel):
     def draw_header(self, context):
         halo = context.material.halo
 
-        self.layout.itemR(halo, "flare_mode", text="")
+        self.layout.prop(halo, "flare_mode", text="")
 
     def draw(self, context):
         layout = self.layout
 
         mat = context.material # dont use node material
         halo = mat.halo
+        wide_ui = context.region.width > narrowui
 
         layout.active = halo.flare_mode
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(halo, "flare_size", text="Size")
-        col.itemR(halo, "flare_boost", text="Boost")
-        col.itemR(halo, "flare_seed", text="Seed")
-        col = split.column()
-        col.itemR(halo, "flares_sub", text="Subflares")
-        col.itemR(halo, "flare_subsize", text="Subsize")
-
-bpy.types.register(MATERIAL_PT_context_material)
-bpy.types.register(MATERIAL_PT_preview)
-bpy.types.register(MATERIAL_PT_diffuse)
-bpy.types.register(MATERIAL_PT_specular)
-bpy.types.register(MATERIAL_PT_shading)
-bpy.types.register(MATERIAL_PT_transp)
-bpy.types.register(MATERIAL_PT_mirror)
-bpy.types.register(MATERIAL_PT_sss)
-bpy.types.register(MATERIAL_PT_halo)
-bpy.types.register(MATERIAL_PT_flare)
-bpy.types.register(MATERIAL_PT_physics)
-bpy.types.register(MATERIAL_PT_strand)
-bpy.types.register(MATERIAL_PT_options)
-bpy.types.register(MATERIAL_PT_shadow)
+        col.prop(halo, "flare_size", text="Size")
+        col.prop(halo, "flare_boost", text="Boost")
+        col.prop(halo, "flare_seed", text="Seed")
+        if wide_ui:
+            col = split.column()
+        col.prop(halo, "flares_sub", text="Subflares")
+        col.prop(halo, "flare_subsize", text="Subsize")
 
 
 class VolumeButtonsPanel(bpy.types.Panel):
@@ -660,117 +788,166 @@ class VolumeButtonsPanel(bpy.types.Panel):
 class MATERIAL_PT_volume_density(VolumeButtonsPanel):
     bl_label = "Density"
     bl_default_closed = False
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def draw(self, context):
         layout = self.layout
 
         vol = context.material.volume # dont use node material
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
-        row = split.row()
-        row.itemR(vol, "density")
-        row.itemR(vol, "density_scale")
+        col = split.column()
+        col.prop(vol, "density")
+
+        if wide_ui:
+            col = split.column()
+        col.prop(vol, "density_scale")
 
 
 class MATERIAL_PT_volume_shading(VolumeButtonsPanel):
     bl_label = "Shading"
     bl_default_closed = False
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def draw(self, context):
         layout = self.layout
 
         vol = context.material.volume # dont use node material
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(vol, "scattering")
-        col.itemR(vol, "asymmetry")
-        col.itemR(vol, "transmission_color")
+        col.prop(vol, "scattering")
+        col.prop(vol, "asymmetry")
+        col.prop(vol, "transmission_color")
 
-        col = split.column()
+        if wide_ui:
+            col = split.column()
         sub = col.column(align=True)
-        sub.itemR(vol, "emission")
-        sub.itemR(vol, "emission_color", text="")
+        sub.prop(vol, "emission")
+        sub.prop(vol, "emission_color", text="")
         sub = col.column(align=True)
-        sub.itemR(vol, "reflection")
-        sub.itemR(vol, "reflection_color", text="")
+        sub.prop(vol, "reflection")
+        sub.prop(vol, "reflection_color", text="")
 
 
 class MATERIAL_PT_volume_lighting(VolumeButtonsPanel):
     bl_label = "Lighting"
     bl_default_closed = False
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def draw(self, context):
         layout = self.layout
 
         vol = context.material.volume # dont use node material
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
         col = split.column()
-        col.itemR(vol, "lighting_mode", text="")
+        col.prop(vol, "lighting_mode", text="")
 
-        col = split.column()
+        if wide_ui:
+            col = split.column()
 
         if vol.lighting_mode == 'SHADED':
-            col.itemR(vol, "external_shadows")
-            col.itemR(vol, "light_cache")
+            col.prop(vol, "external_shadows")
+            col.prop(vol, "light_cache")
             sub = col.column()
             sub.active = vol.light_cache
-            sub.itemR(vol, "cache_resolution")
+            sub.prop(vol, "cache_resolution")
         elif vol.lighting_mode in ('MULTIPLE_SCATTERING', 'SHADED_PLUS_MULTIPLE_SCATTERING'):
             sub = col.column()
             sub.enabled = True
             sub.active = False
-            sub.itemR(vol, "light_cache")
-            col.itemR(vol, "cache_resolution")
+            sub.prop(vol, "light_cache")
+            col.prop(vol, "cache_resolution")
 
             sub = col.column(align=True)
-            sub.itemR(vol, "ms_diffusion")
-            sub.itemR(vol, "ms_spread")
-            sub.itemR(vol, "ms_intensity")
+            sub.prop(vol, "ms_diffusion")
+            sub.prop(vol, "ms_spread")
+            sub.prop(vol, "ms_intensity")
 
 
 class MATERIAL_PT_volume_transp(VolumeButtonsPanel):
     bl_label = "Transparency"
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def draw(self, context):
         layout = self.layout
 
         mat = context.material # dont use node material
+        wide_ui = context.region.width > narrowui
 
-        layout.itemR(mat, "transparency_method", expand=True)
+        if wide_ui:
+            layout.prop(mat, "transparency_method", expand=True)
+        else:
+            layout.prop(mat, "transparency_method", text="")
 
 
 class MATERIAL_PT_volume_integration(VolumeButtonsPanel):
     bl_label = "Integration"
     bl_default_closed = False
-    COMPAT_ENGINES = set(['BLENDER_RENDER'])
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def draw(self, context):
         layout = self.layout
 
         vol = context.material.volume # dont use node material
+        wide_ui = context.region.width > narrowui
 
         split = layout.split()
 
         col = split.column()
-        col.itemL(text="Step Calculation:")
-        col.itemR(vol, "step_calculation", text="")
+        col.label(text="Step Calculation:")
+        col.prop(vol, "step_calculation", text="")
         col = col.column(align=True)
-        col.itemR(vol, "step_size")
+        col.prop(vol, "step_size")
 
-        col = split.column()
-        col.itemL()
-        col.itemR(vol, "depth_cutoff")
-
-bpy.types.register(MATERIAL_PT_volume_density)
-bpy.types.register(MATERIAL_PT_volume_shading)
-bpy.types.register(MATERIAL_PT_volume_lighting)
-bpy.types.register(MATERIAL_PT_volume_transp)
-bpy.types.register(MATERIAL_PT_volume_integration)
+        if wide_ui:
+            col = split.column()
+        col.label()
+        col.prop(vol, "depth_cutoff")
+
+
+classes = [
+    MATERIAL_PT_context_material,
+    MATERIAL_PT_preview,
+    MATERIAL_PT_diffuse,
+    MATERIAL_PT_specular,
+    MATERIAL_PT_shading,
+    MATERIAL_PT_transp,
+    MATERIAL_PT_mirror,
+    MATERIAL_PT_sss,
+    MATERIAL_PT_halo,
+    MATERIAL_PT_flare,
+    MATERIAL_PT_physics,
+    MATERIAL_PT_strand,
+    MATERIAL_PT_options,
+    MATERIAL_PT_shadow,
+    MATERIAL_PT_transp_game,
+
+    MATERIAL_MT_sss_presets,
+    MATERIAL_MT_specials,
+
+    MATERIAL_PT_volume_density,
+    MATERIAL_PT_volume_shading,
+    MATERIAL_PT_volume_lighting,
+    MATERIAL_PT_volume_transp,
+
+    MATERIAL_PT_volume_integration,
+
+    MATERIAL_PT_custom_props]
+
+
+def register():
+    register = bpy.types.register
+    for cls in classes:
+        register(cls)
+
+def unregister():
+    unregister = bpy.types.unregister
+    for cls in classes:
+        unregister(cls)