misc small changes and bmesh support for testing script
[blender.git] / intern / cycles / blender / addon / ui.py
index 2c4f24db2c547d57f5627a045775fbba9c430c7b..70f38fa7e8ccc97235143c4c674a655c4f092c48 100644 (file)
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 
+# <pep8 compliant>
+
 import bpy
 
-from cycles import enums
-from cycles import engine
+from bpy.types import Panel, Menu
+
+from . import enums, engine
+
+
+class CYCLES_MT_integrator_presets(Menu):
+    bl_label = "Integrator Presets"
+    preset_subdir = "cycles/integrator"
+    preset_operator = "script.execute_preset"
+    COMPAT_ENGINES = {'CYCLES'}
+    draw = Menu.draw_preset
+
 
 class CyclesButtonsPanel():
-       bl_space_type = "PROPERTIES"
-       bl_region_type = "WINDOW"
-       bl_context = "render"
-       
-       @classmethod
-       def poll(cls, context):
-               rd = context.scene.render
-               return rd.engine == 'CYCLES'
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "render"
+
+    @classmethod
+    def poll(cls, context):
+        rd = context.scene.render
+        return rd.engine == 'CYCLES'
+
+
+class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel):
+    bl_label = "Integrator"
+    bl_options = {'DEFAULT_CLOSED'}
+
+    def draw(self, context):
+        layout = self.layout
 
