Merge branch 'blender2.7'
[blender.git] / intern / cycles / blender / addon / properties.py
index 23ab1cf..c60db9f 100644 (file)
 # <pep8 compliant>
 
 import bpy
-from bpy.props import (BoolProperty,
-                       EnumProperty,
-                       FloatProperty,
-                       IntProperty,
-                       PointerProperty,
-                       StringProperty)
+from bpy.props import (
+    BoolProperty,
+    EnumProperty,
+    FloatProperty,
+    IntProperty,
+    PointerProperty,
+    StringProperty,
+)
+
+from math import pi
 
 # enums
 
@@ -154,586 +158,591 @@ enum_texture_limit = (
 
 
 class CyclesRenderSettings(bpy.types.PropertyGroup):
-    @classmethod
-    def register(cls):
-        bpy.types.Scene.cycles = PointerProperty(
-            name="Cycles Render Settings",
-            description="Cycles render settings",
-            type=cls,
-        )
-        cls.device = EnumProperty(
-            name="Device",
-            description="Device to use for rendering",
-            items=enum_devices,
-            default='CPU',
-        )
-        cls.feature_set = EnumProperty(
-            name="Feature Set",
-            description="Feature set to use for rendering",
-            items=enum_feature_set,
-            default='SUPPORTED',
-        )
-        cls.shading_system = BoolProperty(
-            name="Open Shading Language",
-            description="Use Open Shading Language (CPU rendering only)",
-        )
 
-        cls.progressive = EnumProperty(
-            name="Integrator",
-            description="Method to sample lights and materials",
-            items=enum_integrator,
-            default='PATH',
-        )
+    device: EnumProperty(
+        name="Device",
+        description="Device to use for rendering",
+        items=enum_devices,
+        default='CPU',
+    )
+    feature_set: EnumProperty(
+        name="Feature Set",
+        description="Feature set to use for rendering",
+        items=enum_feature_set,
+        default='SUPPORTED',
+    )
+    shading_system: BoolProperty(
+        name="Open Shading Language",
+        description="Use Open Shading Language (CPU rendering only)",
+    )
 
-        cls.use_square_samples = BoolProperty(
-            name="Square Samples",
-            description="Square sampling values for easier artist control",
-            default=False,
-        )
+    progressive: EnumProperty(
+        name="Integrator",
+        description="Method to sample lights and materials",
+        items=enum_integrator,
+        default='PATH',
+    )
 
-        cls.samples = IntProperty(
-            name="Samples",
-            description="Number of samples to render for each pixel",
-            min=1, max=2147483647,
-            default=128,
-        )
-        cls.preview_samples = IntProperty(
-            name="Preview Samples",
-            description="Number of samples to render in the viewport, unlimited if 0",
-            min=0, max=2147483647,
-            default=32,
-        )
-        cls.preview_pause = BoolProperty(
-            name="Pause Preview",
-            description="Pause all viewport preview renders",
-            default=False,
-        )
-        cls.preview_active_layer = BoolProperty(
-            name="Preview Active Layer",
-            description="Preview active render layer in viewport",
-            default=False,
-        )
+    use_square_samples: BoolProperty(
+        name="Square Samples",
+        description="Square sampling values for easier artist control",
+        default=False,
+    )
 
-        cls.aa_samples = IntProperty(
-            name="AA Samples",
-            description="Number of antialiasing samples to render for each pixel",
-            min=1, max=2097151,
-            default=128,
-        )
-        cls.preview_aa_samples = IntProperty(
-            name="AA Samples",
-            description="Number of antialiasing samples to render in the viewport, unlimited if 0",
-            min=0, max=2097151,
-            default=32,
-        )
-        cls.diffuse_samples = IntProperty(
-            name="Diffuse Samples",
-            description="Number of diffuse bounce samples to render for each AA sample",
-            min=1, max=1024,
-            default=1,
-        )
-        cls.glossy_samples = IntProperty(
-            name="Glossy Samples",
-            description="Number of glossy bounce samples to render for each AA sample",
-            min=1, max=1024,
-            default=1,
-        )
-        cls.transmission_samples = IntProperty(
-            name="Transmission Samples",
-            description="Number of transmission bounce samples to render for each AA sample",
-            min=1, max=1024,
-            default=1,
-        )
-        cls.ao_samples = IntProperty(
-            name="Ambient Occlusion Samples",
-            description="Number of ambient occlusion samples to render for each AA sample",
-            min=1, max=1024,
-            default=1,
-        )
-        cls.mesh_light_samples = IntProperty(
-            name="Mesh Light Samples",
-            description="Number of mesh emission light samples to render for each AA sample",
-            min=1, max=1024,
-            default=1,
-        )
+    samples: IntProperty(
+        name="Samples",
+        description="Number of samples to render for each pixel",
+        min=1, max=2147483647,
+        default=128,
+    )
+    preview_samples: IntProperty(
+        name="Preview Samples",
+        description="Number of samples to render in the viewport, unlimited if 0",
+        min=0, max=2147483647,
+        default=32,
+    )
+    preview_pause: BoolProperty(
+        name="Pause Preview",
+        description="Pause all viewport preview renders",
+        default=False,
+    )
+    aa_samples: IntProperty(
+        name="AA Samples",
+        description="Number of antialiasing samples to render for each pixel",
+        min=1, max=2097151,
+        default=128,
+    )
+    preview_aa_samples: IntProperty(
+        name="AA Samples",
+        description="Number of antialiasing samples to render in the viewport, unlimited if 0",
+        min=0, max=2097151,
+        default=32,
+    )
+    diffuse_samples: IntProperty(
+        name="Diffuse Samples",
+        description="Number of diffuse bounce samples to render for each AA sample",
+        min=1, max=1024,
+        default=1,
+    )
+    glossy_samples: IntProperty(
+        name="Glossy Samples",
+        description="Number of glossy bounce samples to render for each AA sample",
+        min=1, max=1024,
+        default=1,
+    )
+    transmission_samples: IntProperty(
+        name="Transmission Samples",
+        description="Number of transmission bounce samples to render for each AA sample",
+        min=1, max=1024,
+        default=1,
+    )
+    ao_samples: IntProperty(
+        name="Ambient Occlusion Samples",
+        description="Number of ambient occlusion samples to render for each AA sample",
+        min=1, max=1024,
+        default=1,
+    )
+    mesh_light_samples: IntProperty(
+        name="Mesh Light Samples",
+        description="Number of mesh emission light samples to render for each AA sample",
+        min=1, max=1024,
+        default=1,
+    )
 
-        cls.subsurface_samples = IntProperty(
-            name="Subsurface Samples",
-            description="Number of subsurface scattering samples to render for each AA sample",
-            min=1, max=1024,
-            default=1,
-        )
+    subsurface_samples: IntProperty(
+        name="Subsurface Samples",
+        description="Number of subsurface scattering samples to render for each AA sample",
+        min=1, max=1024,
+        default=1,
+    )
 
-        cls.volume_samples = IntProperty(
-            name="Volume Samples",
-            description="Number of volume scattering samples to render for each AA sample",
-            min=1, max=1024,
-            default=1,
-        )
+    volume_samples: IntProperty(
+        name="Volume Samples",
+        description="Number of volume scattering samples to render for each AA sample",
+        min=1, max=1024,
+        default=1,
+    )
 
-        cls.sampling_pattern = EnumProperty(
-            name="Sampling Pattern",
-            description="Random sampling pattern used by the integrator",
-            items=enum_sampling_pattern,
-            default='SOBOL',
-        )
+    sampling_pattern: EnumProperty(
+        name="Sampling Pattern",
+        description="Random sampling pattern used by the integrator",
+        items=enum_sampling_pattern,
+        default='SOBOL',
+    )
 
-        cls.use_layer_samples = EnumProperty(
-            name="Layer Samples",
-            description="How to use per render layer sample settings",
-            items=enum_use_layer_samples,
-            default='USE',
-        )
+    use_layer_samples: EnumProperty(
+        name="Layer Samples",
+        description="How to use per view layer sample settings",
+        items=enum_use_layer_samples,
+        default='USE',
+    )
 
-        cls.sample_all_lights_direct = BoolProperty(
-            name="Sample All Direct Lights",
-            description="Sample all lights (for direct samples), rather than randomly picking one",
-            default=True,
-        )
+    sample_all_lights_direct: BoolProperty(
+        name="Sample All Direct Lights",
+        description="Sample all lights (for direct samples), rather than randomly picking one",
+        default=True,
+    )
 
-        cls.sample_all_lights_indirect = BoolProperty(
-            name="Sample All Indirect Lights",
-            description="Sample all lights (for indirect samples), rather than randomly picking one",
-            default=True,
-        )
-        cls.light_sampling_threshold = FloatProperty(
-            name="Light Sampling Threshold",
-            description="Probabilistically terminate light samples when the light contribution is below this threshold (more noise but faster rendering). "
-            "Zero disables the test and never ignores lights",
-            min=0.0, max=1.0,
-            default=0.01,
-        )
+    sample_all_lights_indirect: BoolProperty(
+        name="Sample All Indirect Lights",
+        description="Sample all lights (for indirect samples), rather than randomly picking one",
+        default=True,
+    )
+    light_sampling_threshold: FloatProperty(
+        name="Light Sampling Threshold",
+        description="Probabilistically terminate light samples when the light contribution is below this threshold (more noise but faster rendering). "
+        "Zero disables the test and never ignores lights",
+        min=0.0, max=1.0,
+        default=0.01,
+    )
 
-        cls.caustics_reflective = BoolProperty(
-            name="Reflective Caustics",
-            description="Use reflective caustics, resulting in a brighter image (more noise but added realism)",
-            default=True,
-        )
+    caustics_reflective: BoolProperty(
+        name="Reflective Caustics",
+        description="Use reflective caustics, resulting in a brighter image (more noise but added realism)",
+        default=True,
+    )
 
-        cls.caustics_refractive = BoolProperty(
-            name="Refractive Caustics",
-            description="Use refractive caustics, resulting in a brighter image (more noise but added realism)",
-            default=True,
-        )
+    caustics_refractive: BoolProperty(
+        name="Refractive Caustics",
+        description="Use refractive caustics, resulting in a brighter image (more noise but added realism)",
+        default=True,
+    )
 
-        cls.blur_glossy = FloatProperty(
-            name="Filter Glossy",
-            description="Adaptively blur glossy shaders after blurry bounces, "
-            "to reduce noise at the cost of accuracy",
-            min=0.0, max=10.0,
-            default=1.0,
-        )
+    blur_glossy: FloatProperty(
+        name="Filter Glossy",
+        description="Adaptively blur glossy shaders after blurry bounces, "
+        "to reduce noise at the cost of accuracy",
+        min=0.0, max=10.0,
+        default=1.0,
+    )
 
-        cls.max_bounces = IntProperty(
-            name="Max Bounces",
-            description="Total maximum number of bounces",
-            min=0, max=1024,
-            default=12,
-        )
+    max_bounces: IntProperty(
+        name="Max Bounces",
+        description="Total maximum number of bounces",
+        min=0, max=1024,
+        default=12,
+    )
 
-        cls.diffuse_bounces = IntProperty(
-            name="Diffuse Bounces",
-            description="Maximum number of diffuse reflection bounces, bounded by total maximum",
-            min=0, max=1024,
-            default=4,
-        )
-        cls.glossy_bounces = IntProperty(
-            name="Glossy Bounces",
-            description="Maximum number of glossy reflection bounces, bounded by total maximum",
-            min=0, max=1024,
-            default=4,
-        )
-        cls.transmission_bounces = IntProperty(
-            name="Transmission Bounces",
-            description="Maximum number of transmission bounces, bounded by total maximum",
-            min=0, max=1024,
-            default=12,
-        )
-        cls.volume_bounces = IntProperty(
-            name="Volume Bounces",
-            description="Maximum number of volumetric scattering events",
-            min=0, max=1024,
-            default=0,
-        )
+    diffuse_bounces: IntProperty(
+        name="Diffuse Bounces",
+        description="Maximum number of diffuse reflection bounces, bounded by total maximum",
+        min=0, max=1024,
+        default=4,
+    )
+    glossy_bounces: IntProperty(
+        name="Glossy Bounces",
+        description="Maximum number of glossy reflection bounces, bounded by total maximum",
+        min=0, max=1024,
+        default=4,
+    )
+    transmission_bounces: IntProperty(
+        name="Transmission Bounces",
+        description="Maximum number of transmission bounces, bounded by total maximum",
+        min=0, max=1024,
+        default=12,
+    )
+    volume_bounces: IntProperty(
+        name="Volume Bounces",
+        description="Maximum number of volumetric scattering events",
+        min=0, max=1024,
+        default=0,
+    )
 
-        cls.transparent_max_bounces = IntProperty(
-            name="Transparent Max Bounces",
-            description="Maximum number of transparent bounces",
-            min=0, max=1024,
-            default=8,
-        )
+    transparent_max_bounces: IntProperty(
+        name="Transparent Max Bounces",
+        description="Maximum number of transparent bounces",
+        min=0, max=1024,
+        default=8,
+    )
 
-        cls.volume_step_size = FloatProperty(
-            name="Step Size",
-            description="Distance between volume shader samples when rendering the volume "
-            "(lower values give more accurate and detailed results, but also increased render time)",
-            default=0.1,
-            min=0.0000001, max=100000.0, soft_min=0.01, soft_max=1.0, precision=4
-        )
+    volume_step_size: FloatProperty(
+        name="Step Size",
+        description="Distance between volume shader samples when rendering the volume "
+        "(lower values give more accurate and detailed results, but also increased render time)",
+        default=0.1,
+        min=0.0000001, max=100000.0, soft_min=0.01, soft_max=1.0, precision=4,
+        unit='LENGTH'
+    )
 
-        cls.volume_max_steps = IntProperty(
-            name="Max Steps",
-            description="Maximum number of steps through the volume before giving up, "
-            "to avoid extremely long render times with big objects or small step sizes",
-            default=1024,
-            min=2, max=65536
-        )
+    volume_max_steps: IntProperty(
+        name="Max Steps",
+        description="Maximum number of steps through the volume before giving up, "
+        "to avoid extremely long render times with big objects or small step sizes",
+        default=1024,
+        min=2, max=65536
+    )
 
-        cls.dicing_rate = FloatProperty(
-            name="Dicing Rate",
-            description="Size of a micropolygon in pixels",
-            min=0.1, max=1000.0, soft_min=0.5,
-            default=1.0,
-            subtype="PIXEL"
-        )
-        cls.preview_dicing_rate = FloatProperty(
-            name="Preview Dicing Rate",
-            description="Size of a micropolygon in pixels during preview render",
-            min=0.1, max=1000.0, soft_min=0.5,
-            default=8.0,
-            subtype="PIXEL"
-        )
+    dicing_rate: FloatProperty(
+        name="Dicing Rate",
+        description="Size of a micropolygon in pixels",
+        min=0.1, max=1000.0, soft_min=0.5,
+        default=1.0,
+        subtype='PIXEL'
+    )
+    preview_dicing_rate: FloatProperty(
+        name="Preview Dicing Rate",
+        description="Size of a micropolygon in pixels during preview render",
+        min=0.1, max=1000.0, soft_min=0.5,
+        default=8.0,
+        subtype='PIXEL'
+    )
 
-        cls.max_subdivisions = IntProperty(
-            name="Max Subdivisions",
-            description="Stop subdividing when this level is reached even if the dice rate would produce finer tessellation",
-            min=0, max=16,
-            default=12,
-        )
+    max_subdivisions: IntProperty(
+        name="Max Subdivisions",
+        description="Stop subdividing when this level is reached even if the dice rate would produce finer tessellation",
+        min=0, max=16,
+        default=12,
+    )
 
-        cls.dicing_camera = PointerProperty(
-            name="Dicing Camera",
-            description="Camera to use as reference point when subdividing geometry, useful to avoid crawling "
-            "artifacts in animations when the scene camera is moving",
-            type=bpy.types.Object,
-            poll=lambda self, obj: obj.type == 'CAMERA',
-        )
-        cls.offscreen_dicing_scale = FloatProperty(
-            name="Offscreen Dicing Scale",
-            description="Multiplier for dicing rate of geometry outside of the camera view. The dicing rate "
-            "of objects is gradually increased the further they are outside the camera view. "
-            "Lower values provide higher quality reflections and shadows for off screen objects, "
-            "while higher values use less memory",
-            min=1.0, soft_max=25.0,
-            default=4.0,
-        )
+    dicing_camera: PointerProperty(
+        name="Dicing Camera",
+        description="Camera to use as reference point when subdividing geometry, useful to avoid crawling "
+        "artifacts in animations when the scene camera is moving",
+        type=bpy.types.Object,
+        poll=lambda self, obj: obj.type == 'CAMERA',
+    )
+    offscreen_dicing_scale: FloatProperty(
+        name="Offscreen Dicing Scale",
+        description="Multiplier for dicing rate of geometry outside of the camera view. The dicing rate "
+        "of objects is gradually increased the further they are outside the camera view. "
+        "Lower values provide higher quality reflections and shadows for off screen objects, "
+        "while higher values use less memory",
+        min=1.0, soft_max=25.0,
+        default=4.0,
+    )
 
-        cls.film_exposure = FloatProperty(
-            name="Exposure",
-            description="Image brightness scale",
-            min=0.0, max=10.0,
-            default=1.0,
-        )
-        cls.film_transparent = BoolProperty(
-            name="Transparent",
-            description="World background is transparent, for compositing the render over another background",
-            default=False,
-        )
-        cls.film_transparent_glass = BoolProperty(
-            name="Transparent Glass",
-            description="Render transmissive surfaces as transparent, for compositing glass over another background",
-            default=False,
-        )
-        cls.film_transparent_roughness = FloatProperty(
-            name="Transparent Roughness Threshold",
-            description="For transparent transmission, keep surfaces with roughness above the threshold opaque",
-            min=0.0, max=1.0,
-            default=0.1,
-        )
+    film_exposure: FloatProperty(
+        name="Exposure",
+        description="Image brightness scale",
+        min=0.0, max=10.0,
+        default=1.0,
+    )
+    film_transparent: BoolProperty(
+        name="Transparent",
+        description="World background is transparent, for compositing the render over another background",
+        default=False,
+    )
+    film_transparent_glass: BoolProperty(
+        name="Transparent Glass",
+        description="Render transmissive surfaces as transparent, for compositing glass over another background",
+        default=False,
+    )
+    film_transparent_roughness: FloatProperty(
+        name="Transparent Roughness Threshold",
+        description="For transparent transmission, keep surfaces with roughness above the threshold opaque",
+        min=0.0, max=1.0,
+        default=0.1,
+    )
 
-        # Really annoyingly, we have to keep it around for a few releases,
-        # otherwise forward compatibility breaks in really bad manner: CRASH!
-        #
-        # TODO(sergey): Remove this during 2.8x series of Blender.
-        cls.filter_type = EnumProperty(
-            name="Filter Type",
-            description="Pixel filter type",
-            items=enum_filter_types,
-            default='BLACKMAN_HARRIS',
-        )
+    # Really annoyingly, we have to keep it around for a few releases,
+    # otherwise forward compatibility breaks in really bad manner: CRASH!
+    #
+    # TODO(sergey): Remove this during 2.8x series of Blender.
+    filter_type: EnumProperty(
+        name="Filter Type",
+        description="Pixel filter type",
+        items=enum_filter_types,
+        default='BLACKMAN_HARRIS',
+    )
 
-        cls.pixel_filter_type = EnumProperty(
-            name="Filter Type",
-            description="Pixel filter type",
-            items=enum_filter_types,
-            default='BLACKMAN_HARRIS',
-        )
+    pixel_filter_type: EnumProperty(
+        name="Filter Type",
+        description="Pixel filter type",
+        items=enum_filter_types,
+        default='BLACKMAN_HARRIS',
+    )
 
-        cls.filter_width = FloatProperty(
-            name="Filter Width",
-            description="Pixel filter width",
-            min=0.01, max=10.0,
-            default=1.5,
-        )
+    filter_width: FloatProperty(
+        name="Filter Width",
+        description="Pixel filter width",
+        min=0.01, max=10.0,
+        default=1.5,
+        subtype='PIXEL'
+    )
 
-        cls.seed = IntProperty(
-            name="Seed",
-            description="Seed value for integrator to get different noise patterns",
-            min=0, max=2147483647,
-            default=0,
-        )
+    seed: IntProperty(
+        name="Seed",
+        description="Seed value for integrator to get different noise patterns",
+        min=0, max=2147483647,
+        default=0,
+    )
 
-        cls.use_animated_seed = BoolProperty(
-            name="Use Animated Seed",
-            description="Use different seed values (and hence noise patterns) at different frames",
-            default=False,
-        )
+    use_animated_seed: BoolProperty(
+        name="Use Animated Seed",
+        description="Use different seed values (and hence noise patterns) at different frames",
+        default=False,
+    )
 
-        cls.sample_clamp_direct = FloatProperty(
-            name="Clamp Direct",
-            description="If non-zero, the maximum value for a direct sample, "
-            "higher values will be scaled down to avoid too "
-            "much noise and slow convergence at the cost of accuracy",
-            min=0.0, max=1e8,
-            default=0.0,
-        )
+    sample_clamp_direct: FloatProperty(
+        name="Clamp Direct",
+        description="If non-zero, the maximum value for a direct sample, "
+        "higher values will be scaled down to avoid too "
+        "much noise and slow convergence at the cost of accuracy",
+        min=0.0, max=1e8,
+        default=0.0,
+    )
 
-        cls.sample_clamp_indirect = FloatProperty(
-            name="Clamp Indirect",
-            description="If non-zero, the maximum value for an indirect sample, "
-            "higher values will be scaled down to avoid too "
-            "much noise and slow convergence at the cost of accuracy",
-            min=0.0, max=1e8,
-            default=10.0,
-        )
+    sample_clamp_indirect: FloatProperty(
+        name="Clamp Indirect",
+        description="If non-zero, the maximum value for an indirect sample, "
+        "higher values will be scaled down to avoid too "
+        "much noise and slow convergence at the cost of accuracy",
+        min=0.0, max=1e8,
+        default=10.0,
+    )
 
-        cls.debug_tile_size = IntProperty(
-            name="Tile Size",
-            description="",
-            min=1, max=4096,
-            default=1024,
-        )
+    debug_tile_size: IntProperty(
+        name="Tile Size",
+        description="",
+        min=1, max=4096,
+        default=1024,
+    )
 
-        cls.preview_start_resolution = IntProperty(
-            name="Start Resolution",
-            description="Resolution to start rendering preview at, "
-            "progressively increasing it to the full viewport size",
-            min=8, max=16384,
-            default=64,
-        )
+    preview_start_resolution: IntProperty(
+        name="Start Resolution",
+        description="Resolution to start rendering preview at, "
+        "progressively increasing it to the full viewport size",
+        min=8, max=16384,
+        default=64,
+        subtype='PIXEL'
+    )
 
-        cls.debug_reset_timeout = FloatProperty(
-            name="Reset timeout",
-            description="",
-            min=0.01, max=10.0,
-            default=0.1,
-        )
-        cls.debug_cancel_timeout = FloatProperty(
-            name="Cancel timeout",
-            description="",
-            min=0.01, max=10.0,
-            default=0.1,
-        )
-        cls.debug_text_timeout = FloatProperty(
-            name="Text timeout",
-            description="",
-            min=0.01, max=10.0,
-            default=1.0,
-        )
+    debug_reset_timeout: FloatProperty(
+        name="Reset timeout",
+        description="",
+        min=0.01, max=10.0,
+        default=0.1,
+    )
+    debug_cancel_timeout: FloatProperty(
+        name="Cancel timeout",
+        description="",
+        min=0.01, max=10.0,
+        default=0.1,
+    )
+    debug_text_timeout: FloatProperty(
+        name="Text timeout",
+        description="",
+        min=0.01, max=10.0,
+        default=1.0,
+    )
 
-        cls.debug_bvh_type = EnumProperty(
-            name="Viewport BVH Type",
-            description="Choose between faster updates, or faster render",
-            items=enum_bvh_types,
-            default='DYNAMIC_BVH',
-        )
-        cls.debug_use_spatial_splits = BoolProperty(
-            name="Use Spatial Splits",
-            description="Use BVH spatial splits: longer builder time, faster render",
-            default=False,
-        )
-        cls.debug_use_hair_bvh = BoolProperty(
-            name="Use Hair BVH",
-            description="Use special type BVH optimized for hair (uses more ram but renders faster)",
-            default=True,
-        )
-        cls.use_bvh_embree = BoolProperty(
-            name="Use Embree",
-            description="Use Embree as ray accelerator",
-            default=False,
-        )
-        cls.debug_bvh_time_steps = IntProperty(
-            name="BVH Time Steps",
-            description="Split BVH primitives by this number of time steps to speed up render time in cost of memory",
-            default=0,
-            min=0, max=16,
-        )
-        cls.tile_order = EnumProperty(
-            name="Tile Order",
-            description="Tile order for rendering",
-            items=enum_tile_order,
-            default='HILBERT_SPIRAL',
-            options=set(),  # Not animatable!
-        )
-        cls.use_progressive_refine = BoolProperty(
-            name="Progressive Refine",
-            description="Instead of rendering each tile until it is finished, "
-            "refine the whole image progressively "
-            "(this renders somewhat slower, "
-            "but time can be saved by manually stopping the render when the noise is low enough)",
-            default=False,
-        )
+    debug_bvh_type: EnumProperty(
+        name="Viewport BVH Type",
+        description="Choose between faster updates, or faster render",
+        items=enum_bvh_types,
+        default='DYNAMIC_BVH',
+    )
+    use_bvh_embree: BoolProperty(
+        name="Use Embree",
+        description="Use Embree as ray accelerator",
+        default=False,
+    )
+    debug_use_spatial_splits: BoolProperty(
+        name="Use Spatial Splits",
+        description="Use BVH spatial splits: longer builder time, faster render",
+        default=False,
+    )
+    debug_use_hair_bvh: BoolProperty(
+        name="Use Hair BVH",
+        description="Use special type BVH optimized for hair (uses more ram but renders faster)",
+        default=True,
+    )
+    debug_bvh_time_steps: IntProperty(
+        name="BVH Time Steps",
+        description="Split BVH primitives by this number of time steps to speed up render time in cost of memory",
+        default=0,
+        min=0, max=16,
+    )
+    tile_order: EnumProperty(
+        name="Tile Order",
+        description="Tile order for rendering",
+        items=enum_tile_order,
+        default='HILBERT_SPIRAL',
+        options=set(),  # Not animatable!
+    )
+    use_progressive_refine: BoolProperty(
+        name="Progressive Refine",
+        description="Instead of rendering each tile until it is finished, "
+        "refine the whole image progressively "
+        "(this renders somewhat slower, "
+        "but time can be saved by manually stopping the render when the noise is low enough)",
+        default=False,
+    )
 
-        cls.bake_type = EnumProperty(
-            name="Bake Type",
-            default='COMBINED',
-            description="Type of pass to bake",
-            items=(
-                ('COMBINED', "Combined", ""),
-                ('AO', "Ambient Occlusion", ""),
-                ('SHADOW', "Shadow", ""),
-                ('NORMAL', "Normal", ""),
-                ('UV', "UV", ""),
-                ('ROUGHNESS', "Roughness", ""),
-                ('EMIT', "Emit", ""),
-                ('ENVIRONMENT', "Environment", ""),
-                ('DIFFUSE', "Diffuse", ""),
-                ('GLOSSY', "Glossy", ""),
-                ('TRANSMISSION', "Transmission", ""),
-                ('SUBSURFACE', "Subsurface", ""),
-            ),
-        )
+    bake_type: EnumProperty(
+        name="Bake Type",
+        default='COMBINED',
+        description="Type of pass to bake",
+        items=(
+            ('COMBINED', "Combined", ""),
+            ('AO', "Ambient Occlusion", ""),
+            ('SHADOW', "Shadow", ""),
+            ('NORMAL', "Normal", ""),
+            ('UV', "UV", ""),
+            ('ROUGHNESS', "Roughness", ""),
+            ('EMIT', "Emit", ""),
+            ('ENVIRONMENT', "Environment", ""),
+            ('DIFFUSE', "Diffuse", ""),
+            ('GLOSSY', "Glossy", ""),
+            ('TRANSMISSION', "Transmission", ""),
+            ('SUBSURFACE', "Subsurface", ""),
+        ),
+    )
 
-        cls.use_camera_cull = BoolProperty(
-            name="Use Camera Cull",
-            description="Allow objects to be culled based on the camera frustum",
-            default=False,
-        )
+    use_camera_cull: BoolProperty(
+        name="Use Camera Cull",
+        description="Allow objects to be culled based on the camera frustum",
+        default=False,
+    )
 
-        cls.camera_cull_margin = FloatProperty(
-            name="Camera Cull Margin",
-            description="Margin for the camera space culling",
-            default=0.1,
-            min=0.0, max=5.0
-        )
+    camera_cull_margin: FloatProperty(
+        name="Camera Cull Margin",
+        description="Margin for the camera space culling",
+        default=0.1,
+        min=0.0, max=5.0,
+        subtype='FACTOR'
+    )
 
-        cls.use_distance_cull = BoolProperty(
-            name="Use Distance Cull",
-            description="Allow objects to be culled based on the distance from camera",
-            default=False,
-        )
+    use_distance_cull: BoolProperty(
+        name="Use Distance Cull",
+        description="Allow objects to be culled based on the distance from camera",
+        default=False,
+    )
 
-        cls.distance_cull_margin = FloatProperty(
-            name="Cull Distance",
-            description="Cull objects which are further away from camera than this distance",
-            default=50,
-            min=0.0
-        )
+    distance_cull_margin: FloatProperty(
+        name="Cull Distance",
+        description="Cull objects which are further away from camera than this distance",
+        default=50,
+        min=0.0,
+        unit='LENGTH'
+    )
 
-        cls.motion_blur_position = EnumProperty(
-            name="Motion Blur Position",
-            default='CENTER',
-            description="Offset for the shutter's time interval, allows to change the motion blur trails",
-            items=(
-                ('START', "Start on Frame", "The shutter opens at the current frame"),
-                ('CENTER', "Center on Frame", "The shutter is open during the current frame"),
-                ('END', "End on Frame", "The shutter closes at the current frame"),
-            ),
-        )
+    motion_blur_position: EnumProperty(
+        name="Motion Blur Position",
+        default='CENTER',
+        description="Offset for the shutter's time interval, allows to change the motion blur trails",
+        items=(
+            ('START', "Start on Frame", "The shutter opens at the current frame"),
+            ('CENTER', "Center on Frame", "The shutter is open during the current frame"),
+            ('END', "End on Frame", "The shutter closes at the current frame"),
+        ),
+    )
 
-        cls.rolling_shutter_type = EnumProperty(
-            name="Shutter Type",
-            default='NONE',
-            description="Type of rolling shutter effect matching CMOS-based cameras",
-            items=(
-                ('NONE', "None", "No rolling shutter effect used"),
-                ('TOP', "Top-Bottom", "Sensor is being scanned from top to bottom")
-                # TODO(seergey): Are there real cameras with different scanning direction?
-            ),
-        )
+    rolling_shutter_type: EnumProperty(
+        name="Shutter Type",
+        default='NONE',
+        description="Type of rolling shutter effect matching CMOS-based cameras",
+        items=(
+            ('NONE', "None", "No rolling shutter effect used"),
+            ('TOP', "Top-Bottom", "Sensor is being scanned from top to bottom")
+            # TODO(seergey): Are there real cameras with different scanning direction?
+        ),
+    )
 
-        cls.rolling_shutter_duration = FloatProperty(
-            name="Rolling Shutter Duration",
-            description="Scanline \"exposure\" time for the rolling shutter effect",
-            default=0.1,
-            min=0.0, max=1.0,
-        )
+    rolling_shutter_duration: FloatProperty(
+        name="Rolling Shutter Duration",
+        description="Scanline \"exposure\" time for the rolling shutter effect",
+        default=0.1,
+        min=0.0, max=1.0,
+    )
 
-        cls.texture_limit = EnumProperty(
-            name="Viewport Texture Limit",
-            default='OFF',
-            description="Limit texture size used by viewport rendering",
-            items=enum_texture_limit
-        )
+    texture_limit: EnumProperty(
+        name="Viewport Texture Limit",
+        default='OFF',
+        description="Limit texture size used by viewport rendering",
+        items=enum_texture_limit
+    )
 
-        cls.texture_limit_render = EnumProperty(
-            name="Render Texture Limit",
-            default='OFF',
-            description="Limit texture size used by final rendering",
-            items=enum_texture_limit
-        )
+    texture_limit_render: EnumProperty(
+        name="Render Texture Limit",
+        default='OFF',
+        description="Limit texture size used by final rendering",
+        items=enum_texture_limit
+    )
 
-        cls.ao_bounces = IntProperty(
-            name="AO Bounces",
-            default=0,
-            description="Approximate indirect light with background tinted ambient occlusion at the specified bounce, 0 disables this feature",
-            min=0, max=1024,
-        )
+    ao_bounces: IntProperty(
+        name="AO Bounces",
+        default=0,
+        description="Approximate indirect light with background tinted ambient occlusion at the specified bounce, 0 disables this feature",
+        min=0, max=1024,
+    )
 
-        cls.ao_bounces_render = IntProperty(
-            name="AO Bounces Render",
-            default=0,
-            description="Approximate indirect light with background tinted ambient occlusion at the specified bounce, 0 disables this feature",
-            min=0, max=1024,
-        )
+    ao_bounces_render: IntProperty(
+        name="AO Bounces Render",
+        default=0,
+        description="Approximate indirect light with background tinted ambient occlusion at the specified bounce, 0 disables this feature",
+        min=0, max=1024,
+    )
 
-        # Various fine-tuning debug flags
-
-        def devices_update_callback(self, context):
-            import _cycles
-            scene = context.scene.as_pointer()
-            return _cycles.debug_flags_update(scene)
-
-        cls.debug_use_cpu_avx2 = BoolProperty(name="AVX2", default=True)
-        cls.debug_use_cpu_avx = BoolProperty(name="AVX", default=True)
-        cls.debug_use_cpu_sse41 = BoolProperty(name="SSE41", default=True)
-        cls.debug_use_cpu_sse3 = BoolProperty(name="SSE3", default=True)
-        cls.debug_use_cpu_sse2 = BoolProperty(name="SSE2", default=True)
-        cls.debug_bvh_layout = EnumProperty(
-            name="BVH Layout",
-            items=enum_bvh_layouts,
-            default='BVH8',
-        )
-        cls.debug_use_cpu_split_kernel = BoolProperty(name="Split Kernel", default=False)
-
-        cls.debug_use_cuda_adaptive_compile = BoolProperty(name="Adaptive Compile", default=False)
-        cls.debug_use_cuda_split_kernel = BoolProperty(name="Split Kernel", default=False)
-
-        cls.debug_opencl_kernel_type = EnumProperty(
-            name="OpenCL Kernel Type",
-            default='DEFAULT',
-            items=(
-                ('DEFAULT', "Default", ""),
-                ('MEGA', "Mega", ""),
-                ('SPLIT', "Split", ""),
-            ),
-            update=devices_update_callback
-        )
+    # Various fine-tuning debug flags
 
-        cls.debug_opencl_device_type = EnumProperty(
-            name="OpenCL Device Type",
-            default='ALL',
-            items=(
-                ('NONE', "None", ""),
-                ('ALL', "All", ""),
-                ('DEFAULT', "Default", ""),
-                ('CPU', "CPU", ""),
-                ('GPU', "GPU", ""),
-                ('ACCELERATOR', "Accelerator", ""),
-            ),
-            update=devices_update_callback
-        )
+    def _devices_update_callback(self, context):
+        import _cycles
+        scene = context.scene.as_pointer()
+        return _cycles.debug_flags_update(scene)
+
+    debug_use_cpu_avx2: BoolProperty(name="AVX2", default=True)
+    debug_use_cpu_avx: BoolProperty(name="AVX", default=True)
+    debug_use_cpu_sse41: BoolProperty(name="SSE41", default=True)
+    debug_use_cpu_sse3: BoolProperty(name="SSE3", default=True)
+    debug_use_cpu_sse2: BoolProperty(name="SSE2", default=True)
+    debug_bvh_layout: EnumProperty(
+        name="BVH Layout",
+        items=enum_bvh_layouts,
+        default='BVH8',
+    )
+    debug_use_cpu_split_kernel: BoolProperty(name="Split Kernel", default=False)
+
+    debug_use_cuda_adaptive_compile: BoolProperty(name="Adaptive Compile", default=False)
+    debug_use_cuda_split_kernel: BoolProperty(name="Split Kernel", default=False)
+
+    debug_opencl_kernel_type: EnumProperty(
+        name="OpenCL Kernel Type",
+        default='DEFAULT',
+        items=(
+            ('DEFAULT', "Default", ""),
+            ('MEGA', "Mega", ""),
+            ('SPLIT', "Split", ""),
+        ),
+        update=_devices_update_callback
+    )
 
-        cls.debug_opencl_kernel_single_program = BoolProperty(
-            name="Single Program",
-            default=True,
-            update=devices_update_callback,
-        )
+    debug_opencl_device_type: EnumProperty(
+        name="OpenCL Device Type",
+        default='ALL',
+        items=(
+            ('NONE', "None", ""),
+            ('ALL', "All", ""),
+            ('DEFAULT', "Default", ""),
+            ('CPU', "CPU", ""),
+            ('GPU', "GPU", ""),
+            ('ACCELERATOR', "Accelerator", ""),
+        ),
+        update=_devices_update_callback
+    )
+
+    debug_opencl_kernel_single_program: BoolProperty(
+        name="Single Program",
+        default=True,
+        update=_devices_update_callback,
+    )
+    del _devices_update_callback
 
-        cls.debug_use_opencl_debug = BoolProperty(name="Debug OpenCL", default=False)
+    debug_use_opencl_debug: BoolProperty(name="Debug OpenCL", default=False)
 
-        cls.debug_opencl_mem_limit = IntProperty(name="Memory limit", default=0,
-                                                 description="Artificial limit on OpenCL memory usage in MB (0 to disable limit)")
+    debug_opencl_mem_limit: IntProperty(
+        name="Memory limit",
+        default=0,
+        description="Artificial limit on OpenCL memory usage in MB (0 to disable limit)"
+    )
+
+    @classmethod
+    def register(cls):
+        bpy.types.Scene.cycles = PointerProperty(
+            name="Cycles Render Settings",
+            description="Cycles render settings",
+            type=cls,
+        )
 
     @classmethod
     def unregister(cls):
@@ -741,113 +750,153 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
 
 
 class CyclesCameraSettings(bpy.types.PropertyGroup):
+
+    aperture_type: EnumProperty(
+        name="Aperture Type",
+        description="Use f-stop number or aperture radius",
+        items=enum_aperture_types,
+        default='RADIUS',
+    )
+    aperture_fstop: FloatProperty(
+        name="Aperture f-stop",
+        description="F-stop ratio (lower numbers give more defocus, higher numbers give a sharper image)",
+        min=0.0, soft_min=0.1, soft_max=64.0,
+        default=5.6,
+        step=10,
+        precision=1,
+    )
+    aperture_size: FloatProperty(
+        name="Aperture Size",
+        description="Radius of the aperture for depth of field (higher values give more defocus)",
+        min=0.0, soft_max=10.0,
+        default=0.0,
+        step=1,
+        precision=4,
+        subtype='DISTANCE',
+    )
+    aperture_blades: IntProperty(
+        name="Aperture Blades",
+        description="Number of blades in aperture for polygonal bokeh (at least 3)",
+        min=0, max=100,
+        default=0,
+    )
+    aperture_rotation: FloatProperty(
+        name="Aperture Rotation",
+        description="Rotation of blades in aperture",
+        soft_min=-pi, soft_max=pi,
+        subtype='ANGLE',
+        default=0,
+    )
+    aperture_ratio: FloatProperty(
+        name="Aperture Ratio",
+        description="Distortion to simulate anamorphic lens bokeh",
+        min=0.01, soft_min=1.0, soft_max=2.0,
+        default=1.0,
+        precision=4,
+    )
+    panorama_type: EnumProperty(
+        name="Panorama Type",
+        description="Distortion to use for the calculation",
+        items=enum_panorama_types,
+        default='FISHEYE_EQUISOLID',
+    )
+    fisheye_fov: FloatProperty(
+        name="Field of View",
+        description="Field of view for the fisheye lens",
+        min=0.1745, soft_max=2.0 * pi, max=10.0 * pi,
+        subtype='ANGLE',
+        default=pi,
+    )
+    fisheye_lens: FloatProperty(
+        name="Fisheye Lens",
+        description="Lens focal length (mm)",
+        min=0.01, soft_max=15.0, max=100.0,
+        default=10.5,
+    )
+    latitude_min: FloatProperty(
+        name="Min Latitude",
+        description="Minimum latitude (vertical angle) for the equirectangular lens",
+        min=-0.5 * pi, max=0.5 * pi,
+        subtype='ANGLE',
+        default=-0.5 * pi,
+    )
+    latitude_max: FloatProperty(
+        name="Max Latitude",
+        description="Maximum latitude (vertical angle) for the equirectangular lens",
+        min=-0.5 * pi, max=0.5 * pi,
+        subtype='ANGLE',
+        default=0.5 * pi,
+    )
+    longitude_min: FloatProperty(
+        name="Min Longitude",
+        description="Minimum longitude (horizontal angle) for the equirectangular lens",
+        min=-pi, max=pi,
+        subtype='ANGLE',
+        default=-pi,
+    )
+    longitude_max: FloatProperty(
+        name="Max Longitude",
+        description="Maximum longitude (horizontal angle) for the equirectangular lens",
+        min=-pi, max=pi,
+        subtype='ANGLE',
+        default=pi,
+    )
+
     @classmethod
     def register(cls):
-        import math
-
         bpy.types.Camera.cycles = PointerProperty(
             name="Cycles Camera Settings",
             description="Cycles camera settings",
             type=cls,
         )
 
-        cls.aperture_type = EnumProperty(
-            name="Aperture Type",
-            description="Use f-stop number or aperture radius",
-            items=enum_aperture_types,
-            default='RADIUS',
-        )
-        cls.aperture_fstop = FloatProperty(
-            name="Aperture f-stop",
-            description="F-stop ratio (lower numbers give more defocus, higher numbers give a sharper image)",
-            min=0.0, soft_min=0.1, soft_max=64.0,
-            default=5.6,
-            step=10,
-            precision=1,
-        )
-        cls.aperture_size = FloatProperty(
-            name="Aperture Size",
-            description="Radius of the aperture for depth of field (higher values give more defocus)",
-            min=0.0, soft_max=10.0,
-            default=0.0,
-            step=1,
-            precision=4,
-            subtype='DISTANCE',
-        )
-        cls.aperture_blades = IntProperty(
-            name="Aperture Blades",
-            description="Number of blades in aperture for polygonal bokeh (at least 3)",
-            min=0, max=100,
-            default=0,
-        )
-        cls.aperture_rotation = FloatProperty(
-            name="Aperture Rotation",
-            description="Rotation of blades in aperture",
-            soft_min=-math.pi, soft_max=math.pi,
-            subtype='ANGLE',
-            default=0,
-        )
-        cls.aperture_ratio = FloatProperty(
-            name="Aperture Ratio",
-            description="Distortion to simulate anamorphic lens bokeh",
-            min=0.01, soft_min=1.0, soft_max=2.0,
-            default=1.0,
-            precision=4,
-        )
-        cls.panorama_type = EnumProperty(
-            name="Panorama Type",
-            description="Distortion to use for the calculation",
-            items=enum_panorama_types,
-            default='FISHEYE_EQUISOLID',
-        )
-        cls.fisheye_fov = FloatProperty(
-            name="Field of View",
-            description="Field of view for the fisheye lens",
-            min=0.1745, soft_max=2.0 * math.pi, max=10.0 * math.pi,
-            subtype='ANGLE',
-            default=math.pi,
-        )
-        cls.fisheye_lens = FloatProperty(
-            name="Fisheye Lens",
-            description="Lens focal length (mm)",
-            min=0.01, soft_max=15.0, max=100.0,
-            default=10.5,
-        )
-        cls.latitude_min = FloatProperty(
-            name="Min Latitude",
-            description="Minimum latitude (vertical angle) for the equirectangular lens",
-            min=-0.5 * math.pi, max=0.5 * math.pi,
-            subtype='ANGLE',
-            default=-0.5 * math.pi,
-        )
-        cls.latitude_max = FloatProperty(
-            name="Max Latitude",
-            description="Maximum latitude (vertical angle) for the equirectangular lens",
-            min=-0.5 * math.pi, max=0.5 * math.pi,
-            subtype='ANGLE',
-            default=0.5 * math.pi,
-        )
-        cls.longitude_min = FloatProperty(
-            name="Min Longitude",
-            description="Minimum longitude (horizontal angle) for the equirectangular lens",
-            min=-math.pi, max=math.pi,
-            subtype='ANGLE',
-            default=-math.pi,
-        )
-        cls.longitude_max = FloatProperty(
-            name="Max Longitude",
-            description="Maximum longitude (horizontal angle) for the equirectangular lens",
-            min=-math.pi, max=math.pi,
-            subtype='ANGLE',
-            default=math.pi,
-        )
-
     @classmethod
     def unregister(cls):
         del bpy.types.Camera.cycles
 
 
 class CyclesMaterialSettings(bpy.types.PropertyGroup):
+
+    sample_as_light: BoolProperty(
+        name="Multiple Importance Sample",
+        description="Use multiple importance sampling for this material, "
+        "disabling may reduce overall noise for large "
+        "objects that emit little light compared to other light sources",
+        default=True,
+    )
+    use_transparent_shadow: BoolProperty(
+        name="Transparent Shadows",
+        description="Use transparent shadows for this material if it contains a Transparent BSDF, "
+        "disabling will render faster but not give accurate shadows",
+        default=True,
+    )
+    homogeneous_volume: BoolProperty(
+        name="Homogeneous Volume",
+        description="When using volume rendering, assume volume has the same density everywhere "
+        "(not using any textures), for faster rendering",
+        default=False,
+    )
+    volume_sampling: EnumProperty(
+        name="Volume Sampling",
+        description="Sampling method to use for volumes",
+        items=enum_volume_sampling,
+        default='MULTIPLE_IMPORTANCE',
+    )
+
+    volume_interpolation: EnumProperty(
+        name="Volume Interpolation",
+        description="Interpolation method to use for smoke/fire volumes",
+        items=enum_volume_interpolation,
+        default='LINEAR',
+    )
+
+    displacement_method: EnumProperty(
+        name="Displacement Method",
+        description="Method to use for the displacement",
+        items=enum_displacement_methods,
+        default='BUMP',
+    )
+
     @classmethod
     def register(cls):
         bpy.types.Material.cycles = PointerProperty(
@@ -855,95 +904,103 @@ class CyclesMaterialSettings(bpy.types.PropertyGroup):
             description="Cycles material settings",
             type=cls,
         )
-        cls.sample_as_light = BoolProperty(
-            name="Multiple Importance Sample",
-            description="Use multiple importance sampling for this material, "
-            "disabling may reduce overall noise for large "
-            "objects that emit little light compared to other light sources",
-            default=True,
-        )
-        cls.use_transparent_shadow = BoolProperty(
-            name="Transparent Shadows",
-            description="Use transparent shadows for this material if it contains a Transparent BSDF, "
-            "disabling will render faster but not give accurate shadows",
-            default=True,
-        )
-        cls.homogeneous_volume = BoolProperty(
-            name="Homogeneous Volume",
-            description="When using volume rendering, assume volume has the same density everywhere "
-            "(not using any textures), for faster rendering",
-            default=False,
-        )
-        cls.volume_sampling = EnumProperty(
-            name="Volume Sampling",
-            description="Sampling method to use for volumes",
-            items=enum_volume_sampling,
-            default='MULTIPLE_IMPORTANCE',
-        )
-
-        cls.volume_interpolation = EnumProperty(
-            name="Volume Interpolation",
-            description="Interpolation method to use for smoke/fire volumes",
-            items=enum_volume_interpolation,
-            default='LINEAR',
-        )
-
-        cls.displacement_method = EnumProperty(
-            name="Displacement Method",
-            description="Method to use for the displacement",
-            items=enum_displacement_methods,
-            default='BUMP',
-        )
 
     @classmethod
     def unregister(cls):
         del bpy.types.Material.cycles
 
 
-class CyclesLampSettings(bpy.types.PropertyGroup):
+class CyclesLightSettings(bpy.types.PropertyGroup):
+
+    cast_shadow: BoolProperty(
+        name="Cast Shadow",
+        description="Light casts shadows",
+        default=True,
+    )
+    samples: IntProperty(
+        name="Samples",
+        description="Number of light samples to render for each AA sample",
+        min=1, max=10000,
+        default=1,
+    )
+    max_bounces: IntProperty(
+        name="Max Bounces",
+        description="Maximum number of bounces the light will contribute to the render",
+        min=0, max=1024,
+        default=1024,
+    )
+    use_multiple_importance_sampling: BoolProperty(
+        name="Multiple Importance Sample",
+        description="Use multiple importance sampling for the light, "
+        "reduces noise for area lights and sharp glossy materials",
+        default=True,
+    )
+    is_portal: BoolProperty(
+        name="Is Portal",
+        description="Use this area light to guide sampling of the background, "
+        "note that this will make the light invisible",
+        default=False,
+    )
+
     @classmethod
     def register(cls):
-        bpy.types.Lamp.cycles = PointerProperty(
-            name="Cycles Lamp Settings",
-            description="Cycles lamp settings",
+        bpy.types.Light.cycles = PointerProperty(
+            name="Cycles Light Settings",
+            description="Cycles light settings",
             type=cls,
         )
-        cls.cast_shadow = BoolProperty(
-            name="Cast Shadow",
-            description="Lamp casts shadows",
-            default=True,
-        )
-        cls.samples = IntProperty(
-            name="Samples",
-            description="Number of light samples to render for each AA sample",
-            min=1, max=10000,
-            default=1,
-        )
-        cls.max_bounces = IntProperty(
-            name="Max Bounces",
-            description="Maximum number of bounces the light will contribute to the render",
-            min=0, max=1024,
-            default=1024,
-        )
-        cls.use_multiple_importance_sampling = BoolProperty(
-            name="Multiple Importance Sample",
-            description="Use multiple importance sampling for the lamp, "
-            "reduces noise for area lamps and sharp glossy materials",
-            default=True,
-        )
-        cls.is_portal = BoolProperty(
-            name="Is Portal",
-            description="Use this area lamp to guide sampling of the background, "
-            "note that this will make the lamp invisible",
-            default=False,
-        )
 
     @classmethod
     def unregister(cls):
-        del bpy.types.Lamp.cycles
+        del bpy.types.Light.cycles
 
 
 class CyclesWorldSettings(bpy.types.PropertyGroup):
+
+    sampling_method: EnumProperty(
+        name="Sampling method",
+        description="How to sample the background light",
+        items=enum_world_mis,
+        default='AUTOMATIC',
+    )
+    sample_map_resolution: IntProperty(
+        name="Map Resolution",
+        description="Importance map size is resolution x resolution/2; "
+        "higher values potentially produce less noise, at the cost of memory and speed",
+        min=4, max=8192,
+        default=1024,
+    )
+    samples: IntProperty(
+        name="Samples",
+        description="Number of light samples to render for each AA sample",
+        min=1, max=10000,
+        default=1,
+    )
+    max_bounces: IntProperty(
+        name="Max Bounces",
+        description="Maximum number of bounces the background light will contribute to the render",
+        min=0, max=1024,
+        default=1024,
+    )
+    homogeneous_volume: BoolProperty(
+        name="Homogeneous Volume",
+        description="When using volume rendering, assume volume has the same density everywhere"
+        "(not using any textures), for faster rendering",
+        default=False,
+    )
+    volume_sampling: EnumProperty(
+        name="Volume Sampling",
+        description="Sampling method to use for volumes",
+        items=enum_volume_sampling,
+        default='EQUIANGULAR',
+    )
+    volume_interpolation: EnumProperty(
+        name="Volume Interpolation",
+        description="Interpolation method to use for volumes",
+        items=enum_volume_interpolation,
+        default='LINEAR',
+    )
+
     @classmethod
     def register(cls):
         bpy.types.World.cycles = PointerProperty(
@@ -951,50 +1008,6 @@ class CyclesWorldSettings(bpy.types.PropertyGroup):
             description="Cycles world settings",
             type=cls,
         )
-        cls.sampling_method = EnumProperty(
-            name="Sampling method",
-            description="How to sample the background light",
-            items=enum_world_mis,
-            default='AUTOMATIC',
-        )
-        cls.sample_map_resolution = IntProperty(
-            name="Map Resolution",
-            description="Importance map size is resolution x resolution/2; "
-            "higher values potentially produce less noise, at the cost of memory and speed",
-            min=4, max=8192,
-            default=1024,
-        )
-        cls.samples = IntProperty(
-            name="Samples",
-            description="Number of light samples to render for each AA sample",
-            min=1, max=10000,
-            default=1,
-        )
-        cls.max_bounces = IntProperty(
-            name="Max Bounces",
-            description="Maximum number of bounces the background light will contribute to the render",
-            min=0, max=1024,
-            default=1024,
-        )
-        cls.homogeneous_volume = BoolProperty(
-            name="Homogeneous Volume",
-            description="When using volume rendering, assume volume has the same density everywhere"
-            "(not using any textures), for faster rendering",
-            default=False,
-        )
-        cls.volume_sampling = EnumProperty(
-            name="Volume Sampling",
-            description="Sampling method to use for volumes",
-            items=enum_volume_sampling,
-            default='EQUIANGULAR',
-        )
-
-        cls.volume_interpolation = EnumProperty(
-            name="Volume Interpolation",
-            description="Interpolation method to use for volumes",
-            items=enum_volume_interpolation,
-            default='LINEAR',
-        )
 
     @classmethod
     def unregister(cls):
@@ -1002,6 +1015,38 @@ class CyclesWorldSettings(bpy.types.PropertyGroup):
 
 
 class CyclesVisibilitySettings(bpy.types.PropertyGroup):
+
+    camera: BoolProperty(
+        name="Camera",
+        description="Object visibility for camera rays",
+        default=True,
+    )
+    diffuse: BoolProperty(
+        name="Diffuse",
+        description="Object visibility for diffuse reflection rays",
+        default=True,
+    )
+    glossy: BoolProperty(
+        name="Glossy",
+        description="Object visibility for glossy reflection rays",
+        default=True,
+    )
+    transmission: BoolProperty(
+        name="Transmission",
+        description="Object visibility for transmission rays",
+        default=True,
+    )
+    shadow: BoolProperty(
+        name="Shadow",
+        description="Object visibility for shadow rays",
+        default=True,
+    )
+    scatter: BoolProperty(
+        name="Volume Scatter",
+        description="Object visibility for volume scatter rays",
+        default=True,
+    )
+
     @classmethod
     def register(cls):
         bpy.types.Object.cycles_visibility = PointerProperty(
@@ -1016,37 +1061,6 @@ class CyclesVisibilitySettings(bpy.types.PropertyGroup):
             type=cls,
         )
 
-        cls.camera = BoolProperty(
-            name="Camera",
-            description="Object visibility for camera rays",
-            default=True,
-        )
-        cls.diffuse = BoolProperty(
-            name="Diffuse",
-            description="Object visibility for diffuse reflection rays",
-            default=True,
-        )
-        cls.glossy = BoolProperty(
-            name="Glossy",
-            description="Object visibility for glossy reflection rays",
-            default=True,
-        )
-        cls.transmission = BoolProperty(
-            name="Transmission",
-            description="Object visibility for transmission rays",
-            default=True,
-        )
-        cls.shadow = BoolProperty(
-            name="Shadow",
-            description="Object visibility for shadow rays",
-            default=True,
-        )
-        cls.scatter = BoolProperty(
-            name="Volume Scatter",
-            description="Object visibility for volume scatter rays",
-            default=True,
-        )
-
     @classmethod
     def unregister(cls):
         del bpy.types.Object.cycles_visibility
@@ -1080,70 +1094,71 @@ class CyclesMeshSettings(bpy.types.PropertyGroup):
 
 
 class CyclesObjectSettings(bpy.types.PropertyGroup):
-    @classmethod
-    def register(cls):
-        bpy.types.Object.cycles = PointerProperty(
-            name="Cycles Object Settings",
-            description="Cycles object settings",
-            type=cls,
-        )
 
-        cls.use_motion_blur = BoolProperty(
-            name="Use Motion Blur",
-            description="Use motion blur for this object",
-            default=True,
-        )
+    use_motion_blur: BoolProperty(
+        name="Use Motion Blur",
+        description="Use motion blur for this object",
+        default=True,
+    )
 
-        cls.use_deform_motion = BoolProperty(
-            name="Use Deformation Motion",
-            description="Use deformation motion blur for this object",
-            default=True,
-        )
+    use_deform_motion: BoolProperty(
+        name="Use Deformation Motion",
+        description="Use deformation motion blur for this object",
+        default=True,
+    )
 
-        cls.motion_steps = IntProperty(
-            name="Motion Steps",
-            description="Control accuracy of motion blur, more steps gives more memory usage (actual number of steps is 2^(steps - 1))",
-            min=1, soft_max=8,
-            default=1,
-        )
+    motion_steps: IntProperty(
+        name="Motion Steps",
+        description="Control accuracy of motion blur, more steps gives more memory usage (actual number of steps is 2^(steps - 1))",
+        min=1, soft_max=8,
+        default=1,
+    )
 
-        cls.use_camera_cull = BoolProperty(
-            name="Use Camera Cull",
-            description="Allow this object and its duplicators to be culled by camera space culling",
-            default=False,
-        )
+    use_camera_cull: BoolProperty(
+        name="Use Camera Cull",
+        description="Allow this object and its duplicators to be culled by camera space culling",
+        default=False,
+    )
 
-        cls.use_distance_cull = BoolProperty(
-            name="Use Distance Cull",
-            description="Allow this object and its duplicators to be culled by distance from camera",
-            default=False,
-        )
+    use_distance_cull: BoolProperty(
+        name="Use Distance Cull",
+        description="Allow this object and its duplicators to be culled by distance from camera",
+        default=False,
+    )
 
-        cls.use_adaptive_subdivision = BoolProperty(
-            name="Use Adaptive Subdivision",
-            description="Use adaptive render time subdivision",
-            default=False,
-        )
+    use_adaptive_subdivision: BoolProperty(
+        name="Use Adaptive Subdivision",
+        description="Use adaptive render time subdivision",
+        default=False,
+    )
 
-        cls.dicing_rate = FloatProperty(
-            name="Dicing Scale",
-            description="Multiplier for scene dicing rate (located in the Geometry Panel)",
-            min=0.1, max=1000.0, soft_min=0.5,
-            default=1.0,
-        )
+    dicing_rate: FloatProperty(
+        name="Dicing Scale",
+        description="Multiplier for scene dicing rate (located in the Subdivision panel)",
+        min=0.1, max=1000.0, soft_min=0.5,
+        default=1.0,
+    )
 
-        cls.is_shadow_catcher = BoolProperty(
-            name="Shadow Catcher",
-            description="Only render shadows on this object, for compositing renders into real footage",
-            default=False,
-        )
+    is_shadow_catcher: BoolProperty(
+        name="Shadow Catcher",
+        description="Only render shadows on this object, for compositing renders into real footage",
+        default=False,
+    )
+
+    is_holdout: BoolProperty(
+        name="Holdout",
+        description="Render objects as a holdout or matte, creating a "
+        "hole in the image with zero alpha, to fill out in "
+        "compositing with real footage or another render",
+        default=False,
+    )
 
-        cls.is_holdout = BoolProperty(
-            name="Holdout",
-            description="Render objects as a holdout or matte, creating a "
-            "hole in the image with zero alpha, to fill out in "
-            "compositing with real footange or another render",
-            default=False,
+    @classmethod
+    def register(cls):
+        bpy.types.Object.cycles = PointerProperty(
+            name="Cycles Object Settings",
+            description="Cycles object settings",
+            type=cls,
         )
 
     @classmethod
@@ -1152,6 +1167,56 @@ class CyclesObjectSettings(bpy.types.PropertyGroup):
 
 
 class CyclesCurveRenderSettings(bpy.types.PropertyGroup):
+
+    primitive: EnumProperty(
+        name="Primitive",
+        description="Type of primitive used for hair rendering",
+        items=enum_curve_primitives,
+        default='LINE_SEGMENTS',
+    )
+    shape: EnumProperty(
+        name="Shape",
+        description="Form of hair",
+        items=enum_curve_shape,
+        default='THICK',
+    )
+    cull_backfacing: BoolProperty(
+        name="Cull Back-faces",
+        description="Do not test the back-face of each strand",
+        default=True,
+    )
+    use_curves: BoolProperty(
+        name="Use Cycles Hair Rendering",
+        description="Activate Cycles hair rendering for particle system",
+        default=True,
+    )
+    resolution: IntProperty(
+        name="Resolution",
+        description="Resolution of generated mesh",
+        min=3, max=64,
+        default=3,
+    )
+    minimum_width: FloatProperty(
+        name="Minimal width",
+        description="Minimal pixel width for strands (0 - deactivated)",
+        min=0.0, max=100.0,
+        default=0.0,
+        subtype='PIXEL'
+    )
+    maximum_width: FloatProperty(
+        name="Maximal width",
+        description="Maximum extension that strand radius can be increased by",
+        min=0.0, max=100.0,
+        default=0.1,
+        subtype='PIXEL'
+    )
+    subdivisions: IntProperty(
+        name="Subdivisions",
+        description="Number of subdivisions used in Cardinal curve intersection (power of 2)",
+        min=0, max=24,
+        default=4,
+    )
+
     @classmethod
     def register(cls):
         bpy.types.Scene.cycles_curves = PointerProperty(
@@ -1159,52 +1224,6 @@ class CyclesCurveRenderSettings(bpy.types.PropertyGroup):
             description="Cycles hair rendering settings",
             type=cls,
         )
-        cls.primitive = EnumProperty(
-            name="Primitive",
-            description="Type of primitive used for hair rendering",
-            items=enum_curve_primitives,
-            default='LINE_SEGMENTS',
-        )
-        cls.shape = EnumProperty(
-            name="Shape",
-            description="Form of hair",
-            items=enum_curve_shape,
-            default='THICK',
-        )
-        cls.cull_backfacing = BoolProperty(
-            name="Cull back-faces",
-            description="Do not test the back-face of each strand",
-            default=True,
-        )
-        cls.use_curves = BoolProperty(
-            name="Use Cycles Hair Rendering",
-            description="Activate Cycles hair rendering for particle system",
-            default=True,
-        )
-        cls.resolution = IntProperty(
-            name="Resolution",
-            description="Resolution of generated mesh",
-            min=3, max=64,
-            default=3,
-        )
-        cls.minimum_width = FloatProperty(
-            name="Minimal width",
-            description="Minimal pixel width for strands (0 - deactivated)",
-            min=0.0, max=100.0,
-            default=0.0,
-        )
-        cls.maximum_width = FloatProperty(
-            name="Maximal width",
-            description="Maximum extension that strand radius can be increased by",
-            min=0.0, max=100.0,
-            default=0.1,
-        )
-        cls.subdivisions = IntProperty(
-            name="Subdivisions",
-            description="Number of subdivisions used in Cardinal curve intersection (power of 2)",
-            min=0, max=24,
-            default=4,
-        )
 
     @classmethod
     def unregister(cls):
@@ -1212,223 +1231,179 @@ class CyclesCurveRenderSettings(bpy.types.PropertyGroup):
 
 
 def update_render_passes(self, context):
-    scene = context.scene
-    rd = scene.render
-    rl = rd.layers.active
-    rl.update_render_passes()
+    view_layer = context.view_layer
+    view_layer.update_render_passes()
 
 
 class CyclesRenderLayerSettings(bpy.types.PropertyGroup):
-    @classmethod
-    def register(cls):
-        bpy.types.SceneRenderLayer.cycles = PointerProperty(
-            name="Cycles SceneRenderLayer Settings",
-            description="Cycles SceneRenderLayer Settings",
-            type=cls,
-        )
-        cls.pass_debug_bvh_traversed_nodes = BoolProperty(
-            name="Debug BVH Traversed Nodes",
-            description="Store Debug BVH Traversed Nodes pass",
-            default=False,
-            update=update_render_passes,
-        )
-        cls.pass_debug_bvh_traversed_instances = BoolProperty(
-            name="Debug BVH Traversed Instances",
-            description="Store Debug BVH Traversed Instances pass",
-            default=False,
-            update=update_render_passes,
-        )
-        cls.pass_debug_bvh_intersections = BoolProperty(
-            name="Debug BVH Intersections",
-            description="Store Debug BVH Intersections",
-            default=False,
-            update=update_render_passes,
-        )
-        cls.pass_debug_ray_bounces = BoolProperty(
-            name="Debug Ray Bounces",
-            description="Store Debug Ray Bounces pass",
-            default=False,
-            update=update_render_passes,
-        )
-        cls.pass_debug_render_time = BoolProperty(
-            name="Debug Render Time",
-            description="Render time in milliseconds per sample and pixel",
-            default=False,
-            update=update_render_passes,
-        )
-        cls.use_pass_volume_direct = BoolProperty(
-            name="Volume Direct",
-            description="Deliver direct volumetric scattering pass",
-            default=False,
-            update=update_render_passes,
-        )
-        cls.use_pass_volume_indirect = BoolProperty(
-            name="Volume Indirect",
-            description="Deliver indirect volumetric scattering pass",
-            default=False,
-            update=update_render_passes,
-        )
 
-        cls.use_denoising = BoolProperty(
-            name="Use Denoising",
-            description="Denoise the rendered image",
-            default=False,
-            update=update_render_passes,
-        )
-        cls.denoising_diffuse_direct = BoolProperty(
-            name="Diffuse Direct",
-            description="Denoise the direct diffuse lighting",
-            default=True,
-        )
-        cls.denoising_diffuse_indirect = BoolProperty(
-            name="Diffuse Indirect",
-            description="Denoise the indirect diffuse lighting",
-            default=True,
-        )
-        cls.denoising_glossy_direct = BoolProperty(
-            name="Glossy Direct",
-            description="Denoise the direct glossy lighting",
-            default=True,
-        )
-        cls.denoising_glossy_indirect = BoolProperty(
-            name="Glossy Indirect",
-            description="Denoise the indirect glossy lighting",
-            default=True,
-        )
-        cls.denoising_transmission_direct = BoolProperty(
-            name="Transmission Direct",
-            description="Denoise the direct transmission lighting",
-            default=True,
-        )
-        cls.denoising_transmission_indirect = BoolProperty(
-            name="Transmission Indirect",
-            description="Denoise the indirect transmission lighting",
-            default=True,
-        )
-        cls.denoising_subsurface_direct = BoolProperty(
-            name="Subsurface Direct",
-            description="Denoise the direct subsurface lighting",
-            default=True,
-        )
-        cls.denoising_subsurface_indirect = BoolProperty(
-            name="Subsurface Indirect",
-            description="Denoise the indirect subsurface lighting",
-            default=True,
-        )
-        cls.denoising_strength = FloatProperty(
-            name="Denoising Strength",
-            description="Controls neighbor pixel weighting for the denoising filter (lower values preserve more detail, but aren't as smooth)",
-            min=0.0, max=1.0,
-            default=0.5,
-        )
-        cls.denoising_feature_strength = FloatProperty(
-            name="Denoising Feature Strength",
-            description="Controls removal of noisy image feature passes (lower values preserve more detail, but aren't as smooth)",
-            min=0.0, max=1.0,
-            default=0.5,
-        )
-        cls.denoising_radius = IntProperty(
-            name="Denoising Radius",
-            description="Size of the image area that's used to denoise a pixel (higher values are smoother, but might lose detail and are slower)",
-            min=1, max=25,
-            default=8,
-        )
-        cls.denoising_relative_pca = BoolProperty(
-            name="Relative filter",
-            description="When removing pixels that don't carry information, use a relative threshold instead of an absolute one (can help to reduce artifacts, but might cause detail loss around edges)",
-            default=False,
-        )
-        cls.denoising_store_passes = BoolProperty(
-            name="Store denoising passes",
-            description="Store the denoising feature passes and the noisy image",
-            default=False,
-            update=update_render_passes,
-        )
-        cls.use_pass_crypto_object = BoolProperty(
-                name="Cryptomatte Object",
-                description="Render cryptomatte object pass, for isolating objects in compositing",
-                default=False,
-                update=update_render_passes,
-                )
-        cls.use_pass_crypto_material = BoolProperty(
-                name="Cryptomatte Material",
-                description="Render cryptomatte material pass, for isolating materials in compositing",
-                default=False,
-                update=update_render_passes,
-                )
-        cls.use_pass_crypto_asset = BoolProperty(
-                name="Cryptomatte Asset",
-                description="Render cryptomatte asset pass, for isolating groups of objects with the same parent",
-                default=False,
-                update=update_render_passes,
-                )
-        cls.pass_crypto_depth = IntProperty(
-                name="Cryptomatte Levels",
-                description="Sets how many unique objects can be distinguished per pixel",
-                default=6, min=2, max=16, step=2,
-                update=update_render_passes,
-                )
-        cls.pass_crypto_accurate = BoolProperty(
-                name="Cryptomatte Accurate",
-                description="Gerenate a more accurate Cryptomatte pass. CPU only, may render slower and use more memory",
-                default=True,
-                update=update_render_passes,
-                )
-    @classmethod
-    def unregister(cls):
-        del bpy.types.SceneRenderLayer.cycles
+    pass_debug_bvh_traversed_nodes: BoolProperty(
+        name="Debug BVH Traversed Nodes",
+        description="Store Debug BVH Traversed Nodes pass",
+        default=False,
+        update=update_render_passes,
+    )
+    pass_debug_bvh_traversed_instances: BoolProperty(
+        name="Debug BVH Traversed Instances",
+        description="Store Debug BVH Traversed Instances pass",
+        default=False,
+        update=update_render_passes,
+    )
+    pass_debug_bvh_intersections: BoolProperty(
+        name="Debug BVH Intersections",
+        description="Store Debug BVH Intersections",
+        default=False,
+        update=update_render_passes,
+    )
+    pass_debug_ray_bounces: BoolProperty(
+        name="Debug Ray Bounces",
+        description="Store Debug Ray Bounces pass",
+        default=False,
+        update=update_render_passes,
+    )
+    pass_debug_render_time: BoolProperty(
+        name="Debug Render Time",
+        description="Render time in milliseconds per sample and pixel",
+        default=False,
+        update=update_render_passes,
+    )
+    use_pass_volume_direct: BoolProperty(
+        name="Volume Direct",
+        description="Deliver direct volumetric scattering pass",
+        default=False,
+        update=update_render_passes,
+    )
+    use_pass_volume_indirect: BoolProperty(
+        name="Volume Indirect",
+        description="Deliver indirect volumetric scattering pass",
+        default=False,
+        update=update_render_passes,
+    )
 
+    use_denoising: BoolProperty(
+        name="Use Denoising",
+        description="Denoise the rendered image",
+        default=False,
+        update=update_render_passes,
+    )
+    denoising_diffuse_direct: BoolProperty(
+        name="Diffuse Direct",
+        description="Denoise the direct diffuse lighting",
+        default=True,
+    )
+    denoising_diffuse_indirect: BoolProperty(
+        name="Diffuse Indirect",
+        description="Denoise the indirect diffuse lighting",
+        default=True,
+    )
+    denoising_glossy_direct: BoolProperty(
+        name="Glossy Direct",
+        description="Denoise the direct glossy lighting",
+        default=True,
+    )
+    denoising_glossy_indirect: BoolProperty(
+        name="Glossy Indirect",
+        description="Denoise the indirect glossy lighting",
+        default=True,
+    )
+    denoising_transmission_direct: BoolProperty(
+        name="Transmission Direct",
+        description="Denoise the direct transmission lighting",
+        default=True,
+    )
+    denoising_transmission_indirect: BoolProperty(
+        name="Transmission Indirect",
+        description="Denoise the indirect transmission lighting",
+        default=True,
+    )
+    denoising_subsurface_direct: BoolProperty(
+        name="Subsurface Direct",
+        description="Denoise the direct subsurface lighting",
+        default=True,
+    )
+    denoising_subsurface_indirect: BoolProperty(
+        name="Subsurface Indirect",
+        description="Denoise the indirect subsurface lighting",
+        default=True,
+    )
+    denoising_strength: FloatProperty(
+        name="Denoising Strength",
+        description="Controls neighbor pixel weighting for the denoising filter (lower values preserve more detail, but aren't as smooth)",
+        min=0.0, max=1.0,
+        default=0.5,
+    )
+    denoising_feature_strength: FloatProperty(
+        name="Denoising Feature Strength",
+        description="Controls removal of noisy image feature passes (lower values preserve more detail, but aren't as smooth)",
+        min=0.0, max=1.0,
+        default=0.5,
+    )
+    denoising_radius: IntProperty(
+        name="Denoising Radius",
+        description="Size of the image area that's used to denoise a pixel (higher values are smoother, but might lose detail and are slower)",
+        min=1, max=25,
+        default=8,
+    )
+    denoising_relative_pca: BoolProperty(
+        name="Relative filter",
+        description="When removing pixels that don't carry information, use a relative threshold instead of an absolute one (can help to reduce artifacts, but might cause detail loss around edges)",
+        default=False,
+    )
+    denoising_store_passes: BoolProperty(
+        name="Store denoising passes",
+        description="Store the denoising feature passes and the noisy image",
+        default=False,
+        update=update_render_passes,
+    )
+    use_pass_crypto_object: BoolProperty(
+        name="Cryptomatte Object",
+        description="Render cryptomatte object pass, for isolating objects in compositing",
+        default=False,
+        update=update_render_passes,
+        )
+    use_pass_crypto_material: BoolProperty(
+        name="Cryptomatte Material",
+        description="Render cryptomatte material pass, for isolating materials in compositing",
+        default=False,
+        update=update_render_passes,
+        )
+    use_pass_crypto_asset: BoolProperty(
+        name="Cryptomatte Asset",
+        description="Render cryptomatte asset pass, for isolating groups of objects with the same parent",
+        default=False,
+        update=update_render_passes,
+        )
+    pass_crypto_depth: IntProperty(
+        name="Cryptomatte Levels",
+        description="Sets how many unique objects can be distinguished per pixel",
+        default=6, min=2, max=16, step=2,
+        update=update_render_passes,
+        )
+    pass_crypto_accurate: BoolProperty(
+        name="Cryptomatte Accurate",
+        description="Generate a more accurate Cryptomatte pass. CPU only, may render slower and use more memory",
+        default=True,
+        update=update_render_passes,
+        )
 
-class CyclesCurveSettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
-        bpy.types.ParticleSettings.cycles = PointerProperty(
-            name="Cycles Hair Settings",
-            description="Cycles hair settings",
+        bpy.types.ViewLayer.cycles = PointerProperty(
+            name="Cycles ViewLayer Settings",
+            description="Cycles ViewLayer Settings",
             type=cls,
         )
-        cls.radius_scale = FloatProperty(
-            name="Radius Scaling",
-            description="Multiplier of width properties",
-            min=0.0, max=1000.0,
-            default=0.01,
-        )
-        cls.root_width = FloatProperty(
-            name="Root Size",
-            description="Strand's width at root",
-            min=0.0, max=1000.0,
-            default=1.0,
-        )
-        cls.tip_width = FloatProperty(
-            name="Tip Multiplier",
-            description="Strand's width at tip",
-            min=0.0, max=1000.0,
-            default=0.0,
-        )
-        cls.shape = FloatProperty(
-            name="Strand Shape",
-            description="Strand shape parameter",
-            min=-1.0, max=1.0,
-            default=0.0,
-        )
-        cls.use_closetip = BoolProperty(
-            name="Close tip",
-            description="Set tip radius to zero",
-            default=True,
-        )
 
     @classmethod
     def unregister(cls):
-        del bpy.types.ParticleSettings.cycles
+        del bpy.types.ViewLayer.cycles
 
 
 class CyclesDeviceSettings(bpy.types.PropertyGroup):
-    @classmethod
-    def register(cls):
-        cls.id = StringProperty(name="ID")
-        cls.name = StringProperty(name="Name")
-        cls.use = BoolProperty(name="Use", default=True)
-        cls.type = EnumProperty(name="Type", items=enum_device_type, default='CUDA')
+    id: StringProperty(name="ID")
+    name: StringProperty(name="Name")
+    use: BoolProperty(name="Use", default=True)
+    type: EnumProperty(name="Type", items=enum_device_type, default='CUDA')
 
 
 class CyclesPreferences(bpy.types.AddonPreferences):
@@ -1444,13 +1419,13 @@ class CyclesPreferences(bpy.types.AddonPreferences):
             list.append(('OPENCL', "OpenCL", "Use OpenCL for GPU acceleration", 2))
         return list
 
-    compute_device_type = EnumProperty(
+    compute_device_type: EnumProperty(
         name="Compute Device Type",
         description="Device to use for computation (rendering with Cycles)",
         items=get_device_types,
     )
 
-    devices = bpy.props.CollectionProperty(type=CyclesDeviceSettings)
+    devices: bpy.props.CollectionProperty(type=CyclesDeviceSettings)
 
     def find_existing_device_entry(self, device):
         for device_entry in self.devices:
@@ -1550,13 +1525,12 @@ def register():
     bpy.utils.register_class(CyclesRenderSettings)
     bpy.utils.register_class(CyclesCameraSettings)
     bpy.utils.register_class(CyclesMaterialSettings)
-    bpy.utils.register_class(CyclesLampSettings)
+    bpy.utils.register_class(CyclesLightSettings)
     bpy.utils.register_class(CyclesWorldSettings)
     bpy.utils.register_class(CyclesVisibilitySettings)
     bpy.utils.register_class(CyclesMeshSettings)
     bpy.utils.register_class(CyclesObjectSettings)
     bpy.utils.register_class(CyclesCurveRenderSettings)
-    bpy.utils.register_class(CyclesCurveSettings)
     bpy.utils.register_class(CyclesDeviceSettings)
     bpy.utils.register_class(CyclesPreferences)
     bpy.utils.register_class(CyclesRenderLayerSettings)
@@ -1566,13 +1540,12 @@ def unregister():
     bpy.utils.unregister_class(CyclesRenderSettings)
     bpy.utils.unregister_class(CyclesCameraSettings)
     bpy.utils.unregister_class(CyclesMaterialSettings)
-    bpy.utils.unregister_class(CyclesLampSettings)
+    bpy.utils.unregister_class(CyclesLightSettings)
     bpy.utils.unregister_class(CyclesWorldSettings)
     bpy.utils.unregister_class(CyclesMeshSettings)
     bpy.utils.unregister_class(CyclesObjectSettings)
     bpy.utils.unregister_class(CyclesVisibilitySettings)
     bpy.utils.unregister_class(CyclesCurveRenderSettings)
-    bpy.utils.unregister_class(CyclesCurveSettings)
     bpy.utils.unregister_class(CyclesDeviceSettings)
     bpy.utils.unregister_class(CyclesPreferences)
     bpy.utils.unregister_class(CyclesRenderLayerSettings)