text: #
  # Copyright 2011-2013 Blender Foundation
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  # http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  #
  
  # <pep8 compliant>
  
  import bpy
  from bpy_extras.node_utils import find_node_input
  from bl_ui.utils import PresetPanel
  
  from bpy.types import Panel
  
  from bl_ui.properties_grease_pencil_common import GreasePencilSimplifyPanel
  from bl_ui.properties_view_layer import ViewLayerCryptomattePanel
  
  
  class CYCLES_PT_sampling_presets(PresetPanel, Panel):
      bl_label = "Sampling Presets"
      preset_subdir = "cycles/sampling"
      preset_operator = "script.execute_preset"
      preset_add_operator = "render.cycles_sampling_preset_add"
      COMPAT_ENGINES = {'CYCLES'}
  
  
  class CYCLES_PT_integrator_presets(PresetPanel, Panel):
      bl_label = "Integrator Presets"
      preset_subdir = "cycles/integrator"
      preset_operator = "script.execute_preset"
      preset_add_operator = "render.cycles_integrator_preset_add"
      COMPAT_ENGINES = {'CYCLES'}
  
  
  class CyclesButtonsPanel:
      bl_space_type = "PROPERTIES"
      bl_region_type = "WINDOW"
      bl_context = "render"
      COMPAT_ENGINES = {'CYCLES'}
  
      @classmethod
      def poll(cls, context):
          return context.engine in cls.COMPAT_ENGINES
  
  
  # Adapt properties editor panel to display in node editor. We have to
  # copy the class rather than inherit due to the way bpy registration works.
  def node_panel(cls):
      node_cls = type('NODE_' + cls.__name__, cls.__bases__, dict(cls.__dict__))
  
      node_cls.bl_space_type = 'NODE_EDITOR'
      node_cls.bl_region_type = 'UI'
      node_cls.bl_category = "Options"
      if hasattr(node_cls, 'bl_parent_id'):
          node_cls.bl_parent_id = 'NODE_' + node_cls.bl_parent_id
  
      return node_cls
  
  
  def get_device_type(context):
      return context.preferences.addons[__package__].preferences.compute_device_type
  
  
  def use_cpu(context):
      cscene = context.scene.cycles
  
      return (get_device_type(context) == 'NONE' or cscene.device == 'CPU')
  
  
  def use_opencl(context):
      cscene = context.scene.cycles
  
      return (get_device_type(context) == 'OPENCL' and cscene.device == 'GPU')
  
  
  def use_cuda(context):
      cscene = context.scene.cycles
  
      return (get_device_type(context) == 'CUDA' and cscene.device == 'GPU')
  
  
  def use_optix(context):
      cscene = context.scene.cycles
  
      return (get_device_type(context) == 'OPTIX' and cscene.device == 'GPU')
  
  
  def use_branched_path(context):
      cscene = context.scene.cycles
  
      return (cscene.progressive == 'BRANCHED_PATH' and not use_optix(context))
  
  
  def use_sample_all_lights(context):
      cscene = context.scene.cycles
  
      return cscene.sample_all_lights_direct or cscene.sample_all_lights_indirect
  
  
  def show_device_active(context):
      cscene = context.scene.cycles
      if cscene.device != 'GPU':
          return True
      return context.preferences.addons[__package__].preferences.has_active_device()
  
  
  def draw_samples_info(layout, context):
      cscene = context.scene.cycles
      integrator = cscene.progressive
  
      # Calculate sample values
      if integrator == 'PATH':
          aa = cscene.samples
          if cscene.use_square_samples:
              aa = aa * aa
      else:
          aa = cscene.aa_samples
          d = cscene.diffuse_samples
          g = cscene.glossy_samples
          t = cscene.transmission_samples
          ao = cscene.ao_samples
          ml = cscene.mesh_light_samples
          sss = cscene.subsurface_samples
          vol = cscene.volume_samples
  
          if cscene.use_square_samples:
              aa = aa * aa
              d = d * d
              g = g * g
              t = t * t
              ao = ao * ao
              ml = ml * ml
              sss = sss * sss
              vol = vol * vol
  
      # Draw interface
      # Do not draw for progressive, when Square Samples are disabled
      if use_branched_path(context) or (cscene.use_square_samples and integrator == 'PATH'):
          col = layout.column(align=True)
          col.scale_y = 0.6
          col.label(text="Total Samples:")
          col.separator()
          if integrator == 'PATH':
              col.label(text="%s AA" % aa)
          else:
              col.label(text="%s AA, %s Diffuse, %s Glossy, %s Transmission" %
                        (aa, d * aa, g * aa, t * aa))
              col.separator()
              col.label(text="%s AO, %s Mesh Light, %s Subsurface, %s Volume" %
                        (ao * aa, ml * aa, sss * aa, vol * aa))
  
  
  class CYCLES_RENDER_PT_sampling(CyclesButtonsPanel, Panel):
      bl_label = "Sampling"
  
      def draw_header_preset(self, context):
          CYCLES_PT_sampling_presets.draw_panel_header(self.layout)
  
      def draw(self, context):
          layout = self.layout
  
          scene = context.scene
          cscene = scene.cycles
  
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          if not use_optix(context):
              layout.prop(cscene, "progressive")
  
          if not use_branched_path(context):
              col = layout.column(align=True)
              col.prop(cscene, "samples", text="Render")
              col.prop(cscene, "preview_samples", text="Viewport")
          else:
              col = layout.column(align=True)
              col.prop(cscene, "aa_samples", text="Render")
              col.prop(cscene, "preview_aa_samples", text="Viewport")
  
          if not use_branched_path(context):
              draw_samples_info(layout, context)
  
  
  class CYCLES_RENDER_PT_sampling_sub_samples(CyclesButtonsPanel, Panel):
      bl_label = "Sub Samples"
      bl_parent_id = "CYCLES_RENDER_PT_sampling"
  
      @classmethod
      def poll(cls, context):
          return use_branched_path(context)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column(align=True)
          col.prop(cscene, "diffuse_samples", text="Diffuse")
          col.prop(cscene, "glossy_samples", text="Glossy")
          col.prop(cscene, "transmission_samples", text="Transmission")
          col.prop(cscene, "ao_samples", text="AO")
  
          sub = col.row(align=True)
          sub.active = use_sample_all_lights(context)
          sub.prop(cscene, "mesh_light_samples", text="Mesh Light")
          col.prop(cscene, "subsurface_samples", text="Subsurface")
          col.prop(cscene, "volume_samples", text="Volume")
  
          draw_samples_info(layout, context)
  
  
  class CYCLES_RENDER_PT_sampling_adaptive(CyclesButtonsPanel, Panel):
      bl_label = "Adaptive Sampling"
      bl_parent_id = "CYCLES_RENDER_PT_sampling"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw_header(self, context):
          layout = self.layout
          scene = context.scene
          cscene = scene.cycles
  
          layout.prop(cscene, "use_adaptive_sampling", text="")
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          layout.active = cscene.use_adaptive_sampling
  
          col = layout.column(align=True)
          col.prop(cscene, "adaptive_threshold", text="Noise Threshold")
          col.prop(cscene, "adaptive_min_samples", text="Min Samples")
  
  
  class CYCLES_RENDER_PT_sampling_denoising(CyclesButtonsPanel, Panel):
      bl_label = "Denoising"
      bl_parent_id = "CYCLES_RENDER_PT_sampling"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          heading = layout.column(align=True, heading="Render")
          row = heading.row(align=True)
          row.prop(cscene, "use_denoising", text="")
          sub = row.row()
  
          sub.active = cscene.use_denoising
          for view_layer in scene.view_layers:
              if view_layer.cycles.denoising_store_passes:
                  sub.active = True
  
          sub.prop(cscene, "denoiser", text="")
  
          heading = layout.column(align=False, heading="Viewport")
          row = heading.row(align=True)
          row.prop(cscene, "use_preview_denoising", text="")
          sub = row.row()
          sub.active = cscene.use_preview_denoising
          sub.prop(cscene, "preview_denoiser", text="")
  
          sub = heading.row(align=True)
          sub.active = cscene.use_preview_denoising
          sub.prop(cscene, "preview_denoising_start_sample", text="Start Sample")
  
  
  class CYCLES_RENDER_PT_sampling_advanced(CyclesButtonsPanel, Panel):
      bl_label = "Advanced"
      bl_parent_id = "CYCLES_RENDER_PT_sampling"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          row = layout.row(align=True)
          row.prop(cscene, "seed")
          row.prop(cscene, "use_animated_seed", text="", icon='TIME')
  
          col = layout.column(align=True)
          col.active = not(cscene.use_adaptive_sampling)
          col.prop(cscene, "sampling_pattern", text="Pattern")
  
          layout.prop(cscene, "use_square_samples")
  
          layout.separator()
  
          col = layout.column(align=True)
          col.prop(cscene, "min_light_bounces")
          col.prop(cscene, "min_transparent_bounces")
          col.prop(cscene, "light_sampling_threshold", text="Light Threshold")
  
          if cscene.progressive != 'PATH' and use_branched_path(context):
              col = layout.column(align=True)
              col.prop(cscene, "sample_all_lights_direct")
              col.prop(cscene, "sample_all_lights_indirect")
  
          for view_layer in scene.view_layers:
              if view_layer.samples > 0:
                  layout.separator()
                  layout.row().prop(cscene, "use_layer_samples")
                  break
  
  
  class CYCLES_RENDER_PT_sampling_total(CyclesButtonsPanel, Panel):
      bl_label = "Total Samples"
      bl_parent_id = "CYCLES_RENDER_PT_sampling"
  
      @classmethod
      def poll(cls, context):
          scene = context.scene
          cscene = scene.cycles
  
          if cscene.use_square_samples:
              return True
  
          return cscene.progressive != 'PATH' and use_branched_path(context)
  
      def draw(self, context):
          layout = self.layout
          cscene = context.scene.cycles
          integrator = cscene.progressive
  
          # Calculate sample values
          if integrator == 'PATH':
              aa = cscene.samples
              if cscene.use_square_samples:
                  aa = aa * aa
          else:
              aa = cscene.aa_samples
              d = cscene.diffuse_samples
              g = cscene.glossy_samples
              t = cscene.transmission_samples
              ao = cscene.ao_samples
              ml = cscene.mesh_light_samples
              sss = cscene.subsurface_samples
              vol = cscene.volume_samples
  
              if cscene.use_square_samples:
                  aa = aa * aa
                  d = d * d
                  g = g * g
                  t = t * t
                  ao = ao * ao
                  ml = ml * ml
                  sss = sss * sss
                  vol = vol * vol
  
          col = layout.column(align=True)
          col.scale_y = 0.6
          if integrator == 'PATH':
              col.label(text="%s AA" % aa)
          else:
              col.label(text="%s AA, %s Diffuse, %s Glossy, %s Transmission" %
                        (aa, d * aa, g * aa, t * aa))
              col.separator()
              col.label(text="%s AO, %s Mesh Light, %s Subsurface, %s Volume" %
                        (ao * aa, ml * aa, sss * aa, vol * aa))
  
  
  class CYCLES_RENDER_PT_subdivision(CyclesButtonsPanel, Panel):
      bl_label = "Subdivision"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          return (context.scene.render.engine == 'CYCLES') and (context.scene.cycles.feature_set == 'EXPERIMENTAL')
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column()
          sub = col.column(align=True)
          sub.prop(cscene, "dicing_rate", text="Dicing Rate Render")
          sub.prop(cscene, "preview_dicing_rate", text="Viewport")
  
          col.separator()
  
          col.prop(cscene, "offscreen_dicing_scale", text="Offscreen Scale")
          col.prop(cscene, "max_subdivisions")
  
          col.prop(cscene, "dicing_camera")
  
  
  class CYCLES_RENDER_PT_hair(CyclesButtonsPanel, Panel):
      bl_label = "Hair"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          ccscene = scene.cycles_curves
  
          col = layout.column()
          col.prop(ccscene, "shape", text="Shape")
          if ccscene.shape == 'RIBBONS':
              col.prop(ccscene, "subdivisions", text="Curve Subdivisions")
  
  
  class CYCLES_RENDER_PT_volumes(CyclesButtonsPanel, Panel):
      bl_label = "Volumes"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column(align=True)
          col.prop(cscene, "volume_step_rate", text="Step Rate Render")
          col.prop(cscene, "volume_preview_step_rate", text="Viewport")
  
          layout.prop(cscene, "volume_max_steps", text="Max Steps")
  
  
  class CYCLES_RENDER_PT_light_paths(CyclesButtonsPanel, Panel):
      bl_label = "Light Paths"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw_header_preset(self, context):
          CYCLES_PT_integrator_presets.draw_panel_header(self.layout)
  
      def draw(self, context):
          pass
  
  
  class CYCLES_RENDER_PT_light_paths_max_bounces(CyclesButtonsPanel, Panel):
      bl_label = "Max Bounces"
      bl_parent_id = "CYCLES_RENDER_PT_light_paths"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column(align=True)
          col.prop(cscene, "max_bounces", text="Total")
  
          col = layout.column(align=True)
          col.prop(cscene, "diffuse_bounces", text="Diffuse")
          col.prop(cscene, "glossy_bounces", text="Glossy")
          col.prop(cscene, "transparent_max_bounces", text="Transparency")
          col.prop(cscene, "transmission_bounces", text="Transmission")
          col.prop(cscene, "volume_bounces", text="Volume")
  
  
  class CYCLES_RENDER_PT_light_paths_clamping(CyclesButtonsPanel, Panel):
      bl_label = "Clamping"
      bl_parent_id = "CYCLES_RENDER_PT_light_paths"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column(align=True)
          col.prop(cscene, "sample_clamp_direct", text="Direct Light")
          col.prop(cscene, "sample_clamp_indirect", text="Indirect Light")
  
  
  class CYCLES_RENDER_PT_light_paths_caustics(CyclesButtonsPanel, Panel):
      bl_label = "Caustics"
      bl_parent_id = "CYCLES_RENDER_PT_light_paths"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column()
          col.prop(cscene, "blur_glossy")
          col = layout.column(heading="Caustics", align=True)
          col.prop(cscene, "caustics_reflective", text="Reflective")
          col.prop(cscene, "caustics_refractive", text="Refractive")
  
  
  class CYCLES_RENDER_PT_motion_blur(CyclesButtonsPanel, Panel):
      bl_label = "Motion Blur"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw_header(self, context):
          rd = context.scene.render
  
          self.layout.prop(rd, "use_motion_blur", text="")
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
          rd = scene.render
          layout.active = rd.use_motion_blur
  
          col = layout.column()
          col.prop(cscene, "motion_blur_position", text="Position")
          col.prop(rd, "motion_blur_shutter")
          col.separator()
          col.prop(cscene, "rolling_shutter_type", text="Rolling Shutter")
          sub = col.column()
          sub.active = cscene.rolling_shutter_type != 'NONE'
          sub.prop(cscene, "rolling_shutter_duration")
  
  
  class CYCLES_RENDER_PT_motion_blur_curve(CyclesButtonsPanel, Panel):
      bl_label = "Shutter Curve"
      bl_parent_id = "CYCLES_RENDER_PT_motion_blur"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
          layout.active = rd.use_motion_blur
  
          col = layout.column()
  
          col.template_curve_mapping(rd, "motion_blur_shutter_curve")
  
          col = layout.column(align=True)
          row = col.row(align=True)
          row.operator("render.shutter_curve_preset", icon='SMOOTHCURVE', text="").shape = 'SMOOTH'
          row.operator("render.shutter_curve_preset", icon='SPHERECURVE', text="").shape = 'ROUND'
          row.operator("render.shutter_curve_preset", icon='ROOTCURVE', text="").shape = 'ROOT'
          row.operator("render.shutter_curve_preset", icon='SHARPCURVE', text="").shape = 'SHARP'
          row.operator("render.shutter_curve_preset", icon='LINCURVE', text="").shape = 'LINE'
          row.operator("render.shutter_curve_preset", icon='NOCURVE', text="").shape = 'MAX'
  
  
  class CYCLES_RENDER_PT_film(CyclesButtonsPanel, Panel):
      bl_label = "Film"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column()
          col.prop(cscene, "film_exposure")
  
  
  class CYCLES_RENDER_PT_film_transparency(CyclesButtonsPanel, Panel):
      bl_label = "Transparent"
      bl_parent_id = "CYCLES_RENDER_PT_film"
  
      def draw_header(self, context):
          layout = self.layout
  
          scene = context.scene
          rd = scene.render
  
          layout.prop(rd, "film_transparent", text="")
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
          scene = context.scene
          rd = scene.render
          cscene = scene.cycles
  
          layout.active = rd.film_transparent
  
          col = layout.column()
          col.prop(cscene, "film_transparent_glass", text="Transparent Glass")
  
          sub = col.column()
          sub.active = rd.film_transparent and cscene.film_transparent_glass
          sub.prop(cscene, "film_transparent_roughness", text="Roughness Threshold")
  
  
  class CYCLES_RENDER_PT_film_pixel_filter(CyclesButtonsPanel, Panel):
      bl_label = "Pixel Filter"
      bl_parent_id = "CYCLES_RENDER_PT_film"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column()
          col.prop(cscene, "pixel_filter_type", text="Type")
          if cscene.pixel_filter_type != 'BOX':
              col.prop(cscene, "filter_width", text="Width")
  
  
  class CYCLES_RENDER_PT_performance(CyclesButtonsPanel, Panel):
      bl_label = "Performance"
      bl_options = {'DEFAULT_CLOSED'}
  
      def draw(self, context):
          pass
  
  
  class CYCLES_RENDER_PT_performance_threads(CyclesButtonsPanel, Panel):
      bl_label = "Threads"
      bl_parent_id = "CYCLES_RENDER_PT_performance"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
  
          col = layout.column()
  
          col.prop(rd, "threads_mode")
          sub = col.column(align=True)
          sub.enabled = rd.threads_mode == 'FIXED'
          sub.prop(rd, "threads")
  
  
  class CYCLES_RENDER_PT_performance_tiles(CyclesButtonsPanel, Panel):
      bl_label = "Tiles"
      bl_parent_id = "CYCLES_RENDER_PT_performance"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
          cscene = scene.cycles
  
          col = layout.column()
  
          sub = col.column(align=True)
          sub.prop(rd, "tile_x", text="Tiles X")
          sub.prop(rd, "tile_y", text="Y")
          col.prop(cscene, "tile_order", text="Order")
  
          sub = col.column()
          sub.active = not rd.use_save_buffers
          sub.prop(cscene, "use_progressive_refine")
  
  
  class CYCLES_RENDER_PT_performance_acceleration_structure(CyclesButtonsPanel, Panel):
      bl_label = "Acceleration Structure"
      bl_parent_id = "CYCLES_RENDER_PT_performance"
  
      def draw(self, context):
          import _cycles
  
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column()
  
          use_embree = False
          if use_cpu(context):
              use_embree = _cycles.with_embree
              if not use_embree:
                  sub = col.column(align=True)
                  sub.label(text="Cycles built without Embree support")
                  sub.label(text="CPU raytracing performance will be poor")
  
          col.prop(cscene, "debug_use_spatial_splits")
          sub = col.column()
          sub.active = not use_embree
          sub.prop(cscene, "debug_use_hair_bvh")
          sub = col.column()
          sub.active = not cscene.debug_use_spatial_splits and not use_embree
          sub.prop(cscene, "debug_bvh_time_steps")
  
  
  class CYCLES_RENDER_PT_performance_final_render(CyclesButtonsPanel, Panel):
      bl_label = "Final Render"
      bl_parent_id = "CYCLES_RENDER_PT_performance"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
  
          col = layout.column()
  
          col.prop(rd, "use_save_buffers")
          col.prop(rd, "use_persistent_data", text="Persistent Images")
  
  
  class CYCLES_RENDER_PT_performance_viewport(CyclesButtonsPanel, Panel):
      bl_label = "Viewport"
      bl_parent_id = "CYCLES_RENDER_PT_performance"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
          cscene = scene.cycles
  
          col = layout.column()
          col.prop(rd, "preview_pixel_size", text="Pixel Size")
          col.prop(cscene, "preview_start_resolution", text="Start Pixels")
  
  
  class CYCLES_RENDER_PT_filter(CyclesButtonsPanel, Panel):
      bl_label = "Filter"
      bl_options = {'DEFAULT_CLOSED'}
      bl_context = "view_layer"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          with_freestyle = bpy.app.build_options.freestyle
  
          scene = context.scene
          rd = scene.render
          view_layer = context.view_layer
  
          col = layout.column(heading="Include")
          col.prop(view_layer, "use_sky", text="Environment")
          col.prop(view_layer, "use_ao", text="Ambient Occlusion")
          col.prop(view_layer, "use_solid", text="Surfaces")
          col.prop(view_layer, "use_strand", text="Hair")
          col.prop(view_layer, "use_volumes", text="Volumes")
  
  
  class CYCLES_RENDER_PT_override(CyclesButtonsPanel, Panel):
      bl_label = "Override"
      bl_options = {'DEFAULT_CLOSED'}
      bl_context = "view_layer"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          view_layer = context.view_layer
  
          layout.prop(view_layer, "material_override")
          layout.prop(view_layer, "samples")
  
  
  class CYCLES_RENDER_PT_passes(CyclesButtonsPanel, Panel):
      bl_label = "Passes"
      bl_context = "view_layer"
  
      def draw(self, context):
          pass
  
  
  class CYCLES_RENDER_PT_passes_data(CyclesButtonsPanel, Panel):
      bl_label = "Data"
      bl_context = "view_layer"
      bl_parent_id = "CYCLES_RENDER_PT_passes"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
          view_layer = context.view_layer
          cycles_view_layer = view_layer.cycles
  
          col = layout.column(heading="Include", align=True)
          col.prop(view_layer, "use_pass_combined")
          col.prop(view_layer, "use_pass_z")
          col.prop(view_layer, "use_pass_mist")
          col.prop(view_layer, "use_pass_normal")
          sub = col.column()
          sub.active = not rd.use_motion_blur
          sub.prop(view_layer, "use_pass_vector")
          col.prop(view_layer, "use_pass_uv")
  
          col.prop(cycles_view_layer, "denoising_store_passes", text="Denoising Data")
  
          col = layout.column(heading="Indexes", align=True)
          col.prop(view_layer, "use_pass_object_index")
          col.prop(view_layer, "use_pass_material_index")
  
          col = layout.column(heading="Debug", align=True)
          col.prop(cycles_view_layer, "pass_debug_render_time", text="Render Time")
          col.prop(cycles_view_layer, "pass_debug_sample_count", text="Sample Count")
  
          layout.prop(view_layer, "pass_alpha_threshold")
  
  
  class CYCLES_RENDER_PT_passes_light(CyclesButtonsPanel, Panel):
      bl_label = "Light"
      bl_context = "view_layer"
      bl_parent_id = "CYCLES_RENDER_PT_passes"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          view_layer = context.view_layer
          cycles_view_layer = view_layer.cycles
  
          col = layout.column(heading="Diffuse", align=True)
          col.prop(view_layer, "use_pass_diffuse_direct", text="Direct")
          col.prop(view_layer, "use_pass_diffuse_indirect", text="Indirect")
          col.prop(view_layer, "use_pass_diffuse_color", text="Color")
  
          col = layout.column(heading="Glossy", align=True)
          col.prop(view_layer, "use_pass_glossy_direct", text="Direct")
          col.prop(view_layer, "use_pass_glossy_indirect", text="Indirect")
          col.prop(view_layer, "use_pass_glossy_color", text="Color")
  
          col = layout.column(heading="Transmission", align=True)
          col.prop(view_layer, "use_pass_transmission_direct", text="Direct")
          col.prop(view_layer, "use_pass_transmission_indirect", text="Indirect")
          col.prop(view_layer, "use_pass_transmission_color", text="Color")
  
          col = layout.column(heading="Volume", align=True)
          col.prop(cycles_view_layer, "use_pass_volume_direct", text="Direct")
          col.prop(cycles_view_layer, "use_pass_volume_indirect", text="Indirect")
  
          col = layout.column(heading="Other", align=True)
          col.prop(view_layer, "use_pass_emit", text="Emission")
          col.prop(view_layer, "use_pass_environment")
          col.prop(view_layer, "use_pass_shadow")
          col.prop(view_layer, "use_pass_ambient_occlusion", text="Ambient Occlusion")
  
  
  class CYCLES_RENDER_PT_passes_crypto(CyclesButtonsPanel, ViewLayerCryptomattePanel):
      bl_label = "Cryptomatte"
      bl_context = "view_layer"
      bl_parent_id = "CYCLES_RENDER_PT_passes"
  
  
  class CYCLES_RENDER_PT_passes_debug(CyclesButtonsPanel, Panel):
      bl_label = "Debug"
      bl_context = "view_layer"
      bl_parent_id = "CYCLES_RENDER_PT_passes"
  
      @classmethod
      def poll(cls, context):
          import _cycles
          return _cycles.with_cycles_debug
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          cycles_view_layer = context.view_layer.cycles
  
          layout.prop(cycles_view_layer, "pass_debug_bvh_traversed_nodes")
          layout.prop(cycles_view_layer, "pass_debug_bvh_traversed_instances")
          layout.prop(cycles_view_layer, "pass_debug_bvh_intersections")
          layout.prop(cycles_view_layer, "pass_debug_ray_bounces")
  
  
  class CYCLES_RENDER_UL_aov(bpy.types.UIList):
      def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
          row = layout.row()
          split = row.split(factor=0.65)
          icon = 'ERROR' if item.conflict else 'NONE'
          split.row().prop(item, "name", text="", icon=icon, emboss=False)
          split.row().prop(item, "type", text="", emboss=False)
  
  
  class CYCLES_RENDER_PT_passes_aov(CyclesButtonsPanel, Panel):
      bl_label = "Shader AOV"
      bl_context = "view_layer"
      bl_parent_id = "CYCLES_RENDER_PT_passes"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          cycles_view_layer = context.view_layer.cycles
  
          row = layout.row()
          col = row.column()
          col.template_list(
              "CYCLES_RENDER_UL_aov",
              "aovs",
              cycles_view_layer,
              "aovs",
              cycles_view_layer,
              "active_aov",
              rows=2,
          )
  
          col = row.column()
          sub = col.column(align=True)
          sub.operator("cycles.add_aov", icon='ADD', text="")
          sub.operator("cycles.remove_aov", icon='REMOVE', text="")
  
          if cycles_view_layer.active_aov < len(cycles_view_layer.aovs):
              active_aov = cycles_view_layer.aovs[cycles_view_layer.active_aov]
              if active_aov.conflict:
                  layout.label(text=active_aov.conflict, icon='ERROR')
  
  
  class CYCLES_RENDER_PT_denoising(CyclesButtonsPanel, Panel):
      bl_label = "Denoising"
      bl_context = "view_layer"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          cscene = context.scene.cycles
          return CyclesButtonsPanel.poll(context) and cscene.use_denoising
  
      def draw_header(self, context):
          scene = context.scene
          view_layer = context.view_layer
          cycles_view_layer = view_layer.cycles
  
          layout = self.layout
          layout.prop(cycles_view_layer, "use_denoising", text="")
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          view_layer = context.view_layer
          cycles_view_layer = view_layer.cycles
          denoiser = scene.cycles.denoiser
  
          layout.active = denoiser != 'NONE' and cycles_view_layer.use_denoising
  
          col = layout.column()
  
          if denoiser == 'OPTIX':
              col.prop(cycles_view_layer, "denoising_optix_input_passes")
              return
          elif denoiser == 'OPENIMAGEDENOISE':
              col.prop(cycles_view_layer, "denoising_openimagedenoise_input_passes")
              return
  
          col.prop(cycles_view_layer, "denoising_radius", text="Radius")
  
          col = layout.column()
          col.prop(cycles_view_layer, "denoising_strength", slider=True, text="Strength")
          col.prop(cycles_view_layer, "denoising_feature_strength", slider=True, text="Feature Strength")
          col.prop(cycles_view_layer, "denoising_relative_pca")
  
          layout.separator()
  
          col = layout.column()
          col.active = cycles_view_layer.use_denoising or cycles_view_layer.denoising_store_passes
  
          row = col.row(heading="Diffuse", align=True)
          row.prop(cycles_view_layer, "denoising_diffuse_direct", text="Direct", toggle=True)
          row.prop(cycles_view_layer, "denoising_diffuse_indirect", text="Indirect", toggle=True)
  
          row = col.row(heading="Glossy", align=True)
          row.prop(cycles_view_layer, "denoising_glossy_direct", text="Direct", toggle=True)
          row.prop(cycles_view_layer, "denoising_glossy_indirect", text="Indirect", toggle=True)
  
          row = col.row(heading="Transmission", align=True)
          row.prop(cycles_view_layer, "denoising_transmission_direct", text="Direct", toggle=True)
          row.prop(cycles_view_layer, "denoising_transmission_indirect", text="Indirect", toggle=True)
  
  
  class CYCLES_PT_post_processing(CyclesButtonsPanel, Panel):
      bl_label = "Post Processing"
      bl_options = {'DEFAULT_CLOSED'}
      bl_context = "output"
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          rd = context.scene.render
  
          col = layout.column(align=True, heading="Pipeline")
          col.prop(rd, "use_compositing")
          col.prop(rd, "use_sequencer")
  
          layout.prop(rd, "dither_intensity", text="Dither", slider=True)
  
  
  class CYCLES_CAMERA_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_header(self, context):
          cam = context.camera
          dof = cam.dof
          self.layout.prop(dof, "use_dof", text="")
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
  
          cam = context.camera
          dof = cam.dof
          layout.active = dof.use_dof
  
          split = layout.split()
  
          col = split.column()
          col.prop(dof, "focus_object", text="Focus Object")
  
          sub = col.row()
          sub.active = dof.focus_object is None
          sub.prop(dof, "focus_distance", text="Distance")
  
  
  class CYCLES_CAMERA_PT_dof_aperture(CyclesButtonsPanel, Panel):
      bl_label = "Aperture"
      bl_parent_id = "CYCLES_CAMERA_PT_dof"
  
      @classmethod
      def poll(cls, context):
          return context.camera and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
  
          cam = context.camera
          dof = cam.dof
          layout.active = dof.use_dof
          flow = layout.grid_flow(row_major=True, columns=0, even_columns=True, even_rows=False, align=False)
  
          col = flow.column()
          col.prop(dof, "aperture_fstop")
          col.prop(dof, "aperture_blades")
          col.prop(dof, "aperture_rotation")
          col.prop(dof, "aperture_ratio")
  
  
  class CYCLES_PT_context_material(CyclesButtonsPanel, Panel):
      bl_label = ""
      bl_context = "material"
      bl_options = {'HIDE_HEADER'}
  
      @classmethod
      def poll(cls, context):
          if context.active_object and context.active_object.type == 'GPENCIL':
              return False
          else:
              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:
              is_sortable = len(ob.material_slots) > 1
              rows = 1
              if (is_sortable):
                  rows = 4
  
              row = layout.row()
  
              row.template_list("MATERIAL_UL_matslots", "", ob, "material_slots", ob, "active_material_index", rows=rows)
  
              col = row.column(align=True)
              col.operator("object.material_slot_add", icon='ADD', text="")
              col.operator("object.material_slot_remove", icon='REMOVE', text="")
  
              col.menu("MATERIAL_MT_context_menu", icon='DOWNARROW_HLT', text="")
  
              if is_sortable:
                  col.separator()
  
                  col.operator("object.material_slot_move", icon='TRIA_UP', text="").direction = 'UP'
                  col.operator("object.material_slot_move", icon='TRIA_DOWN', text="").direction = 'DOWN'
  
              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(factor=0.65)
  
          if ob:
              split.template_ID(ob, "active_material", new="material.new", duplicate="material.duplicate")
              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_OBJECT_PT_motion_blur(CyclesButtonsPanel, Panel):
      bl_label = "Motion Blur"
      bl_context = "object"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          ob = context.object
          if CyclesButtonsPanel.poll(context) and ob:
              if ob.type in {'MESH', 'CURVE', 'CURVE', 'SURFACE', 'FONT', 'META', 'CAMERA'}:
                  return True
              if ob.instance_type == 'COLLECTION' and ob.instance_collection:
                  return True
              # TODO(sergey): More duplicator types here?
          return False
  
      def draw_header(self, context):
          layout = self.layout
  
          rd = context.scene.render
          # scene = context.scene
  
          layout.active = rd.use_motion_blur
  
          ob = context.object
          cob = ob.cycles
  
          layout.prop(cob, "use_motion_blur", text="")
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
  
          rd = context.scene.render
          # scene = context.scene
  
          ob = context.object
          cob = ob.cycles
  
          layout.active = (rd.use_motion_blur and cob.use_motion_blur)
  
          col = layout.column()
          col.prop(cob, "motion_steps", text="Steps")
          if ob.type != 'CAMERA':
              col.prop(cob, "use_deform_motion", text="Deformation")
  
  
  def has_geometry_visibility(ob):
      return ob and ((ob.type in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META', 'LIGHT'}) or
                     (ob.instance_type == 'COLLECTION' and ob.instance_collection))
  
  
  class CYCLES_OBJECT_PT_shading(CyclesButtonsPanel, Panel):
      bl_label = "Shading"
      bl_context = "object"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          return CyclesButtonsPanel.poll(context) and (context.object)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
  
          flow = layout.grid_flow(row_major=False, columns=0, even_columns=True, even_rows=False, align=False)
          layout = self.layout
          ob = context.object
          cob = ob.cycles
  
          if has_geometry_visibility(ob):
              col = flow.column()
              col.prop(cob, "shadow_terminator_offset")
  
  
  class CYCLES_OBJECT_PT_visibility(CyclesButtonsPanel, Panel):
      bl_label = "Visibility"
      bl_context = "object"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          return CyclesButtonsPanel.poll(context) and (context.object)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
  
          ob = context.object
  
          layout.prop(ob, "hide_select", text="Selectable", invert_checkbox=True, toggle=False)
  
          col = layout.column(heading="Show In")
          col.prop(ob, "hide_viewport", text="Viewports", invert_checkbox=True, toggle=False)
          col.prop(ob, "hide_render", text="Renders", invert_checkbox=True, toggle=False)
  
          if has_geometry_visibility(ob):
              cob = ob.cycles
              col = layout.column(heading="Mask")
              col.prop(cob, "is_shadow_catcher")
              col.prop(cob, "is_holdout")
  
  
  class CYCLES_OBJECT_PT_visibility_ray_visibility(CyclesButtonsPanel, Panel):
      bl_label = "Ray Visibility"
      bl_parent_id = "CYCLES_OBJECT_PT_visibility"
      bl_context = "object"
  
      @classmethod
      def poll(cls, context):
          ob = context.object
          return CyclesButtonsPanel.poll(context) and has_geometry_visibility(ob)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          ob = context.object
          cob = ob.cycles
          visibility = ob.cycles_visibility
  
          col = layout.column()
          col.prop(visibility, "camera")
          col.prop(visibility, "diffuse")
          col.prop(visibility, "glossy")
          col.prop(visibility, "transmission")
          col.prop(visibility, "scatter")
  
          if ob.type != 'LIGHT':
              sub = col.column()
              sub.prop(visibility, "shadow")
  
  
  class CYCLES_OBJECT_PT_visibility_culling(CyclesButtonsPanel, Panel):
      bl_label = "Culling"
      bl_parent_id = "CYCLES_OBJECT_PT_visibility"
      bl_context = "object"
  
      @classmethod
      def poll(cls, context):
          ob = context.object
          return CyclesButtonsPanel.poll(context) and has_geometry_visibility(ob)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          cscene = scene.cycles
          ob = context.object
          cob = ob.cycles
  
          row = layout.row()
          row.active = scene.render.use_simplify and cscene.use_camera_cull
          row.prop(cob, "use_camera_cull")
  
          row = layout.row()
          row.active = scene.render.use_simplify and cscene.use_distance_cull
          row.prop(cob, "use_distance_cull")
  
  
  def panel_node_draw(layout, id_data, output_type, input_name):
      if not id_data.use_nodes:
          layout.operator("cycles.use_shading_nodes", icon='NODETREE')
          return False
  
      ntree = id_data.node_tree
  
      node = ntree.get_output_node('CYCLES')
      if node:
          input = find_node_input(node, input_name)
          if input:
              layout.template_node_view(ntree, node, input)
          else:
              layout.label(text="Incompatible output node")
      else:
          layout.label(text="No output node")
  
      return True
  
  
  class CYCLES_LIGHT_PT_preview(CyclesButtonsPanel, Panel):
      bl_label = "Preview"
      bl_context = "data"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          return (
              context.light and
              not (
                  context.light.type == 'AREA' and
                  context.light.cycles.is_portal
              ) and
              CyclesButtonsPanel.poll(context)
          )
  
      def draw(self, context):
          self.layout.template_preview(context.light)
  
  
  class CYCLES_LIGHT_PT_light(CyclesButtonsPanel, Panel):
      bl_label = "Light"
      bl_context = "data"
  
      @classmethod
      def poll(cls, context):
          return context.light and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
  
          light = context.light
          clamp = light.cycles
  
          if self.bl_space_type == 'PROPERTIES':
              layout.row().prop(light, "type", expand=True)
              layout.use_property_split = True
          else:
              layout.use_property_split = True
              layout.row().prop(light, "type")
  
          col = layout.column()
  
          col.prop(light, "color")
          col.prop(light, "energy")
          col.separator()
  
          if light.type in {'POINT', 'SPOT'}:
              col.prop(light, "shadow_soft_size", text="Radius")
          elif light.type == 'SUN':
              col.prop(light, "angle")
          elif light.type == 'AREA':
              col.prop(light, "shape", text="Shape")
              sub = col.column(align=True)
  
              if light.shape in {'SQUARE', 'DISK'}:
                  sub.prop(light, "size")
              elif light.shape in {'RECTANGLE', 'ELLIPSE'}:
                  sub.prop(light, "size", text="Size X")
                  sub.prop(light, "size_y", text="Y")
  
          if not (light.type == 'AREA' and clamp.is_portal):
              sub = col.column()
              if use_branched_path(context):
                  subsub = sub.row(align=True)
                  subsub.active = use_sample_all_lights(context)
                  subsub.prop(clamp, "samples")
              sub.prop(clamp, "max_bounces")
  
          sub = col.column(align=True)
          sub.active = not (light.type == 'AREA' and clamp.is_portal)
          sub.prop(clamp, "cast_shadow")
          sub.prop(clamp, "use_multiple_importance_sampling", text="Multiple Importance")
  
          if light.type == 'AREA':
              col.prop(clamp, "is_portal", text="Portal")
  
  
  class CYCLES_LIGHT_PT_nodes(CyclesButtonsPanel, Panel):
      bl_label = "Nodes"
      bl_context = "data"
  
      @classmethod
      def poll(cls, context):
          return context.light and not (context.light.type == 'AREA' and
                                        context.light.cycles.is_portal) and \
              CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
  
          layout.use_property_split = True
  
          light = context.light
          panel_node_draw(layout, light, 'OUTPUT_LIGHT', 'Surface')
  
  
  class CYCLES_LIGHT_PT_spot(CyclesButtonsPanel, Panel):
      bl_label = "Spot Shape"
      bl_parent_id = "CYCLES_LIGHT_PT_light"
      bl_context = "data"
  
      @classmethod
      def poll(cls, context):
          light = context.light
          return (light and light.type == 'SPOT') and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
          light = context.light
          layout.use_property_split = True
  
          col = layout.column()
          col.prop(light, "spot_size", text="Size")
          col.prop(light, "spot_blend", text="Blend", slider=True)
          col.prop(light, "show_cone")
  
  
  class CYCLES_WORLD_PT_preview(CyclesButtonsPanel, Panel):
      bl_label = "Preview"
      bl_context = "world"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          return context.world and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          self.layout.template_preview(context.world)
  
  
  class CYCLES_WORLD_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
  
          layout.use_property_split = True
  
          world = context.world
  
          if not panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Surface'):
              layout.prop(world, "color")
  
  
  class CYCLES_WORLD_PT_volume(CyclesButtonsPanel, Panel):
      bl_label = "Volume"
      bl_context = "world"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          world = context.world
          return world and world.node_tree and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
  
          layout.use_property_split = True
  
          world = context.world
          panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Volume')
  
  
  class CYCLES_WORLD_PT_ambient_occlusion(CyclesButtonsPanel, Panel):
      bl_label = "Ambient Occlusion"
      bl_context = "world"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          return context.world and CyclesButtonsPanel.poll(context)
  
      def draw_header(self, context):
          light = context.world.light_settings
          self.layout.prop(light, "use_ambient_occlusion", text="")
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          light = context.world.light_settings
          scene = context.scene
  
          col = layout.column()
          sub = col.column()
          sub.active = light.use_ambient_occlusion or scene.render.use_simplify
          sub.prop(light, "ao_factor", text="Factor")
          col.prop(light, "distance", text="Distance")
  
  
  class CYCLES_WORLD_PT_mist(CyclesButtonsPanel, Panel):
      bl_label = "Mist Pass"
      bl_context = "world"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          if CyclesButtonsPanel.poll(context):
              if context.world:
                  for view_layer in context.scene.view_layers:
                      if view_layer.use_pass_mist:
                          return True
  
          return False
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
  
          world = context.world
  
          col = layout.column(align=True)
          col.prop(world.mist_settings, "start")
          col.prop(world.mist_settings, "depth")
  
          col = layout.column()
          col.prop(world.mist_settings, "falloff")
  
  
  class CYCLES_WORLD_PT_ray_visibility(CyclesButtonsPanel, Panel):
      bl_label = "Ray Visibility"
      bl_context = "world"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          return CyclesButtonsPanel.poll(context) and context.world
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          world = context.world
          visibility = world.cycles_visibility
  
          col = layout.column()
          col.prop(visibility, "camera")
          col.prop(visibility, "diffuse")
          col.prop(visibility, "glossy")
          col.prop(visibility, "transmission")
          col.prop(visibility, "scatter")
  
  
  class CYCLES_WORLD_PT_settings(CyclesButtonsPanel, Panel):
      bl_label = "Settings"
      bl_context = "world"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          return context.world and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          layout.column()
  
  
  class CYCLES_WORLD_PT_settings_surface(CyclesButtonsPanel, Panel):
      bl_label = "Surface"
      bl_parent_id = "CYCLES_WORLD_PT_settings"
      bl_context = "world"
  
      @classmethod
      def poll(cls, context):
          return context.world and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          world = context.world
          cworld = world.cycles
  
          col = layout.column()
          col.prop(cworld, "sampling_method", text="Sampling")
  
          sub = col.column()
          sub.active = cworld.sampling_method != 'NONE'
          subsub = sub.row(align=True)
          subsub.active = cworld.sampling_method == 'MANUAL'
          subsub.prop(cworld, "sample_map_resolution")
          if use_branched_path(context):
              subsub = sub.column(align=True)
              subsub.active = use_sample_all_lights(context)
              subsub.prop(cworld, "samples")
          sub.prop(cworld, "max_bounces")
  
  
  class CYCLES_WORLD_PT_settings_volume(CyclesButtonsPanel, Panel):
      bl_label = "Volume"
      bl_parent_id = "CYCLES_WORLD_PT_settings"
      bl_context = "world"
  
      @classmethod
      def poll(cls, context):
          return context.world and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          world = context.world
          cworld = world.cycles
  
          col = layout.column()
  
          sub = col.column()
          sub.active = use_cpu(context)
          sub.prop(cworld, "volume_sampling", text="Sampling")
          col.prop(cworld, "volume_interpolation", text="Interpolation")
          col.prop(cworld, "homogeneous_volume", text="Homogeneous")
          sub = col.column()
          sub.active = not cworld.homogeneous_volume
          sub.prop(cworld, "volume_step_size")
  
  
  class CYCLES_MATERIAL_PT_preview(CyclesButtonsPanel, Panel):
      bl_label = "Preview"
      bl_context = "material"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          mat = context.material
          return mat and (not mat.grease_pencil) and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          self.layout.template_preview(context.material)
  
  
  class CYCLES_MATERIAL_PT_surface(CyclesButtonsPanel, Panel):
      bl_label = "Surface"
      bl_context = "material"
  
      @classmethod
      def poll(cls, context):
          mat = context.material
          return mat and (not mat.grease_pencil) and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
  
          layout.use_property_split = True
  
          mat = context.material
          if not panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Surface'):
              layout.prop(mat, "diffuse_color")
  
  
  class CYCLES_MATERIAL_PT_volume(CyclesButtonsPanel, Panel):
      bl_label = "Volume"
      bl_context = "material"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          mat = context.material
          return mat and (not mat.grease_pencil) and mat.node_tree and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
  
          layout.use_property_split = True
  
          mat = context.material
          # cmat = mat.cycles
  
          panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Volume')
  
  
  class CYCLES_MATERIAL_PT_displacement(CyclesButtonsPanel, Panel):
      bl_label = "Displacement"
      bl_context = "material"
  
      @classmethod
      def poll(cls, context):
          mat = context.material
          return mat and (not mat.grease_pencil) and mat.node_tree and CyclesButtonsPanel.poll(context)
  
      def draw(self, context):
          layout = self.layout
  
          layout.use_property_split = True
  
          mat = context.material
          panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Displacement')
  
  
  class CYCLES_MATERIAL_PT_settings(CyclesButtonsPanel, Panel):
      bl_label = "Settings"
      bl_context = "material"
      bl_options = {'DEFAULT_CLOSED'}
  
      @classmethod
      def poll(cls, context):
          mat = context.material
          return mat and (not mat.grease_pencil) and CyclesButtonsPanel.poll(context)
  
      @staticmethod
      def draw_shared(self, mat):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          layout.prop(mat, "pass_index")
  
      def draw(self, context):
          self.draw_shared(self, context.material)
  
  
  class CYCLES_MATERIAL_PT_settings_surface(CyclesButtonsPanel, Panel):
      bl_label = "Surface"
      bl_parent_id = "CYCLES_MATERIAL_PT_settings"
      bl_context = "material"
  
      @staticmethod
      def draw_shared(self, mat):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          cmat = mat.cycles
  
          col = layout.column()
          col.prop(cmat, "sample_as_light", text="Multiple Importance")
          col.prop(cmat, "use_transparent_shadow")
          col.prop(cmat, "displacement_method", text="Displacement")
  
      def draw(self, context):
          self.draw_shared(self, context.material)
  
  
  class CYCLES_MATERIAL_PT_settings_volume(CyclesButtonsPanel, Panel):
      bl_label = "Volume"
      bl_parent_id = "CYCLES_MATERIAL_PT_settings"
      bl_context = "material"
  
      @staticmethod
      def draw_shared(self, context, mat):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          cmat = mat.cycles
  
          col = layout.column()
          sub = col.column()
          sub.active = use_cpu(context)
          sub.prop(cmat, "volume_sampling", text="Sampling")
          col.prop(cmat, "volume_interpolation", text="Interpolation")
          col.prop(cmat, "homogeneous_volume", text="Homogeneous")
          sub = col.column()
          sub.active = not cmat.homogeneous_volume
          sub.prop(cmat, "volume_step_rate")
  
      def draw(self, context):
          self.draw_shared(self, context, context.material)
  
  
  class CYCLES_RENDER_PT_bake(CyclesButtonsPanel, Panel):
      bl_label = "Bake"
      bl_context = "render"
      bl_options = {'DEFAULT_CLOSED'}
      COMPAT_ENGINES = {'CYCLES'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False  # No animation.
  
          scene = context.scene
          cscene = scene.cycles
          cbk = scene.render.bake
          rd = scene.render
  
          if use_optix(context):
              layout.label(text="Baking is performed using CUDA instead of OptiX", icon='INFO')
  
          if rd.use_bake_multires:
              layout.operator("object.bake_image", icon='RENDER_STILL')
              layout.prop(rd, "use_bake_multires")
              layout.prop(rd, "bake_type")
  
          else:
              layout.operator("object.bake", icon='RENDER_STILL').type = cscene.bake_type
              layout.prop(rd, "use_bake_multires")
              layout.prop(cscene, "bake_type")
  
  
  class CYCLES_RENDER_PT_bake_influence(CyclesButtonsPanel, Panel):
      bl_label = "Influence"
      bl_context = "render"
      bl_parent_id = "CYCLES_RENDER_PT_bake"
      COMPAT_ENGINES = {'CYCLES'}
  
      @classmethod
      def poll(cls, context):
          scene = context.scene
          cscene = scene.cycles
          rd = scene.render
          if rd.use_bake_multires == False and cscene.bake_type in {
                  'NORMAL', 'COMBINED', 'DIFFUSE', 'GLOSSY', 'TRANSMISSION'}:
              return True
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False  # No animation.
  
          scene = context.scene
          cscene = scene.cycles
          cbk = scene.render.bake
          rd = scene.render
  
          col = layout.column()
  
          if cscene.bake_type == 'NORMAL':
              col.prop(cbk, "normal_space", text="Space")
  
              sub = col.column(align=True)
              sub.prop(cbk, "normal_r", text="Swizzle R")
              sub.prop(cbk, "normal_g", text="G")
              sub.prop(cbk, "normal_b", text="B")
  
          elif cscene.bake_type == 'COMBINED':
  
              col = layout.column(heading="Lighting", align=True)
              col.prop(cbk, "use_pass_direct")
              col.prop(cbk, "use_pass_indirect")
  
              col = layout.column(heading="Contributions", align=True)
              col.active = cbk.use_pass_direct or cbk.use_pass_indirect
              col.prop(cbk, "use_pass_diffuse")
              col.prop(cbk, "use_pass_glossy")
              col.prop(cbk, "use_pass_transmission")
              col.prop(cbk, "use_pass_ambient_occlusion")
              col.prop(cbk, "use_pass_emit")
  
          elif cscene.bake_type in {'DIFFUSE', 'GLOSSY', 'TRANSMISSION'}:
              col = layout.column(heading="Contributions", align=True)
              col.prop(cbk, "use_pass_direct")
              col.prop(cbk, "use_pass_indirect")
              col.prop(cbk, "use_pass_color")
  
  
  class CYCLES_RENDER_PT_bake_selected_to_active(CyclesButtonsPanel, Panel):
      bl_label = "Selected to Active"
      bl_context = "render"
      bl_parent_id = "CYCLES_RENDER_PT_bake"
      bl_options = {'DEFAULT_CLOSED'}
      COMPAT_ENGINES = {'CYCLES'}
  
      @classmethod
      def poll(cls, context):
          scene = context.scene
          rd = scene.render
          return rd.use_bake_multires == False
  
      def draw_header(self, context):
          scene = context.scene
          cbk = scene.render.bake
          self.layout.prop(cbk, "use_selected_to_active", text="")
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False  # No animation.
  
          scene = context.scene
          cscene = scene.cycles
          cbk = scene.render.bake
          rd = scene.render
  
          layout.active = cbk.use_selected_to_active
          col = layout.column()
  
          col.prop(cbk, "use_cage", text="Cage")
          if cbk.use_cage:
              col.prop(cbk, "cage_object")
              col = layout.column()
              col.prop(cbk, "cage_extrusion")
              col.active = cbk.cage_object is None
          else:
              col.prop(cbk, "cage_extrusion", text="Extrusion")
  
          col = layout.column()
          col.prop(cbk, "max_ray_distance")
  
  
  class CYCLES_RENDER_PT_bake_output(CyclesButtonsPanel, Panel):
      bl_label = "Output"
      bl_context = "render"
      bl_parent_id = "CYCLES_RENDER_PT_bake"
      COMPAT_ENGINES = {'CYCLES'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False  # No animation.
  
          scene = context.scene
          cscene = scene.cycles
          cbk = scene.render.bake
          rd = scene.render
  
          if rd.use_bake_multires:
              layout.prop(rd, "bake_margin")
              layout.prop(rd, "use_bake_clear", text="Clear Image")
  
              if rd.bake_type == 'DISPLACEMENT':
                  layout.prop(rd, "use_bake_lores_mesh")
          else:
              layout.prop(cbk, "target")
  
              if cbk.target == 'IMAGE_TEXTURES':
                  layout.prop(cbk, "margin")
                  layout.prop(cbk, "use_clear", text="Clear Image")
  
  
  class CYCLES_RENDER_PT_debug(CyclesButtonsPanel, Panel):
      bl_label = "Debug"
      bl_context = "render"
      bl_options = {'DEFAULT_CLOSED'}
      COMPAT_ENGINES = {'CYCLES'}
  
      @classmethod
      def poll(cls, context):
          prefs = bpy.context.preferences
          return (CyclesButtonsPanel.poll(context)
                  and prefs.experimental.use_cycles_debug
                  and prefs.view.show_developer_ui)
  
      def draw(self, context):
          layout = self.layout
  
          scene = context.scene
          cscene = scene.cycles
  
          col = layout.column()
  
          col.label(text="CPU Flags:")
          row = col.row(align=True)
          row.prop(cscene, "debug_use_cpu_sse2", toggle=True)
          row.prop(cscene, "debug_use_cpu_sse3", toggle=True)
          row.prop(cscene, "debug_use_cpu_sse41", toggle=True)
          row.prop(cscene, "debug_use_cpu_avx", toggle=True)
          row.prop(cscene, "debug_use_cpu_avx2", toggle=True)
          col.prop(cscene, "debug_bvh_layout")
          col.prop(cscene, "debug_use_cpu_split_kernel")
  
          col.separator()
  
          col = layout.column()
          col.label(text="CUDA Flags:")
          col.prop(cscene, "debug_use_cuda_adaptive_compile")
          col.prop(cscene, "debug_use_cuda_split_kernel")
  
          col.separator()
  
          col = layout.column()
          col.label(text="OptiX Flags:")
          col.prop(cscene, "debug_optix_cuda_streams")
          col.prop(cscene, "debug_optix_curves_api")
  
          col.separator()
  
          col = layout.column()
          col.label(text="OpenCL Flags:")
          col.prop(cscene, "debug_opencl_device_type", text="Device")
          col.prop(cscene, "debug_use_opencl_debug", text="Debug")
          col.prop(cscene, "debug_opencl_mem_limit")
  
          col.separator()
  
          col = layout.column()
          col.prop(cscene, "debug_bvh_type")
  
  
  class CYCLES_RENDER_PT_simplify(CyclesButtonsPanel, Panel):
      bl_label = "Simplify"
      bl_context = "render"
      bl_options = {'DEFAULT_CLOSED'}
      COMPAT_ENGINES = {'CYCLES'}
  
      def draw_header(self, context):
          rd = context.scene.render
          self.layout.prop(rd, "use_simplify", text="")
  
      def draw(self, context):
          pass
  
  
  class CYCLES_RENDER_PT_simplify_viewport(CyclesButtonsPanel, Panel):
      bl_label = "Viewport"
      bl_context = "render"
      bl_parent_id = "CYCLES_RENDER_PT_simplify"
      COMPAT_ENGINES = {'CYCLES'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
          cscene = scene.cycles
  
          layout.active = rd.use_simplify
  
          col = layout.column()
          col.prop(rd, "simplify_subdivision", text="Max Subdivision")
          col.prop(rd, "simplify_child_particles", text="Child Particles")
          col.prop(cscene, "texture_limit", text="Texture Limit")
          col.prop(cscene, "ao_bounces", text="AO Bounces")
          col.prop(rd, "simplify_volumes", text="Volume Resolution")
  
  
  class CYCLES_RENDER_PT_simplify_render(CyclesButtonsPanel, Panel):
      bl_label = "Render"
      bl_context = "render"
      bl_parent_id = "CYCLES_RENDER_PT_simplify"
      COMPAT_ENGINES = {'CYCLES'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
          cscene = scene.cycles
  
          layout.active = rd.use_simplify
  
          col = layout.column()
  
          col.prop(rd, "simplify_subdivision_render", text="Max Subdivision")
          col.prop(rd, "simplify_child_particles_render", text="Child Particles")
          col.prop(cscene, "texture_limit_render", text="Texture Limit")
          col.prop(cscene, "ao_bounces_render", text="AO Bounces")
  
  
  class CYCLES_RENDER_PT_simplify_culling(CyclesButtonsPanel, Panel):
      bl_label = "Culling"
      bl_context = "render"
      bl_parent_id = "CYCLES_RENDER_PT_simplify"
      bl_options = {'DEFAULT_CLOSED'}
      COMPAT_ENGINES = {'CYCLES'}
  
      def draw(self, context):
          layout = self.layout
          layout.use_property_split = True
          layout.use_property_decorate = False
  
          scene = context.scene
          rd = scene.render
          cscene = scene.cycles
  
          layout.active = rd.use_simplify
  
          row = layout.row(heading="Camera Culling")
          row.prop(cscene, "use_camera_cull", text="")
          sub = row.column()
          sub.active = cscene.use_camera_cull
          sub.prop(cscene, "camera_cull_margin", text="")
  
          row = layout.row(heading="Distance Culling")
          row.prop(cscene, "use_distance_cull", text="")
          sub = row.column()
          sub.active = cscene.use_distance_cull
          sub.prop(cscene, "distance_cull_margin", text="")
  
  
  class CYCLES_VIEW3D_PT_shading_render_pass(Panel):
      bl_space_type = 'VIEW_3D'
      bl_region_type = 'HEADER'
      bl_label = "Render Pass"
      bl_parent_id = 'VIEW3D_PT_shading'
      COMPAT_ENGINES = {'CYCLES'}
  
      @classmethod
      def poll(cls, context):
          return (
              context.engine in cls.COMPAT_ENGINES and
              context.space_data.shading.type == 'RENDERED'
          )
  
      def draw(self, context):
          shading = context.space_data.shading
  
          layout = self.layout
          layout.prop(shading.cycles, "render_pass", text="")
  
  
  class CYCLES_VIEW3D_PT_shading_lighting(Panel):
      bl_space_type = 'VIEW_3D'
      bl_region_type = 'HEADER'
      bl_label = "Lighting"
      bl_parent_id = 'VIEW3D_PT_shading'
      COMPAT_ENGINES = {'CYCLES'}
  
      @classmethod
      def poll(cls, context):
          return (
              context.engine in cls.COMPAT_ENGINES and
              context.space_data.shading.type == 'RENDERED'
          )
  
      def draw(self, context):
          layout = self.layout
          col = layout.column()
          split = col.split(factor=0.9)
  
          shading = context.space_data.shading
          col.prop(shading, "use_scene_lights_render")
          col.prop(shading, "use_scene_world_render")
  
          if not shading.use_scene_world_render:
              col = layout.column()
              split = col.split(factor=0.9)
  
              col = split.column()
              sub = col.row()
              sub.scale_y = 0.6
              sub.template_icon_view(shading, "studio_light", scale_popup=3)
  
              col = split.column()
              col.operator("preferences.studiolight_show", emboss=False, text="", icon='PREFERENCES')
  
              split = layout.split(factor=0.9)
              col = split.column()
              col.prop(shading, "studiolight_rotate_z", text="Rotation")
              col.prop(shading, "studiolight_intensity")
              col.prop(shading, "studiolight_background_alpha")
  
  
  class CYCLES_VIEW3D_PT_simplify_greasepencil(CyclesButtonsPanel, Panel, GreasePencilSimplifyPanel):
      bl_label = "Grease Pencil"
      bl_parent_id = "CYCLES_RENDER_PT_simplify"
      COMPAT_ENGINES = {'CYCLES'}
      bl_options = {'DEFAULT_CLOSED'}
  
  
  def draw_device(self, context):
      scene = context.scene
      layout = self.layout
      layout.use_property_split = True
      layout.use_property_decorate = False
  
      if context.engine == 'CYCLES':
          from . import engine
          cscene = scene.cycles
  
          col = layout.column()
          col.prop(cscene, "feature_set")
  
          col = layout.column()
          col.active = show_device_active(context)
          col.prop(cscene, "device")
  
          from . import engine
          if engine.with_osl() and use_cpu(context):
              col.prop(cscene, "shading_system")
  
  
  def draw_pause(self, context):
      layout = self.layout
      scene = context.scene
  
      if context.engine == "CYCLES":
          view = context.space_data
  
          if view.shading.type == 'RENDERED':
              cscene = scene.cycles
              layout.prop(cscene, "preview_pause", icon='PLAY' if cscene.preview_pause else 'PAUSE', text="")
  
  
  def get_panels():
      exclude_panels = {
          'DATA_PT_area',
          'DATA_PT_camera_dof',
          'DATA_PT_falloff_curve',
          'DATA_PT_light',
          'DATA_PT_preview',
          'DATA_PT_spot',
          'MATERIAL_PT_context_material',
          'MATERIAL_PT_preview',
          'NODE_DATA_PT_light',
          'NODE_DATA_PT_spot',
          'OBJECT_PT_visibility',
          'VIEWLAYER_PT_filter',
          'VIEWLAYER_PT_layer_passes',
          'RENDER_PT_post_processing',
          'RENDER_PT_simplify',
      }
  
      panels = []
      for panel in bpy.types.Panel.__subclasses__():
          if hasattr(panel, 'COMPAT_ENGINES') and 'BLENDER_RENDER' in panel.COMPAT_ENGINES:
              if panel.__name__ not in exclude_panels:
                  panels.append(panel)
  
      return panels
  
  
  classes = (
      CYCLES_PT_sampling_presets,
      CYCLES_PT_integrator_presets,
      CYCLES_RENDER_PT_sampling,
      CYCLES_RENDER_PT_sampling_sub_samples,
      CYCLES_RENDER_PT_sampling_adaptive,
      CYCLES_RENDER_PT_sampling_denoising,
      CYCLES_RENDER_PT_sampling_advanced,
      CYCLES_RENDER_PT_light_paths,
      CYCLES_RENDER_PT_light_paths_max_bounces,
      CYCLES_RENDER_PT_light_paths_clamping,
      CYCLES_RENDER_PT_light_paths_caustics,
      CYCLES_RENDER_PT_volumes,
      CYCLES_RENDER_PT_subdivision,
      CYCLES_RENDER_PT_hair,
      CYCLES_RENDER_PT_simplify,
      CYCLES_RENDER_PT_simplify_viewport,
      CYCLES_RENDER_PT_simplify_render,
      CYCLES_RENDER_PT_simplify_culling,
      CYCLES_VIEW3D_PT_simplify_greasepencil,
      CYCLES_VIEW3D_PT_shading_lighting,
      CYCLES_VIEW3D_PT_shading_render_pass,
      CYCLES_RENDER_PT_motion_blur,
      CYCLES_RENDER_PT_motion_blur_curve,
      CYCLES_RENDER_PT_film,
      CYCLES_RENDER_PT_film_pixel_filter,
      CYCLES_RENDER_PT_film_transparency,
      CYCLES_RENDER_PT_performance,
      CYCLES_RENDER_PT_performance_threads,
      CYCLES_RENDER_PT_performance_tiles,
      CYCLES_RENDER_PT_performance_acceleration_structure,
      CYCLES_RENDER_PT_performance_final_render,
      CYCLES_RENDER_PT_performance_viewport,
      CYCLES_RENDER_PT_passes,
      CYCLES_RENDER_PT_passes_data,
      CYCLES_RENDER_PT_passes_light,
      CYCLES_RENDER_PT_passes_crypto,
      CYCLES_RENDER_PT_passes_debug,
      CYCLES_RENDER_UL_aov,
      CYCLES_RENDER_PT_passes_aov,
      CYCLES_RENDER_PT_filter,
      CYCLES_RENDER_PT_override,
      CYCLES_RENDER_PT_denoising,
      CYCLES_PT_post_processing,
      CYCLES_CAMERA_PT_dof,
      CYCLES_CAMERA_PT_dof_aperture,
      CYCLES_PT_context_material,
      CYCLES_OBJECT_PT_motion_blur,
      CYCLES_OBJECT_PT_shading,
      CYCLES_OBJECT_PT_visibility,
      CYCLES_OBJECT_PT_visibility_ray_visibility,
      CYCLES_OBJECT_PT_visibility_culling,
      CYCLES_LIGHT_PT_preview,
      CYCLES_LIGHT_PT_light,
      CYCLES_LIGHT_PT_nodes,
      CYCLES_LIGHT_PT_spot,
      CYCLES_WORLD_PT_preview,
      CYCLES_WORLD_PT_surface,
      CYCLES_WORLD_PT_volume,
      CYCLES_WORLD_PT_ambient_occlusion,
      CYCLES_WORLD_PT_mist,
      CYCLES_WORLD_PT_ray_visibility,
      CYCLES_WORLD_PT_settings,
      CYCLES_WORLD_PT_settings_surface,
      CYCLES_WORLD_PT_settings_volume,
      CYCLES_MATERIAL_PT_preview,
      CYCLES_MATERIAL_PT_surface,
      CYCLES_MATERIAL_PT_volume,
      CYCLES_MATERIAL_PT_displacement,
      CYCLES_MATERIAL_PT_settings,
      CYCLES_MATERIAL_PT_settings_surface,
      CYCLES_MATERIAL_PT_settings_volume,
      CYCLES_RENDER_PT_bake,
      CYCLES_RENDER_PT_bake_influence,
      CYCLES_RENDER_PT_bake_selected_to_active,
      CYCLES_RENDER_PT_bake_output,
      CYCLES_RENDER_PT_debug,
      node_panel(CYCLES_MATERIAL_PT_settings),
      node_panel(CYCLES_MATERIAL_PT_settings_surface),
      node_panel(CYCLES_MATERIAL_PT_settings_volume),
      node_panel(CYCLES_WORLD_PT_ray_visibility),
      node_panel(CYCLES_WORLD_PT_settings),
      node_panel(CYCLES_WORLD_PT_settings_surface),
      node_panel(CYCLES_WORLD_PT_settings_volume),
      node_panel(CYCLES_LIGHT_PT_light),
      node_panel(CYCLES_LIGHT_PT_spot),
  )
  
  
  def register():
      from bpy.utils import register_class
  
      bpy.types.RENDER_PT_context.append(draw_device)
      bpy.types.VIEW3D_HT_header.append(draw_pause)
  
      for panel in get_panels():
          panel.COMPAT_ENGINES.add('CYCLES')
  
      for cls in classes:
          register_class(cls)
  
  
  def unregister():
      from bpy.utils import unregister_class
  
      bpy.types.RENDER_PT_context.remove(draw_device)
      bpy.types.VIEW3D_HT_header.remove(draw_pause)
  
      for panel in get_panels():
          if 'CYCLES' in panel.COMPAT_ENGINES:
              panel.COMPAT_ENGINES.remove('CYCLES')
  
      for cls in classes:
          unregister_class(cls)
  