Merge branch 'blender2.7'
authorJeroen Bakker <j.bakker@atmind.nl>
Tue, 19 Feb 2019 07:05:15 +0000 (08:05 +0100)
committerJeroen Bakker <j.bakker@atmind.nl>
Tue, 19 Feb 2019 07:05:15 +0000 (08:05 +0100)
1  2 
intern/cycles/blender/addon/properties.py

@@@ -158,591 -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=False,
 -            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
 +    )
  
 -        cls.debug_use_opencl_debug = BoolProperty(name="Debug OpenCL", default=False)
 +    debug_opencl_kernel_single_program: BoolProperty(
 +        name="Single Program",
-         default=True,
++        default=False,
 +        update=_devices_update_callback,
 +    )
 +    del _devices_update_callback
 +
 +    debug_use_opencl_debug: BoolProperty(name="Debug OpenCL", default=False)
 +
 +    debug_opencl_mem_limit: IntProperty(
 +        name="Memory limit",
 +        default=0,
 +        description="Artificial limit on OpenCL memory usage in MB (0 to disable limit)"
 +    )
  
 -        cls.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):