-class CyclesRender_PT_integrator(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Integrator"
+        scene = context.scene
+        cscene = scene.cycles
 
-       def draw(self, context):
-               layout = self.layout
+        row = layout.row(align=True)
+        row.menu("CYCLES_MT_integrator_presets", text=bpy.types.CYCLES_MT_integrator_presets.bl_label)
+        row.operator("render.cycles_integrator_preset_add", text="", icon="ZOOMIN")
+        row.operator("render.cycles_integrator_preset_add", text="", icon="ZOOMOUT").remove_active = True
 
-               scene = context.scene
-               cycles = scene.cycles
+        split = layout.split()
 
-               split = layout.split()
+        col = split.column()
+        sub = col.column(align=True)
+        sub.label(text="Samples:")
+        sub.prop(cscene, "samples", text="Render")
+        sub.prop(cscene, "preview_samples", text="Preview")
+        sub.prop(cscene, "seed")
+
+        sub = col.column(align=True)
+        sub.label("Transparency:")
+        sub.prop(cscene, "transparent_max_bounces", text="Max")
+        sub.prop(cscene, "transparent_min_bounces", text="Min")
+        sub.prop(cscene, "use_transparent_shadows", text="Shadows")
 
-               col = split.column()
-               col.prop(cycles, "passes")
-               col.prop(cycles, "no_caustics")
+        col = split.column()
 
-               col = split.column()
-               col = col.column(align=True)
-               col.prop(cycles, "max_bounces")
-               col.prop(cycles, "min_bounces")
+        sub = col.column(align=True)
+        sub.label(text="Bounces:")
+        sub.prop(cscene, "max_bounces", text="Max")
+        sub.prop(cscene, "min_bounces", text="Min")
 
-               #row = col.row()
-               #row.prop(cycles, "blur_caustics")
-               #row.active = not cycles.no_caustics
+        sub = col.column(align=True)
+        sub.label(text="Light Paths:")
+        sub.prop(cscene, "diffuse_bounces", text="Diffuse")
+        sub.prop(cscene, "glossy_bounces", text="Glossy")
+        sub.prop(cscene, "transmission_bounces", text="Transmission")
+        sub.prop(cscene, "no_caustics")
 
-class CyclesRender_PT_film(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Film"
+        #row = col.row()
+        #row.prop(cscene, "blur_caustics")
+        #row.active = not cscene.no_caustics
 
-       def draw(self, context):
-               layout = self.layout
 
-               scene = context.scene
-               cycles = scene.cycles
+class CyclesRender_PT_film(CyclesButtonsPanel, Panel):
+    bl_label = "Film"
 
-               split = layout.split()
+    def draw(self, context):
+        layout = self.layout
 
-               split.prop(cycles, "exposure")
-               split.prop(cycles, "response_curve", text="")
+        scene = context.scene
+        cscene = scene.cycles
 
-class CyclesRender_PT_debug(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Debug"
-       bl_options = {'DEFAULT_CLOSED'}
+        split = layout.split()
 
-       def draw(self, context):
-               layout = self.layout
+        col = split.column()
+        col.prop(cscene, "film_exposure")
+        col.prop(cscene, "film_transparent")
+
+        col = split.column()
+        sub = col.column(align=True)
+        sub.prop(cscene, "filter_type", text="")
+        if cscene.filter_type != 'BOX':
+            sub.prop(cscene, "filter_width", text="Width")
 
-               scene = context.scene
-               cycles = scene.cycles
 
-               split = layout.split()
+class CyclesRender_PT_performance(CyclesButtonsPanel, Panel):
+    bl_label = "Performance"
+    bl_options = {'DEFAULT_CLOSED'}
 
-               col = split.column()
+    def draw(self, context):
+        layout = self.layout
 
-               sub = col.column(align=True)
-               sub.prop(cycles, "debug_bvh_type", text="")
-               sub.prop(cycles, "debug_use_spatial_splits")
+        scene = context.scene
+        rd = scene.render
+        cscene = scene.cycles
 
-               sub = col.column(align=True)
-               sub.prop(cycles, "debug_tile_size")
-               sub.prop(cycles, "debug_min_size")
+        split = layout.split()
 
-               col = split.column(align=True)
-               col.prop(cycles, "debug_cancel_timeout")
-               col.prop(cycles, "debug_reset_timeout")
-               col.prop(cycles, "debug_text_timeout")
+        col = split.column(align=True)
 
-class Cycles_PT_post_processing(CyclesButtonsPanel, bpy.types.Panel):
+        col.label(text="Threads:")
+        col.row().prop(rd, "threads_mode", expand=True)
+        sub = col.column()
+        sub.enabled = rd.threads_mode == 'FIXED'
+        sub.prop(rd, "threads")
+
+        sub = col.column(align=True)
+        sub.label(text="Tiles:")
+        sub.prop(cscene, "debug_tile_size")
+        sub.prop(cscene, "debug_min_size")
+
+        col = split.column()
+
+        sub = col.column(align=True)
+        sub.label(text="Acceleration structure:")
+        sub.prop(cscene, "debug_bvh_type", text="")
+        sub.prop(cscene, "debug_use_spatial_splits")
+        sub.prop(cscene, "use_cache")
+
+
+class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
+    bl_label = "Layers"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_RENDER'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        scene = context.scene
+        rd = scene.render
+
+        row = layout.row()
+        row.template_list(rd, "layers", rd.layers, "active_index", rows=2)
+
+        col = row.column(align=True)
+        col.operator("scene.render_layer_add", icon='ZOOMIN', text="")
+        col.operator("scene.render_layer_remove", icon='ZOOMOUT', text="")
+
+        row = layout.row()
+        rl = rd.layers.active
+        row.prop(rl, "name")
+        row.prop(rd, "use_single_layer", text="", icon_only=True)
+
+        split = layout.split()
+
+        col = split.column()
+        col.prop(scene, "layers", text="Scene")
+
+        col = split.column()
+        col.prop(rl, "layers", text="Layer")
+
+        layout.separator()
+
+        rl = rd.layers[0]
+        layout.prop(rl, "material_override", text="Material")
+
+
+class Cycles_PT_post_processing(CyclesButtonsPanel, Panel):
     bl_label = "Post Processing"
     bl_options = {'DEFAULT_CLOSED'}
 
@@ -114,275 +205,608 @@ class Cycles_PT_post_processing(CyclesButtonsPanel, bpy.types.Panel):
         col = split.column()
         col.prop(rd, "dither_intensity", text="Dither", slider=True)
 
-class Cycles_PT_camera(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Cycles"
-       bl_context = "data"
 
-       @classmethod
-       def poll(cls, context):
-               return context.camera
+class CyclesCamera_PT_dof(CyclesButtonsPanel, Panel):
+    bl_label = "Depth of Field"
+    bl_context = "data"
 
-       def draw(self, context):
-               layout = self.layout
+    @classmethod
+    def poll(cls, context):
+        return context.camera and CyclesButtonsPanel.poll(context)
 
-               camera = context.camera
-               cycles = camera.cycles
+    def draw(self, context):
+        layout = self.layout
+
+        cam = context.camera
+        ccam = cam.cycles
 
-               layout.prop(cycles, "lens_radius")
+        split = layout.split()
 
-class Cycles_PT_context_material(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Surface"
-       bl_context = "material"
-       bl_options = {'HIDE_HEADER'}
+        col = split.column()
+        col.label("Focus:")
+        col.prop(cam, "dof_object", text="")
+
+        sub = col.row()
+        sub.active = cam.dof_object is None
+        sub.prop(cam, "dof_distance", text="Distance")
+
+        col = split.column()
 
-       @classmethod
-       def poll(cls, context):
-               return (context.material or context.object) and CyclesButtonsPanel.poll(context)
+        col.label("Aperture:")
+        col.prop(ccam, "aperture_size", text="Size")
 
-       def draw(self, context):
-               layout = self.layout
+        sub = col.column(align=True)
+        sub.prop(ccam, "aperture_blades", text="Blades")
+        sub.prop(ccam, "aperture_rotation", text="Rotation")
+
+
+class Cycles_PT_context_material(CyclesButtonsPanel, Panel):
+    bl_label = "Surface"
+    bl_context = "material"
+    bl_options = {'HIDE_HEADER'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.material or context.object) and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
 
-               mat = context.material
-               ob = context.object
-               slot = context.material_slot
-               space = context.space_data
+        mat = context.material
+        ob = context.object
+        slot = context.material_slot
+        space = context.space_data
 
-               if ob:
-                       row = layout.row()
+        if ob:
+            row = layout.row()
 
-                       row.template_list(ob, "material_slots", ob, "active_material_index", rows=2)
+            row.template_list(ob, "material_slots", ob, "active_material_index", rows=2)
+
+            col = row.column(align=True)
+            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.operator("object.material_slot_assign", text="Assign")
+                row.operator("object.material_slot_select", text="Select")
+                row.operator("object.material_slot_deselect", text="Deselect")
+
+        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()
+
+
+class Cycles_PT_mesh_displacement(CyclesButtonsPanel, Panel):
+    bl_label = "Displacement"
+    bl_context = "data"
+
+    @classmethod
+    def poll(cls, context):
+        if CyclesButtonsPanel.poll(context):
+            if context.mesh or context.curve or context.meta_ball:
+                if context.scene.cycles.feature_set == 'EXPERIMENTAL':
+                    return True
+
+        return False
+
+    def draw(self, context):
+        layout = self.layout
 
-                       col = row.column(align=True)
-                       col.operator("object.material_slot_add", icon='ZOOMIN', text="")
-                       col.operator("object.material_slot_remove", icon='ZOOMOUT', text="")
+        mesh = context.mesh
+        curve = context.curve
+        mball = context.meta_ball
 
-                       col.menu("MATERIAL_MT_specials", icon='DOWNARROW_HLT', text="")
+        if mesh:
+            cdata = mesh.cycles
+        elif curve:
+            cdata = curve.cycles
+        elif mball:
+            cdata = mball.cycles
 
-                       if ob.mode == 'EDIT':
-                               row = layout.row(align=True)
-                               row.operator("object.material_slot_assign", text="Assign")
-                               row.operator("object.material_slot_select", text="Select")
-                               row.operator("object.material_slot_deselect", text="Deselect")
+        layout.prop(cdata, "displacement_method", text="Method")
+        layout.prop(cdata, "use_subdivision")
+        layout.prop(cdata, "dicing_rate")
 
-               split = layout.split(percentage=0.65)
 
-               if ob:
-                       split.template_ID(ob, "active_material", new="material.new")
-                       row = split.row()
+class CyclesObject_PT_ray_visibility(CyclesButtonsPanel, Panel):
+    bl_label = "Ray Visibility"
+    bl_context = "object"
+    bl_options = {'DEFAULT_CLOSED'}
 
-                       if slot:
-                               row.prop(slot, "link", text="")
-                       else:
-                               row.label()
-               elif mat:
-                       split.template_ID(space, "pin_id")
-                       split.separator()
+    @classmethod
+    def poll(cls, context):
+        ob = context.object
+        return CyclesButtonsPanel.poll(context) and ob and ob.type in {'MESH', 'CURVE', 'CURVE', 'SURFACE', 'FONT', 'META'}  # todo: 'LAMP'
 
-class Cycles_PT_mesh_displacement(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Displacement"
-       bl_context = "data"
+    def draw(self, context):
+        layout = self.layout
 
-       @classmethod
-       def poll(cls, context):
-               return context.mesh or context.curve or context.meta_ball
+        ob = context.object
+        visibility = ob.cycles_visibility
 
-       def draw(self, context):
-               layout = self.layout
+        split = layout.split()
 
-               mesh = context.mesh
-               curve = context.curve
-               mball = context.meta_ball
+        col = split.column()
+        col.prop(visibility, "camera")
+        col.prop(visibility, "diffuse")
+        col.prop(visibility, "glossy")
 
-               if mesh:
-                       cycles = mesh.cycles
-               elif curve:
-                       cycles = curve.cycles
-               elif mball:
-                       cycles = mball.cycles
+        col = split.column()
+        col.prop(visibility, "transmission")
+        col.prop(visibility, "shadow")
 
-               layout.prop(cycles, "displacement_method", text="Method")
-               layout.prop(cycles, "use_subdivision");
-               layout.prop(cycles, "dicing_rate");
 
 def find_node(material, nodetype):
-       if material and material.node_tree:
-               ntree = material.node_tree
+    if material and material.node_tree:
+        ntree = material.node_tree
+
+        for node in ntree.nodes:
+            if getattr(node, "type", None) == nodetype:
+                return node
+
+    return None
 
-               for node in ntree.nodes:
-                       if type(node) is not bpy.types.NodeGroup and node.type == nodetype:
-                               return node
-       
-       return None
 
 def find_node_input(node, name):
-       for input in node.inputs:
-               if input.name == name:
-                       return input
-       
-       return None
+    for input in node.inputs:
+        if input.name == name:
+            return input
+
+    return None
+
+
+def panel_node_draw(layout, id_data, output_type, input_name):
+    if not id_data.node_tree:
+        layout.prop(id_data, "use_nodes", icon='NODETREE')
+        return False
+
+    ntree = id_data.node_tree
+
+    node = find_node(id_data, output_type)
+    if not node:
+        layout.label(text="No output node.")
+    else:
+        input = find_node_input(node, input_name)
+        layout.template_node_view(ntree, node, input)
+
+    return True
+
+
+class CyclesLamp_PT_lamp(CyclesButtonsPanel, Panel):
+    bl_label = "Lamp"
+    bl_context = "data"
+
+    @classmethod
+    def poll(cls, context):
+        return context.lamp and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
+
+        lamp = context.lamp
+        clamp = lamp.cycles
+
+        layout.prop(lamp, "type", expand=True)
+
+        split = layout.split()
+        col = split.column(align=True)
 
-def panel_node_draw(layout, id, output_type, input_name):
-       if not id.node_tree:
-               layout.prop(id, "use_nodes")
-               return
+        if lamp.type in {'POINT', 'SUN', 'SPOT'}:
+            col.prop(lamp, "shadow_soft_size", text="Size")
+        elif lamp.type == 'AREA':
+            col.prop(lamp, "shape", text="")
+            sub = col.column(align=True)
 
-       ntree = id.node_tree
+            if lamp.shape == 'SQUARE':
+                sub.prop(lamp, "size")
+            elif lamp.shape == 'RECTANGLE':
+                sub.prop(lamp, "size", text="Size X")
+                sub.prop(lamp, "size_y", text="Size Y")
 
-       node = find_node(id, output_type)
-       if not node:
-               layout.label(text="No output node.")
+        col = split.column()
+        col.prop(clamp, "cast_shadow")
+
+        if lamp.type == 'SPOT':
+            layout.label(text="Not supported, interpreted as point lamp.")
+        elif lamp.type == 'HEMI':
+            layout.label(text="Not supported, interpreted as sun lamp.")
+
+
+class CyclesLamp_PT_nodes(CyclesButtonsPanel, Panel):
+    bl_label = "Nodes"
+    bl_context = "data"
 
-       input = find_node_input(node, input_name)
-       layout.template_node_view(id, ntree, node, input);
+    @classmethod
+    def poll(cls, context):
+        return context.lamp and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
 
-class CyclesLamp_PT_lamp(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Surface"
-       bl_context = "data"
+        lamp = context.lamp
+        if not panel_node_draw(layout, lamp, 'OUTPUT_LAMP', 'Surface'):
+            layout.prop(lamp, "color")
+
+
+class CyclesWorld_PT_surface(CyclesButtonsPanel, Panel):
+    bl_label = "Surface"
+    bl_context = "world"
+
+    @classmethod
+    def poll(cls, context):
+        return context.world and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
 
-       @classmethod
-       def poll(cls, context):
-               return context.lamp and CyclesButtonsPanel.poll(context)
+        world = context.world
+        if not panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Surface'):
+            layout.prop(world, "horizon_color", text="Color")
 
-       def draw(self, context):
-               layout = self.layout
 
-               mat = context.lamp
-               panel_node_draw(layout, mat, 'OUTPUT_LAMP', 'Surface')
+class CyclesWorld_PT_volume(CyclesButtonsPanel, Panel):
+    bl_label = "Volume"
+    bl_context = "world"
+    bl_options = {'DEFAULT_CLOSED'}
 
-class CyclesWorld_PT_surface(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Surface"
-       bl_context = "world"
+    @classmethod
+    def poll(cls, context):
+        # world = context.world
+        # world and world.node_tree and CyclesButtonsPanel.poll(context)
+        return False
 
-       @classmethod
-       def poll(cls, context):
-               return context.world and CyclesButtonsPanel.poll(context)
+    def draw(self, context):
+        layout = self.layout
+        layout.active = False
 
-       def draw(self, context):
-               layout = self.layout
+        world = context.world
+        panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Volume')
 
-               mat = context.world
-               panel_node_draw(layout, mat, 'OUTPUT_WORLD', 'Surface')
 
-class CyclesWorld_PT_volume(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Volume"
-       bl_context = "world"
+class CyclesMaterial_PT_surface(CyclesButtonsPanel, Panel):
+    bl_label = "Surface"
+    bl_context = "material"
 
-       @classmethod
-       def poll(cls, context):
-               return context.world and CyclesButtonsPanel.poll(context)
+    @classmethod
+    def poll(cls, context):
+        return context.material and CyclesButtonsPanel.poll(context)
 
-       def draw(self, context):
-               layout = self.layout
-               layout.active = False
+    def draw(self, context):
+        layout = self.layout
 
-               mat = context.world
-               panel_node_draw(layout, mat, 'OUTPUT_WORLD', 'Volume')
+        mat = context.material
+        if not panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Surface'):
+            layout.prop(mat, "diffuse_color")
 
-class CyclesMaterial_PT_surface(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Surface"
-       bl_context = "material"
 
-       @classmethod
-       def poll(cls, context):
-               return context.material and CyclesButtonsPanel.poll(context)
+class CyclesMaterial_PT_volume(CyclesButtonsPanel, Panel):
+    bl_label = "Volume"
+    bl_context = "material"
+    bl_options = {'DEFAULT_CLOSED'}
 
-       def draw(self, context):
-               layout = self.layout
+    @classmethod
+    def poll(cls, context):
+        # mat = context.material
+        # mat and mat.node_tree and CyclesButtonsPanel.poll(context)
+        return False
 
-               mat = context.material
-               panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Surface')
+    def draw(self, context):
+        layout = self.layout
+        layout.active = False
 
-class CyclesMaterial_PT_volume(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Volume"
-       bl_context = "material"
+        mat = context.material
+        cmat = mat.cycles
 
-       @classmethod
-       def poll(cls, context):
-               return context.material and CyclesButtonsPanel.poll(context)
+        panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Volume')
 
-       def draw(self, context):
-               layout = self.layout
-               layout.active = False
+        layout.prop(cmat, "homogeneous_volume")
 
-               mat = context.material
-               panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Volume')
 
-class CyclesMaterial_PT_displacement(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Displacement"
-       bl_context = "material"
+class CyclesMaterial_PT_displacement(CyclesButtonsPanel, Panel):
+    bl_label = "Displacement"
+    bl_context = "material"
 
-       @classmethod
-       def poll(cls, context):
-               return context.material and CyclesButtonsPanel.poll(context)
+    @classmethod
+    def poll(cls, context):
+        mat = context.material
+        return mat and mat.node_tree and CyclesButtonsPanel.poll(context)
 
-       def draw(self, context):
-               layout = self.layout
+    def draw(self, context):
+        layout = self.layout
 
-               mat = context.material
-               panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Displacement')
+        mat = context.material
+        panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Displacement')
 
-class CyclesMaterial_PT_settings(CyclesButtonsPanel, bpy.types.Panel):
-       bl_label = "Settings"
-       bl_context = "material"
-       bl_options = {'DEFAULT_CLOSED'}
 
-       @classmethod
-       def poll(cls, context):
-               # return context.material and CyclesButtonsPanel.poll(context)
-               return False
+class CyclesMaterial_PT_settings(CyclesButtonsPanel, Panel):
+    bl_label = "Settings"
+    bl_context = "material"
+    bl_options = {'DEFAULT_CLOSED'}
+
+    @classmethod
+    def poll(cls, context):
+        return context.material and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
+
+        mat = context.material
+        cmat = mat.cycles
+
+        split = layout.split()
+
+        col = split.column()
+        col.prop(mat, "diffuse_color", text="Viewport Color")
+
+        col = split.column()
+        col.prop(cmat, "sample_as_light")
+
+
+class CyclesTexture_PT_context(CyclesButtonsPanel, Panel):
+    bl_label = ""
+    bl_context = "texture"
+    bl_options = {'HIDE_HEADER'}
+    COMPAT_ENGINES = {'CYCLES'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        tex = context.texture
+        space = context.space_data
+        pin_id = space.pin_id
+        use_pin_id = space.use_pin_id
+        user = context.texture_user
+        # node = context.texture_node
+
+        if not use_pin_id or not isinstance(pin_id, bpy.types.Texture):
+            pin_id = None
+
+        if not pin_id:
+            layout.template_texture_user()
+
+        if user:
+            layout.separator()
+
+            split = layout.split(percentage=0.65)
+            col = split.column()
+
+            if pin_id:
+                col.template_ID(space, "pin_id")
+            elif user:
+                col.template_ID(user, "texture", new="texture.new")
+
+            if tex:
+                row = split.row()
+                row.prop(tex, "use_nodes", icon="NODETREE", text="")
+                row.label()
+
+                if not tex.use_nodes:
+                    split = layout.split(percentage=0.2)
+                    split.label(text="Type:")
+                    split.prop(tex, "type", text="")
+
+
+class CyclesTexture_PT_nodes(CyclesButtonsPanel, Panel):
+    bl_label = "Nodes"
+    bl_context = "texture"
+
+    @classmethod
+    def poll(cls, context):
+        tex = context.texture
+        return (tex and tex.use_nodes) and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
+
+        tex = context.texture
+        panel_node_draw(layout, tex, 'OUTPUT_TEXTURE', 'Color')
+
+
+class CyclesTexture_PT_node(CyclesButtonsPanel, Panel):
+    bl_label = "Node"
+    bl_context = "texture"
+
+    @classmethod
+    def poll(cls, context):
+        node = context.texture_node
+        return node and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
+
+        node = context.texture_node
+        ntree = node.id_data
+        layout.template_node_view(ntree, node, None)
+
+
+class CyclesTexture_PT_mapping(CyclesButtonsPanel, Panel):
+    bl_label = "Mapping"
+    bl_context = "texture"
+
+    @classmethod
+    def poll(cls, context):
+        tex = context.texture
+        node = context.texture_node
+        return (node or (tex and tex.use_nodes)) and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
+
+        # tex = context.texture
+        node = context.texture_node
+
+        mapping = node.texture_mapping
+
+        row = layout.row()
+
+        row.column().prop(mapping, "location")
+        row.column().prop(mapping, "rotation")
+        row.column().prop(mapping, "scale")
+
+        layout.label(text="Projection:")
+
+        row = layout.row()
+        row.prop(mapping, "mapping_x", text="")
+        row.prop(mapping, "mapping_y", text="")
+        row.prop(mapping, "mapping_z", text="")
+
+
+class CyclesTexture_PT_colors(CyclesButtonsPanel, Panel):
+    bl_label = "Color"
+    bl_context = "texture"
+    bl_options = {'DEFAULT_CLOSED'}
+
+    @classmethod
+    def poll(cls, context):
+        # tex = context.texture
+        # node = context.texture_node
+        return False
+        #return (node or (tex and tex.use_nodes)) and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
+
+        # tex = context.texture
+        node = context.texture_node
+
+        mapping = node.color_mapping
+
+        split = layout.split()
+
+        col = split.column()
+        col.label(text="Blend:")
+        col.prop(mapping, "blend_type", text="")
+        col.prop(mapping, "blend_factor", text="Factor")
+        col.prop(mapping, "blend_color", text="")
+
+        col = split.column()
+        col.label(text="Adjust:")
+        col.prop(mapping, "brightness")
+        col.prop(mapping, "contrast")
+        col.prop(mapping, "saturation")
+
+        layout.separator()
+
+        layout.prop(mapping, "use_color_ramp", text="Ramp")
+        if mapping.use_color_ramp:
+            layout.template_color_ramp(mapping, "color_ramp", expand=True)
 
-       def draw(self, context):
-               layout = self.layout
 
-               mat = context.material
-       
-               row = layout.row()
-               row.label(text="Light Group:")
-               row.prop(mat, "light_group", text="")
-       
 def draw_device(self, context):
-       scene = context.scene
-       layout = self.layout
+    scene = context.scene
+    layout = self.layout
+
+    if scene.render.engine == 'CYCLES':
+        cscene = scene.cycles
+
+        layout.prop(cscene, "feature_set")
+
+        device_type = context.user_preferences.system.compute_device_type
+        if device_type == 'CUDA':
+            layout.prop(cscene, "device")
+        elif device_type == 'OPENCL' and cscene.feature_set == 'EXPERIMENTAL':
+            layout.prop(cscene, "device")
+
 
-       if scene.render.engine == "CYCLES":
-               cycles = scene.cycles
+def draw_pause(self, context):
+    layout = self.layout
+    scene = context.scene
+
+    if scene.render.engine == "CYCLES":
+        view = context.space_data
+
+        if view.viewport_shade == 'RENDERED':
+            cscene = scene.cycles
+            layout.prop(cscene, "preview_pause", icon="PAUSE", text="")
 
-               if 'cuda' in engine.available_devices():
-                       layout.prop(cycles, "device")
-               if cycles.device == 'CPU' and engine.with_osl():
-                       layout.prop(cycles, "shading_system")
 
 def get_panels():
-       return [
-               bpy.types.RENDER_PT_render,
-               bpy.types.RENDER_PT_output,
-               bpy.types.RENDER_PT_encoding,
-               bpy.types.RENDER_PT_dimensions,
-               bpy.types.RENDER_PT_stamp,
-               bpy.types.WORLD_PT_context_world,
-               bpy.types.DATA_PT_context_mesh,
-               bpy.types.DATA_PT_vertex_groups,
-               bpy.types.DATA_PT_shape_keys,
-               bpy.types.DATA_PT_uv_texture,
-               bpy.types.DATA_PT_vertex_colors,
-               bpy.types.DATA_PT_custom_props_mesh,
-               bpy.types.DATA_PT_context_camera,
-               bpy.types.DATA_PT_camera,
-               bpy.types.DATA_PT_camera_display,
-               bpy.types.DATA_PT_custom_props_camera,
-               bpy.types.DATA_PT_context_lamp,
-               bpy.types.DATA_PT_custom_props_lamp,
-               bpy.types.TEXTURE_PT_context_texture]
+    return (
+        bpy.types.RENDER_PT_render,
+        bpy.types.RENDER_PT_output,
+        bpy.types.RENDER_PT_encoding,
+        bpy.types.RENDER_PT_dimensions,
+        bpy.types.RENDER_PT_stamp,
+        bpy.types.SCENE_PT_scene,
+        bpy.types.SCENE_PT_audio,
+        bpy.types.SCENE_PT_unit,
+        bpy.types.SCENE_PT_keying_sets,
+        bpy.types.SCENE_PT_keying_set_paths,
+        bpy.types.SCENE_PT_physics,
+        bpy.types.WORLD_PT_context_world,
+        bpy.types.DATA_PT_context_mesh,
+        bpy.types.DATA_PT_context_camera,
+        bpy.types.DATA_PT_context_lamp,
+        bpy.types.DATA_PT_texture_space,
+        bpy.types.DATA_PT_curve_texture_space,
+        bpy.types.DATA_PT_mball_texture_space,
+        bpy.types.DATA_PT_vertex_groups,
+        bpy.types.DATA_PT_shape_keys,
+        bpy.types.DATA_PT_uv_texture,
+        bpy.types.DATA_PT_vertex_colors,
+        bpy.types.DATA_PT_camera,
+        bpy.types.DATA_PT_camera_display,
+        bpy.types.DATA_PT_lens,
+        bpy.types.DATA_PT_custom_props_mesh,
+        bpy.types.DATA_PT_custom_props_camera,
+        bpy.types.DATA_PT_custom_props_lamp,
+        bpy.types.TEXTURE_PT_clouds,
+        bpy.types.TEXTURE_PT_wood,
+        bpy.types.TEXTURE_PT_marble,
+        bpy.types.TEXTURE_PT_magic,
+        bpy.types.TEXTURE_PT_blend,
+        bpy.types.TEXTURE_PT_stucci,
+        bpy.types.TEXTURE_PT_image,
+        bpy.types.TEXTURE_PT_image_sampling,
+        bpy.types.TEXTURE_PT_image_mapping,
+        bpy.types.TEXTURE_PT_musgrave,
+        bpy.types.TEXTURE_PT_voronoi,
+        bpy.types.TEXTURE_PT_distortednoise,
+        bpy.types.TEXTURE_PT_voxeldata,
+        bpy.types.TEXTURE_PT_pointdensity,
+        bpy.types.TEXTURE_PT_pointdensity_turbulence,
+        bpy.types.PARTICLE_PT_context_particles,
+        bpy.types.PARTICLE_PT_emission,
+        bpy.types.PARTICLE_PT_hair_dynamics,
+        bpy.types.PARTICLE_PT_cache,
+        bpy.types.PARTICLE_PT_velocity,
+        bpy.types.PARTICLE_PT_rotation,
+        bpy.types.PARTICLE_PT_physics,
+        bpy.types.PARTICLE_PT_boidbrain,
+        bpy.types.PARTICLE_PT_render,
+        bpy.types.PARTICLE_PT_draw,
+        bpy.types.PARTICLE_PT_children,
+        bpy.types.PARTICLE_PT_field_weights,
+        bpy.types.PARTICLE_PT_force_fields,
+        bpy.types.PARTICLE_PT_vertexgroups,
+        bpy.types.PARTICLE_PT_custom_props,
+        )
+
 
 def register():
-       bpy.types.RENDER_PT_render.append(draw_device)
+    bpy.types.RENDER_PT_render.append(draw_device)
+    bpy.types.VIEW3D_HT_header.append(draw_pause)
+
+    for panel in get_panels():
+        panel.COMPAT_ENGINES.add('CYCLES')
 
-       for panel in get_panels():
-               panel.COMPAT_ENGINES.add('CYCLES')
-       
-def unregister():
-       bpy.types.RENDER_PT_render.remove(draw_device)
 
-       for panel in get_panels():
-               panel.COMPAT_ENGINES.remove('CYCLES')
+def unregister():
+    bpy.types.RENDER_PT_render.remove(draw_device)
+    bpy.types.VIEW3D_HT_header.remove(draw_pause)
 
+    for panel in get_panels():
+        panel.COMPAT_ENGINES.remove('CYCLES')