# # Copyright 2011, Blender Foundation. # # 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. # # import bpy 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' class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel): bl_label = "Integrator" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout scene = context.scene cscene = scene.cycles 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 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() sub = col.column(align=True) sub.label(text="Bounces:") sub.prop(cscene, "max_bounces", text="Max") sub.prop(cscene, "min_bounces", text="Min") 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") #row = col.row() #row.prop(cscene, "blur_caustics") #row.active = not cscene.no_caustics class CyclesRender_PT_film(CyclesButtonsPanel, Panel): bl_label = "Film" def draw(self, context): layout = self.layout scene = context.scene cscene = scene.cycles split = layout.split() 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") class CyclesRender_PT_performance(CyclesButtonsPanel, Panel): bl_label = "Performance" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout scene = context.scene rd = scene.render cscene = scene.cycles split = layout.split() col = split.column(align=True) 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") 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 rl = rd.layers[0] 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() layout.prop(rl, "material_override", text="Material") class Cycles_PT_post_processing(CyclesButtonsPanel, Panel): bl_label = "Post Processing" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout rd = context.scene.render split = layout.split() col = split.column() col.prop(rd, "use_compositing") col.prop(rd, "use_sequencer") col = split.column() col.prop(rd, "dither_intensity", text="Dither", slider=True) class CyclesCamera_PT_dof(CyclesButtonsPanel, Panel): bl_label = "Depth of Field" bl_context = "data" @classmethod def poll(cls, context): return context.camera and CyclesButtonsPanel.poll(context) def draw(self, context): layout = self.layout cam = context.camera ccam = cam.cycles split = layout.split() 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() col.label("Aperture:") col.prop(ccam, "aperture_size", text="Size") 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 if ob: row = layout.row() 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 mesh = context.mesh curve = context.curve mball = context.meta_ball if mesh: cdata = mesh.cycles elif curve: cdata = curve.cycles elif mball: cdata = mball.cycles layout.prop(cdata, "displacement_method", text="Method") layout.prop(cdata, "use_subdivision") layout.prop(cdata, "dicing_rate") class CyclesObject_PT_ray_visibility(CyclesButtonsPanel, Panel): bl_label = "Ray Visibility" bl_context = "object" bl_options = {'DEFAULT_CLOSED'} @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' def draw(self, context): layout = self.layout ob = context.object visibility = ob.cycles_visibility split = layout.split() col = split.column() col.prop(visibility, "camera") col.prop(visibility, "diffuse") col.prop(visibility, "glossy") col = split.column() col.prop(visibility, "transmission") col.prop(visibility, "shadow") def find_node(material, nodetype): 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 def find_node_input(node, name): 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) 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) 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") 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" @classmethod def poll(cls, context): return context.lamp and CyclesButtonsPanel.poll(context) def draw(self, context): layout = self.layout 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 world = context.world if not panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Surface'): layout.prop(world, "horizon_color", text="Color") class CyclesWorld_PT_volume(CyclesButtonsPanel, Panel): bl_label = "Volume" bl_context = "world" bl_options = {'DEFAULT_CLOSED'} @classmethod def poll(cls, context): # world = context.world # world and world.node_tree and CyclesButtonsPanel.poll(context) return False def draw(self, context): layout = self.layout layout.active = False world = context.world panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Volume') class CyclesMaterial_PT_surface(CyclesButtonsPanel, Panel): bl_label = "Surface" bl_context = "material" @classmethod def poll(cls, context): return context.material and CyclesButtonsPanel.poll(context) def draw(self, context): layout = self.layout mat = context.material if not panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Surface'): layout.prop(mat, "diffuse_color") class CyclesMaterial_PT_volume(CyclesButtonsPanel, Panel): bl_label = "Volume" bl_context = "material" bl_options = {'DEFAULT_CLOSED'} @classmethod def poll(cls, context): # mat = context.material # mat and mat.node_tree and CyclesButtonsPanel.poll(context) return False def draw(self, context): layout = self.layout layout.active = False mat = context.material cmat = mat.cycles panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Volume') layout.prop(cmat, "homogeneous_volume") class CyclesMaterial_PT_displacement(CyclesButtonsPanel, Panel): bl_label = "Displacement" bl_context = "material" @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 mat = context.material panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Displacement') 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_device(self, context): scene = context.scene layout = self.layout if scene.render.engine == "CYCLES": cscene = scene.cycles layout.prop(cscene, "feature_set") experimental = cscene.feature_set == 'EXPERIMENTAL' available_devices = engine.available_devices() available_cuda = 'cuda' in available_devices available_opencl = experimental and 'opencl' in available_devices if available_cuda or available_opencl: layout.prop(cscene, "device") if cscene.device == 'GPU' and available_cuda and available_opencl: layout.prop(cscene, "gpu_type") if experimental and cscene.device == 'CPU' and engine.with_osl(): layout.prop(cscene, "shading_system") 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="") 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_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.VIEW3D_HT_header.append(draw_pause) for panel in get_panels(): panel.COMPAT_ENGINES.add('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')