intern/cycles/blender/addon/properties.py

   1 #
   2 # Copyright 2011-2013 Blender Foundation
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15 #
  16
  17 # <pep8 compliant>
  18
  19 import bpy
  20 from bpy.props import (BoolProperty,
  21                        EnumProperty,
  22                        FloatProperty,
  23                        IntProperty,
  24                        PointerProperty,
  25                        StringProperty)
  26
  27 # enums
  28
  29 import _cycles
  30
  31 enum_devices = (
  32     ('CPU', "CPU", "Use CPU for rendering"),
  33     ('GPU', "GPU Compute", "Use GPU compute device for rendering, configured in the system tab in the user preferences"),
  34     )
  35
  36 if _cycles.with_network:
  37     enum_devices += (('NETWORK', "Networked Device", "Use networked device for rendering"),)
  38
  39 enum_feature_set = (
  40     ('SUPPORTED', "Supported", "Only use finished and supported features"),
  41     ('EXPERIMENTAL', "Experimental", "Use experimental and incomplete features that might be broken or change in the future", 'ERROR', 1),
  42     )
  43
  44 enum_displacement_methods = (
  45     ('BUMP', "Bump", "Bump mapping to simulate the appearance of displacement"),
  46     ('TRUE', "True", "Use true displacement only, requires fine subdivision"),
  47     ('BOTH', "Both", "Combination of displacement and bump mapping"),
  48     )
  49
  50 enum_bvh_types = (
  51     ('DYNAMIC_BVH', "Dynamic BVH", "Objects can be individually updated, at the cost of slower render time"),
  52     ('STATIC_BVH', "Static BVH", "Any object modification requires a complete BVH rebuild, but renders faster"),
  53     )
  54
  55 enum_filter_types = (
  56     ('BOX', "Box", "Box filter"),
  57     ('GAUSSIAN', "Gaussian", "Gaussian filter"),
  58     ('BLACKMAN_HARRIS', "Blackman-Harris", "Blackman-Harris filter"),
  59     )
  60
  61 enum_aperture_types = (
  62     ('RADIUS', "Radius", "Directly change the size of the aperture"),
  63     ('FSTOP', "F-stop", "Change the size of the aperture by f-stop"),
  64     )
  65
  66 enum_panorama_types = (
  67     ('EQUIRECTANGULAR', "Equirectangular", "Render the scene with a spherical camera, also known as Lat Long panorama"),
  68     ('FISHEYE_EQUIDISTANT', "Fisheye Equidistant", "Ideal for fulldomes, ignore the sensor dimensions"),
  69     ('FISHEYE_EQUISOLID', "Fisheye Equisolid",
  70                           "Similar to most fisheye modern lens, takes sensor dimensions into consideration"),
  71     ('MIRRORBALL', "Mirror Ball", "Uses the mirror ball mapping"),
  72     )
  73
  74 enum_curve_primitives = (
  75     ('TRIANGLES', "Triangles", "Create triangle geometry around strands"),
  76     ('LINE_SEGMENTS', "Line Segments", "Use line segment primitives"),
  77     ('CURVE_SEGMENTS', "Curve Segments", "Use segmented cardinal curve primitives"),
  78     )
  79
  80 enum_triangle_curves = (
  81     ('CAMERA_TRIANGLES', "Planes", "Create individual triangles forming planes that face camera"),
  82     ('TESSELLATED_TRIANGLES', "Tessellated", "Create mesh surrounding each strand"),
  83     )
  84
  85 enum_curve_shape = (
  86     ('RIBBONS', "Ribbons", "Ignore thickness of each strand"),
  87     ('THICK', "Thick", "Use thickness of strand when rendering"),
  88     )
  89
  90 enum_tile_order = (
  91     ('CENTER', "Center", "Render from center to the edges"),
  92     ('RIGHT_TO_LEFT', "Right to Left", "Render from right to left"),
  93     ('LEFT_TO_RIGHT', "Left to Right", "Render from left to right"),
  94     ('TOP_TO_BOTTOM', "Top to Bottom", "Render from top to bottom"),
  95     ('BOTTOM_TO_TOP', "Bottom to Top", "Render from bottom to top"),
  96     ('HILBERT_SPIRAL', "Hilbert Spiral", "Render in a Hilbert Spiral"),
  97     )
  98
  99 enum_use_layer_samples = (
 100     ('USE', "Use", "Per render layer number of samples override scene samples"),
 101     ('BOUNDED', "Bounded", "Bound per render layer number of samples by global samples"),
 102     ('IGNORE', "Ignore", "Ignore per render layer number of samples"),
 103     )
 104
 105 enum_sampling_pattern = (
 106     ('SOBOL', "Sobol", "Use Sobol random sampling pattern"),
 107     ('CORRELATED_MUTI_JITTER', "Correlated Multi-Jitter", "Use Correlated Multi-Jitter random sampling pattern"),
 108     )
 109
 110 enum_integrator = (
 111     ('BRANCHED_PATH', "Branched Path Tracing", "Path tracing integrator that branches on the first bounce, giving more control over the number of light and material samples"),
 112     ('PATH', "Path Tracing", "Pure path tracing integrator"),
 113     )
 114
 115 enum_volume_sampling = (
 116     ('DISTANCE', "Distance", "Use distance sampling, best for dense volumes with lights far away"),
 117     ('EQUIANGULAR', "Equiangular", "Use equiangular sampling, best for volumes with low density with light inside or near the volume"),
 118     ('MULTIPLE_IMPORTANCE', "Multiple Importance", "Combine distance and equi-angular sampling for volumes where neither method is ideal"),
 119     )
 120
 121 enum_volume_interpolation = (
 122     ('LINEAR', "Linear", "Good smoothness and speed"),
 123     ('CUBIC', "Cubic", "Smoothed high quality interpolation, but slower")
 124     )
 125
 126 enum_device_type = (
 127     ('CPU', "CPU", "CPU", 0),
 128     ('CUDA', "CUDA", "CUDA", 1),
 129     ('OPENCL', "OpenCL", "OpenCL", 2)
 130     )
 131
 132 enum_texture_limit = (
 133     ('OFF', "No Limit", "No texture size limit", 0),
 134     ('128', "128", "Limit texture size to 128 pixels", 1),
 135     ('256', "256", "Limit texture size to 256 pixels", 2),
 136     ('512', "512", "Limit texture size to 512 pixels", 3),
 137     ('1024', "1024", "Limit texture size to 1024 pixels", 4),
 138     ('2048', "2048", "Limit texture size to 2048 pixels", 5),
 139     ('4096', "4096", "Limit texture size to 4096 pixels", 6),
 140     ('8192', "8192", "Limit texture size to 8192 pixels", 7),
 141     )
 142
 143 class CyclesRenderSettings(bpy.types.PropertyGroup):
 144     @classmethod
 145     def register(cls):
 146         bpy.types.Scene.cycles = PointerProperty(
 147                 name="Cycles Render Settings",
 148                 description="Cycles render settings",
 149                 type=cls,
 150                 )
 151         cls.device = EnumProperty(
 152                 name="Device",
 153                 description="Device to use for rendering",
 154                 items=enum_devices,
 155                 default='CPU',
 156                 )
 157         cls.feature_set = EnumProperty(
 158                 name="Feature Set",
 159                 description="Feature set to use for rendering",
 160                 items=enum_feature_set,
 161                 default='SUPPORTED',
 162                 )
 163         cls.shading_system = BoolProperty(
 164                 name="Open Shading Language",
 165                 description="Use Open Shading Language (CPU rendering only)",
 166                 )
 167
 168         cls.progressive = EnumProperty(
 169                 name="Integrator",
 170                 description="Method to sample lights and materials",
 171                 items=enum_integrator,
 172                 default='PATH',
 173                 )
 174
 175         cls.use_square_samples = BoolProperty(
 176                 name="Square Samples",
 177                 description="Square sampling values for easier artist control",
 178                 default=False,
 179                 )
 180
 181         cls.samples = IntProperty(
 182                 name="Samples",
 183                 description="Number of samples to render for each pixel",
 184                 min=1, max=2147483647,
 185                 default=128,
 186                 )
 187         cls.preview_samples = IntProperty(
 188                 name="Preview Samples",
 189                 description="Number of samples to render in the viewport, unlimited if 0",
 190                 min=0, max=2147483647,
 191                 default=32,
 192                 )
 193         cls.preview_pause = BoolProperty(
 194                 name="Pause Preview",
 195                 description="Pause all viewport preview renders",
 196                 default=False,
 197                 )
 198         cls.preview_active_layer = BoolProperty(
 199                 name="Preview Active Layer",
 200                 description="Preview active render layer in viewport",
 201                 default=False,
 202                 )
 203
 204         cls.aa_samples = IntProperty(
 205                 name="AA Samples",
 206                 description="Number of antialiasing samples to render for each pixel",
 207                 min=1, max=2097151,
 208                 default=4,
 209                 )
 210         cls.preview_aa_samples = IntProperty(
 211                 name="AA Samples",
 212                 description="Number of antialiasing samples to render in the viewport, unlimited if 0",
 213                 min=0, max=2097151,
 214                 default=4,
 215                 )
 216         cls.diffuse_samples = IntProperty(
 217                 name="Diffuse Samples",
 218                 description="Number of diffuse bounce samples to render for each AA sample",
 219                 min=1, max=1024,
 220                 default=1,
 221                 )
 222         cls.glossy_samples = IntProperty(
 223                 name="Glossy Samples",
 224                 description="Number of glossy bounce samples to render for each AA sample",
 225                 min=1, max=1024,
 226                 default=1,
 227                 )
 228         cls.transmission_samples = IntProperty(
 229                 name="Transmission Samples",
 230                 description="Number of transmission bounce samples to render for each AA sample",
 231                 min=1, max=1024,
 232                 default=1,
 233                 )
 234         cls.ao_samples = IntProperty(
 235                 name="Ambient Occlusion Samples",
 236                 description="Number of ambient occlusion samples to render for each AA sample",
 237                 min=1, max=1024,
 238                 default=1,
 239                 )
 240         cls.mesh_light_samples = IntProperty(
 241                 name="Mesh Light Samples",
 242                 description="Number of mesh emission light samples to render for each AA sample",
 243                 min=1, max=1024,
 244                 default=1,
 245                 )
 246
 247         cls.subsurface_samples = IntProperty(
 248                 name="Subsurface Samples",
 249                 description="Number of subsurface scattering samples to render for each AA sample",
 250                 min=1, max=1024,
 251                 default=1,
 252                 )
 253
 254         cls.volume_samples = IntProperty(
 255                 name="Volume Samples",
 256                 description="Number of volume scattering samples to render for each AA sample",
 257                 min=1, max=1024,
 258                 default=1,
 259                 )
 260
 261         cls.sampling_pattern = EnumProperty(
 262                 name="Sampling Pattern",
 263                 description="Random sampling pattern used by the integrator",
 264                 items=enum_sampling_pattern,
 265                 default='SOBOL',
 266                 )
 267
 268         cls.use_layer_samples = EnumProperty(
 269                 name="Layer Samples",
 270                 description="How to use per render layer sample settings",
 271                 items=enum_use_layer_samples,
 272                 default='USE',
 273                 )
 274
 275         cls.sample_all_lights_direct = BoolProperty(
 276                 name="Sample All Direct Lights",
 277                 description="Sample all lights (for direct samples), rather than randomly picking one",
 278                 default=True,
 279                 )
 280
 281         cls.sample_all_lights_indirect = BoolProperty(
 282                 name="Sample All Indirect Lights",
 283                 description="Sample all lights (for indirect samples), rather than randomly picking one",
 284                 default=True,
 285                 )
 286         cls.light_sampling_threshold = FloatProperty(
 287                 name="Light Sampling Threshold",
 288                 description="Probabilistically terminate light samples when the light contribution is below this threshold (more noise but faster rendering). "
 289                             "Zero disables the test and never ignores lights",
 290                 min=0.0, max=1.0,
 291                 default=0.01,
 292                 )
 293
 294         cls.caustics_reflective = BoolProperty(
 295                 name="Reflective Caustics",
 296                 description="Use reflective caustics, resulting in a brighter image (more noise but added realism)",
 297                 default=True,
 298                 )
 299
 300         cls.caustics_refractive = BoolProperty(
 301                 name="Refractive Caustics",
 302                 description="Use refractive caustics, resulting in a brighter image (more noise but added realism)",
 303                 default=True,
 304                 )
 305
 306         cls.blur_glossy = FloatProperty(
 307                 name="Filter Glossy",
 308                 description="Adaptively blur glossy shaders after blurry bounces, "
 309                             "to reduce noise at the cost of accuracy",
 310                 min=0.0, max=10.0,
 311                 default=0.0,
 312                 )
 313
 314         cls.min_bounces = IntProperty(
 315                 name="Min Bounces",
 316                 description="Minimum number of bounces, setting this lower "
 317                             "than the maximum enables probabilistic path "
 318                             "termination (faster but noisier)",
 319                 min=0, max=1024,
 320                 default=3,
 321                 )
 322         cls.max_bounces = IntProperty(
 323                 name="Max Bounces",
 324                 description="Total maximum number of bounces",
 325                 min=0, max=1024,
 326                 default=12,
 327                 )
 328
 329         cls.diffuse_bounces = IntProperty(
 330                 name="Diffuse Bounces",
 331                 description="Maximum number of diffuse reflection bounces, bounded by total maximum",
 332                 min=0, max=1024,
 333                 default=4,
 334                 )
 335         cls.glossy_bounces = IntProperty(
 336                 name="Glossy Bounces",
 337                 description="Maximum number of glossy reflection bounces, bounded by total maximum",
 338                 min=0, max=1024,
 339                 default=4,
 340                 )
 341         cls.transmission_bounces = IntProperty(
 342                 name="Transmission Bounces",
 343                 description="Maximum number of transmission bounces, bounded by total maximum",
 344                 min=0, max=1024,
 345                 default=12,
 346                 )
 347         cls.volume_bounces = IntProperty(
 348                 name="Volume Bounces",
 349                 description="Maximum number of volumetric scattering events",
 350                 min=0, max=1024,
 351                 default=0,
 352                 )
 353
 354         cls.transparent_min_bounces = IntProperty(
 355                 name="Transparent Min Bounces",
 356                 description="Minimum number of transparent bounces, setting "
 357                             "this lower than the maximum enables "
 358                             "probabilistic path termination (faster but "
 359                             "noisier)",
 360                 min=0, max=1024,
 361                 default=8,
 362                 )
 363         cls.transparent_max_bounces = IntProperty(
 364                 name="Transparent Max Bounces",
 365                 description="Maximum number of transparent bounces",
 366                 min=0, max=1024,
 367                 default=8,
 368                 )
 369         cls.use_transparent_shadows = BoolProperty(
 370                 name="Transparent Shadows",
 371                 description="Use transparency of surfaces for rendering shadows",
 372                 default=True,
 373                 )
 374
 375         cls.volume_step_size = FloatProperty(
 376                 name="Step Size",
 377                 description="Distance between volume shader samples when rendering the volume "
 378                             "(lower values give more accurate and detailed results, but also increased render time)",
 379                 default=0.1,
 380                 min=0.0000001, max=100000.0, soft_min=0.01, soft_max=1.0, precision=4
 381                 )
 382
 383         cls.volume_max_steps = IntProperty(
 384                 name="Max Steps",
 385                 description="Maximum number of steps through the volume before giving up, "
 386                             "to avoid extremely long render times with big objects or small step sizes",
 387                 default=1024,
 388                 min=2, max=65536
 389                 )
 390
 391         cls.dicing_rate = FloatProperty(
 392                 name="Dicing Rate",
 393                 description="Size of a micropolygon in pixels",
 394                 min=0.1, max=1000.0, soft_min=0.5,
 395                 default=1.0,
 396                 subtype="PIXEL"
 397                 )
 398         cls.preview_dicing_rate = FloatProperty(
 399                 name="Preview Dicing Rate",
 400                 description="Size of a micropolygon in pixels during preview render",
 401                 min=0.1, max=1000.0, soft_min=0.5,
 402                 default=8.0,
 403                 subtype="PIXEL"
 404                 )
 405
 406         cls.max_subdivisions = IntProperty(
 407                 name="Max Subdivisions",
 408                 description="Stop subdividing when this level is reached even if the dice rate would produce finer tessellation",
 409                 min=0, max=16,
 410                 default=12,
 411                 )
 412
 413         cls.film_exposure = FloatProperty(
 414                 name="Exposure",
 415                 description="Image brightness scale",
 416                 min=0.0, max=10.0,
 417                 default=1.0,
 418                 )
 419         cls.film_transparent = BoolProperty(
 420                 name="Transparent",
 421                 description="World background is transparent with premultiplied alpha",
 422                 default=False,
 423                 )
 424
 425         # Really annoyingly, we have to keep it around for a few releases,
 426         # otherwise forward compatibility breaks in really bad manner: CRASH!
 427         #
 428         # TODO(sergey): Remove this during 2.8x series of Blender.
 429         cls.filter_type = EnumProperty(
 430                 name="Filter Type",
 431                 description="Pixel filter type",
 432                 items=enum_filter_types,
 433                 default='BLACKMAN_HARRIS',
 434                 )
 435
 436         cls.pixel_filter_type = EnumProperty(
 437                 name="Filter Type",
 438                 description="Pixel filter type",
 439                 items=enum_filter_types,
 440                 default='BLACKMAN_HARRIS',
 441                 )
 442
 443         cls.filter_width = FloatProperty(
 444                 name="Filter Width",
 445                 description="Pixel filter width",
 446                 min=0.01, max=10.0,
 447                 default=1.5,
 448                 )
 449
 450         cls.seed = IntProperty(
 451                 name="Seed",
 452                 description="Seed value for integrator to get different noise patterns",
 453                 min=0, max=2147483647,
 454                 default=0,
 455                 )
 456
 457         cls.use_animated_seed = BoolProperty(
 458                 name="Use Animated Seed",
 459                 description="Use different seed values (and hence noise patterns) at different frames",
 460                 default=False,
 461                 )
 462
 463         cls.sample_clamp_direct = FloatProperty(
 464                 name="Clamp Direct",
 465                 description="If non-zero, the maximum value for a direct sample, "
 466                             "higher values will be scaled down to avoid too "
 467                             "much noise and slow convergence at the cost of accuracy",
 468                 min=0.0, max=1e8,
 469                 default=0.0,
 470                 )
 471
 472         cls.sample_clamp_indirect = FloatProperty(
 473                 name="Clamp Indirect",
 474                 description="If non-zero, the maximum value for an indirect sample, "
 475                             "higher values will be scaled down to avoid too "
 476                             "much noise and slow convergence at the cost of accuracy",
 477                 min=0.0, max=1e8,
 478                 default=0.0,
 479                 )
 480
 481         cls.debug_tile_size = IntProperty(
 482                 name="Tile Size",
 483                 description="",
 484                 min=1, max=4096,
 485                 default=1024,
 486                 )
 487
 488         cls.preview_start_resolution = IntProperty(
 489                 name="Start Resolution",
 490                 description="Resolution to start rendering preview at, "
 491                             "progressively increasing it to the full viewport size",
 492                 min=8, max=16384,
 493                 default=64,
 494                 )
 495
 496         cls.debug_reset_timeout = FloatProperty(
 497                 name="Reset timeout",
 498                 description="",
 499                 min=0.01, max=10.0,
 500                 default=0.1,
 501                 )
 502         cls.debug_cancel_timeout = FloatProperty(
 503                 name="Cancel timeout",
 504                 description="",
 505                 min=0.01, max=10.0,
 506                 default=0.1,
 507                 )
 508         cls.debug_text_timeout = FloatProperty(
 509                 name="Text timeout",
 510                 description="",
 511                 min=0.01, max=10.0,
 512                 default=1.0,
 513                 )
 514
 515         cls.debug_bvh_type = EnumProperty(
 516                 name="Viewport BVH Type",
 517                 description="Choose between faster updates, or faster render",
 518                 items=enum_bvh_types,
 519                 default='DYNAMIC_BVH',
 520                 )
 521         cls.debug_use_spatial_splits = BoolProperty(
 522                 name="Use Spatial Splits",
 523                 description="Use BVH spatial splits: longer builder time, faster render",
 524                 default=False,
 525                 )
 526         cls.debug_use_hair_bvh = BoolProperty(
 527                 name="Use Hair BVH",
 528                 description="Use special type BVH optimized for hair (uses more ram but renders faster)",
 529                 default=True,
 530                 )
 531         cls.debug_bvh_time_steps = IntProperty(
 532                 name="BVH Time Steps",
 533                 description="Split BVH primitives by this number of time steps to speed up render time in cost of memory",
 534                 default=0,
 535                 min=0, max=16,
 536                 )
 537         cls.tile_order = EnumProperty(
 538                 name="Tile Order",
 539                 description="Tile order for rendering",
 540                 items=enum_tile_order,
 541                 default='HILBERT_SPIRAL',
 542                 options=set(),  # Not animatable!
 543                 )
 544         cls.use_progressive_refine = BoolProperty(
 545                 name="Progressive Refine",
 546                 description="Instead of rendering each tile until it is finished, "
 547                             "refine the whole image progressively "
 548                             "(this renders somewhat slower, "
 549                             "but time can be saved by manually stopping the render when the noise is low enough)",
 550                 default=False,
 551                 )
 552
 553         cls.bake_type = EnumProperty(
 554             name="Bake Type",
 555             default='COMBINED',
 556             description="Type of pass to bake",
 557             items=(
 558                 ('COMBINED', "Combined", ""),
 559                 ('AO', "Ambient Occlusion", ""),
 560                 ('SHADOW', "Shadow", ""),
 561                 ('NORMAL', "Normal", ""),
 562                 ('UV', "UV", ""),
 563                 ('EMIT', "Emit", ""),
 564                 ('ENVIRONMENT', "Environment", ""),
 565                 ('DIFFUSE', "Diffuse", ""),
 566                 ('GLOSSY', "Glossy", ""),
 567                 ('TRANSMISSION', "Transmission", ""),
 568                 ('SUBSURFACE', "Subsurface", ""),
 569                 ),
 570             )
 571
 572         cls.use_camera_cull = BoolProperty(
 573                 name="Use Camera Cull",
 574                 description="Allow objects to be culled based on the camera frustum",
 575                 default=False,
 576                 )
 577
 578         cls.camera_cull_margin = FloatProperty(
 579                 name="Camera Cull Margin",
 580                 description="Margin for the camera space culling",
 581                 default=0.1,
 582                 min=0.0, max=5.0
 583                 )
 584
 585         cls.use_distance_cull = BoolProperty(
 586                 name="Use Distance Cull",
 587                 description="Allow objects to be culled based on the distance from camera",
 588                 default=False,
 589                 )
 590
 591         cls.distance_cull_margin = FloatProperty(
 592                 name="Cull Distance",
 593                 description="Cull objects which are further away from camera than this distance",
 594                 default=50,
 595                 min=0.0
 596                 )
 597
 598         cls.motion_blur_position = EnumProperty(
 599             name="Motion Blur Position",
 600             default='CENTER',
 601             description="Offset for the shutter's time interval, allows to change the motion blur trails",
 602             items=(
 603                 ('START', "Start on Frame", "The shutter opens at the current frame"),
 604                 ('CENTER', "Center on Frame", "The shutter is open during the current frame"),
 605                 ('END', "End on Frame", "The shutter closes at the current frame"),
 606                 ),
 607             )
 608
 609         cls.rolling_shutter_type = EnumProperty(
 610             name="Shutter Type",
 611             default='NONE',
 612             description="Type of rolling shutter effect matching CMOS-based cameras",
 613             items=(
 614                 ('NONE', "None", "No rolling shutter effect used"),
 615                 ('TOP', "Top-Bottom", "Sensor is being scanned from top to bottom")
 616                 # TODO(seergey): Are there real cameras with different scanning direction?
 617                 ),
 618             )
 619
 620         cls.rolling_shutter_duration = FloatProperty(
 621             name="Rolling Shutter Duration",
 622             description="Scanline \"exposure\" time for the rolling shutter effect",
 623             default=0.1,
 624             min=0.0, max=1.0,
 625             )
 626
 627         cls.texture_limit = EnumProperty(
 628             name="Viewport Texture Limit",
 629             default='OFF',
 630             description="Limit texture size used by viewport rendering",
 631             items=enum_texture_limit
 632             )
 633
 634         cls.texture_limit_render = EnumProperty(
 635             name="Render Texture Limit",
 636             default='OFF',
 637             description="Limit texture size used by final rendering",
 638             items=enum_texture_limit
 639             )
 640
 641         cls.ao_bounces = IntProperty(
 642             name="AO Bounces",
 643             default=0,
 644             description="Approximate indirect light with background tinted ambient occlusion at the specified bounce, 0 disables this feature",
 645             min=0, max=1024,
 646             )
 647
 648         cls.ao_bounces_render = IntProperty(
 649             name="AO Bounces Render",
 650             default=0,
 651             description="Approximate indirect light with background tinted ambient occlusion at the specified bounce, 0 disables this feature",
 652             min=0, max=1024,
 653             )
 654
 655         # Various fine-tuning debug flags
 656
 657         def devices_update_callback(self, context):
 658             import _cycles
 659             scene = context.scene.as_pointer()
 660             return _cycles.debug_flags_update(scene)
 661
 662         cls.debug_use_cpu_avx2 = BoolProperty(name="AVX2", default=True)
 663         cls.debug_use_cpu_avx = BoolProperty(name="AVX", default=True)
 664         cls.debug_use_cpu_sse41 = BoolProperty(name="SSE41", default=True)
 665         cls.debug_use_cpu_sse3 = BoolProperty(name="SSE3", default=True)
 666         cls.debug_use_cpu_sse2 = BoolProperty(name="SSE2", default=True)
 667         cls.debug_use_qbvh = BoolProperty(name="QBVH", default=True)
 668         cls.debug_use_cpu_split_kernel = BoolProperty(name="Split Kernel", default=False)
 669
 670         cls.debug_use_cuda_adaptive_compile = BoolProperty(name="Adaptive Compile", default=False)
 671         cls.debug_use_cuda_split_kernel = BoolProperty(name="Split Kernel", default=False)
 672
 673         cls.debug_opencl_kernel_type = EnumProperty(
 674             name="OpenCL Kernel Type",
 675             default='DEFAULT',
 676             items=(
 677                 ('DEFAULT', "Default", ""),
 678                 ('MEGA', "Mega", ""),
 679                 ('SPLIT', "Split", ""),
 680                 ),
 681             update=devices_update_callback
 682             )
 683
 684         cls.debug_opencl_device_type = EnumProperty(
 685             name="OpenCL Device Type",
 686             default='ALL',
 687             items=(
 688                 ('NONE', "None", ""),
 689                 ('ALL', "All", ""),
 690                 ('DEFAULT', "Default", ""),
 691                 ('CPU', "CPU", ""),
 692                 ('GPU', "GPU", ""),
 693                 ('ACCELERATOR', "Accelerator", ""),
 694                 ),
 695             update=devices_update_callback
 696             )
 697
 698         cls.debug_opencl_kernel_single_program = BoolProperty(name="Single Program", default=True, update=devices_update_callback);
 699
 700         cls.debug_use_opencl_debug = BoolProperty(name="Debug OpenCL", default=False)
 701
 702     @classmethod
 703     def unregister(cls):
 704         del bpy.types.Scene.cycles
 705
 706
 707 class CyclesCameraSettings(bpy.types.PropertyGroup):
 708     @classmethod
 709     def register(cls):
 710         import math
 711
 712         bpy.types.Camera.cycles = PointerProperty(
 713                 name="Cycles Camera Settings",
 714                 description="Cycles camera settings",
 715                 type=cls,
 716                 )
 717
 718         cls.aperture_type = EnumProperty(
 719                 name="Aperture Type",
 720                 description="Use f-stop number or aperture radius",
 721                 items=enum_aperture_types,
 722                 default='RADIUS',
 723                 )
 724         cls.aperture_fstop = FloatProperty(
 725                 name="Aperture f-stop",
 726                 description="F-stop ratio (lower numbers give more defocus, higher numbers give a sharper image)",
 727                 min=0.0, soft_min=0.1, soft_max=64.0,
 728                 default=5.6,
 729                 step=10,
 730                 precision=1,
 731                 )
 732         cls.aperture_size = FloatProperty(
 733                 name="Aperture Size",
 734                 description="Radius of the aperture for depth of field (higher values give more defocus)",
 735                 min=0.0, soft_max=10.0,
 736                 default=0.0,
 737                 step=1,
 738                 precision=4,
 739                 subtype='DISTANCE',
 740                 )
 741         cls.aperture_blades = IntProperty(
 742                 name="Aperture Blades",
 743                 description="Number of blades in aperture for polygonal bokeh (at least 3)",
 744                 min=0, max=100,
 745                 default=0,
 746                 )
 747         cls.aperture_rotation = FloatProperty(
 748                 name="Aperture Rotation",
 749                 description="Rotation of blades in aperture",
 750                 soft_min=-math.pi, soft_max=math.pi,
 751                 subtype='ANGLE',
 752                 default=0,
 753                 )
 754         cls.aperture_ratio = FloatProperty(
 755                 name="Aperture Ratio",
 756                 description="Distortion to simulate anamorphic lens bokeh",
 757                 min=0.01, soft_min=1.0, soft_max=2.0,
 758                 default=1.0,
 759                 precision=4,
 760                 )
 761         cls.panorama_type = EnumProperty(
 762                 name="Panorama Type",
 763                 description="Distortion to use for the calculation",
 764                 items=enum_panorama_types,
 765                 default='FISHEYE_EQUISOLID',
 766                 )
 767         cls.fisheye_fov = FloatProperty(
 768                 name="Field of View",
 769                 description="Field of view for the fisheye lens",
 770                 min=0.1745, soft_max=2.0 * math.pi, max=10.0 * math.pi,
 771                 subtype='ANGLE',
 772                 default=math.pi,
 773                 )
 774         cls.fisheye_lens = FloatProperty(
 775                 name="Fisheye Lens",
 776                 description="Lens focal length (mm)",
 777                 min=0.01, soft_max=15.0, max=100.0,
 778                 default=10.5,
 779                 )
 780         cls.latitude_min = FloatProperty(
 781                 name="Min Latitude",
 782                 description="Minimum latitude (vertical angle) for the equirectangular lens",
 783                 min=-0.5 * math.pi, max=0.5 * math.pi,
 784                 subtype='ANGLE',
 785                 default=-0.5 * math.pi,
 786                 )
 787         cls.latitude_max = FloatProperty(
 788                 name="Max Latitude",
 789                 description="Maximum latitude (vertical angle) for the equirectangular lens",
 790                 min=-0.5 * math.pi, max=0.5 * math.pi,
 791                 subtype='ANGLE',
 792                 default=0.5 * math.pi,
 793                 )
 794         cls.longitude_min = FloatProperty(
 795                 name="Min Longitude",
 796                 description="Minimum longitude (horizontal angle) for the equirectangular lens",
 797                 min=-math.pi, max=math.pi,
 798                 subtype='ANGLE',
 799                 default=-math.pi,
 800                 )
 801         cls.longitude_max = FloatProperty(
 802                 name="Max Longitude",
 803                 description="Maximum longitude (horizontal angle) for the equirectangular lens",
 804                 min=-math.pi, max=math.pi,
 805                 subtype='ANGLE',
 806                 default=math.pi,
 807                 )
 808
 809     @classmethod
 810     def unregister(cls):
 811         del bpy.types.Camera.cycles
 812
 813
 814 class CyclesMaterialSettings(bpy.types.PropertyGroup):
 815     @classmethod
 816     def register(cls):
 817         bpy.types.Material.cycles = PointerProperty(
 818                 name="Cycles Material Settings",
 819                 description="Cycles material settings",
 820                 type=cls,
 821                 )
 822         cls.sample_as_light = BoolProperty(
 823                 name="Multiple Importance Sample",
 824                 description="Use multiple importance sampling for this material, "
 825                             "disabling may reduce overall noise for large "
 826                             "objects that emit little light compared to other light sources",
 827                 default=True,
 828                 )
 829         cls.use_transparent_shadow = BoolProperty(
 830                 name="Transparent Shadows",
 831                 description="Use transparent shadows for this material if it contains a Transparent BSDF, "
 832                             "disabling will render faster but not give accurate shadows",
 833                 default=True,
 834                 )
 835         cls.homogeneous_volume = BoolProperty(
 836                 name="Homogeneous Volume",
 837                 description="When using volume rendering, assume volume has the same density everywhere "
 838                             "(not using any textures), for faster rendering",
 839                 default=False,
 840                 )
 841         cls.volume_sampling = EnumProperty(
 842                 name="Volume Sampling",
 843                 description="Sampling method to use for volumes",
 844                 items=enum_volume_sampling,
 845                 default='MULTIPLE_IMPORTANCE',
 846                 )
 847
 848         cls.volume_interpolation = EnumProperty(
 849                 name="Volume Interpolation",
 850                 description="Interpolation method to use for smoke/fire volumes",
 851                 items=enum_volume_interpolation,
 852                 default='LINEAR',
 853                 )
 854
 855         cls.displacement_method = EnumProperty(
 856                 name="Displacement Method",
 857                 description="Method to use for the displacement",
 858                 items=enum_displacement_methods,
 859                 default='BUMP',
 860                 )
 861
 862     @classmethod
 863     def unregister(cls):
 864         del bpy.types.Material.cycles
 865
 866
 867 class CyclesLampSettings(bpy.types.PropertyGroup):
 868     @classmethod
 869     def register(cls):
 870         bpy.types.Lamp.cycles = PointerProperty(
 871                 name="Cycles Lamp Settings",
 872                 description="Cycles lamp settings",
 873                 type=cls,
 874                 )
 875         cls.cast_shadow = BoolProperty(
 876                 name="Cast Shadow",
 877                 description="Lamp casts shadows",
 878                 default=True,
 879                 )
 880         cls.samples = IntProperty(
 881                 name="Samples",
 882                 description="Number of light samples to render for each AA sample",
 883                 min=1, max=10000,
 884                 default=1,
 885                 )
 886         cls.max_bounces = IntProperty(
 887                 name="Max Bounces",
 888                 description="Maximum number of bounces the light will contribute to the render",
 889                 min=0, max=1024,
 890                 default=1024,
 891                 )
 892         cls.use_multiple_importance_sampling = BoolProperty(
 893                 name="Multiple Importance Sample",
 894                 description="Use multiple importance sampling for the lamp, "
 895                             "reduces noise for area lamps and sharp glossy materials",
 896                 default=True,
 897                 )
 898         cls.is_portal = BoolProperty(
 899                 name="Is Portal",
 900                 description="Use this area lamp to guide sampling of the background, "
 901                             "note that this will make the lamp invisible",
 902                 default=False,
 903                 )
 904
 905     @classmethod
 906     def unregister(cls):
 907         del bpy.types.Lamp.cycles
 908
 909
 910 class CyclesWorldSettings(bpy.types.PropertyGroup):
 911     @classmethod
 912     def register(cls):
 913         bpy.types.World.cycles = PointerProperty(
 914                 name="Cycles World Settings",
 915                 description="Cycles world settings",
 916                 type=cls,
 917                 )
 918         cls.sample_as_light = BoolProperty(
 919                 name="Multiple Importance Sample",
 920                 description="Use multiple importance sampling for the environment, "
 921                             "enabling for non-solid colors is recommended",
 922                 default=True,
 923                 )
 924         cls.sample_map_resolution = IntProperty(
 925                 name="Map Resolution",
 926                 description="Importance map size is resolution x resolution; "
 927                             "higher values potentially produce less noise, at the cost of memory and speed",
 928                 min=4, max=8192,
 929                 default=1024,
 930                 )
 931         cls.samples = IntProperty(
 932                 name="Samples",
 933                 description="Number of light samples to render for each AA sample",
 934                 min=1, max=10000,
 935                 default=1,
 936                 )
 937         cls.max_bounces = IntProperty(
 938                 name="Max Bounces",
 939                 description="Maximum number of bounces the background light will contribute to the render",
 940                 min=0, max=1024,
 941                 default=1024,
 942                 )
 943         cls.homogeneous_volume = BoolProperty(
 944                 name="Homogeneous Volume",
 945                 description="When using volume rendering, assume volume has the same density everywhere"
 946                             "(not using any textures), for faster rendering",
 947                 default=False,
 948                 )
 949         cls.volume_sampling = EnumProperty(
 950                 name="Volume Sampling",
 951                 description="Sampling method to use for volumes",
 952                 items=enum_volume_sampling,
 953                 default='EQUIANGULAR',
 954                 )
 955
 956         cls.volume_interpolation = EnumProperty(
 957                 name="Volume Interpolation",
 958                 description="Interpolation method to use for volumes",
 959                 items=enum_volume_interpolation,
 960                 default='LINEAR',
 961                 )
 962
 963     @classmethod
 964     def unregister(cls):
 965         del bpy.types.World.cycles
 966
 967
 968 class CyclesVisibilitySettings(bpy.types.PropertyGroup):
 969     @classmethod
 970     def register(cls):
 971         bpy.types.Object.cycles_visibility = PointerProperty(
 972                 name="Cycles Visibility Settings",
 973                 description="Cycles visibility settings",
 974                 type=cls,
 975                 )
 976
 977         bpy.types.World.cycles_visibility = PointerProperty(
 978                 name="Cycles Visibility Settings",
 979                 description="Cycles visibility settings",
 980                 type=cls,
 981                 )
 982
 983         cls.camera = BoolProperty(
 984                 name="Camera",
 985                 description="Object visibility for camera rays",
 986                 default=True,
 987                 )
 988         cls.diffuse = BoolProperty(
 989                 name="Diffuse",
 990                 description="Object visibility for diffuse reflection rays",
 991                 default=True,
 992                 )
 993         cls.glossy = BoolProperty(
 994                 name="Glossy",
 995                 description="Object visibility for glossy reflection rays",
 996                 default=True,
 997                 )
 998         cls.transmission = BoolProperty(
 999                 name="Transmission",
1000                 description="Object visibility for transmission rays",
1001                 default=True,
1002                 )
1003         cls.shadow = BoolProperty(
1004                 name="Shadow",
1005                 description="Object visibility for shadow rays",
1006                 default=True,
1007                 )
1008         cls.scatter = BoolProperty(
1009                 name="Volume Scatter",
1010                 description="Object visibility for volume scatter rays",
1011                 default=True,
1012                 )
1013
1014     @classmethod
1015     def unregister(cls):
1016         del bpy.types.Object.cycles_visibility
1017         del bpy.types.World.cycles_visibility
1018
1019
1020 class CyclesMeshSettings(bpy.types.PropertyGroup):
1021     @classmethod
1022     def register(cls):
1023         bpy.types.Mesh.cycles = PointerProperty(
1024                 name="Cycles Mesh Settings",
1025                 description="Cycles mesh settings",
1026                 type=cls,
1027                 )
1028         bpy.types.Curve.cycles = PointerProperty(
1029                 name="Cycles Mesh Settings",
1030                 description="Cycles mesh settings",
1031                 type=cls,
1032                 )
1033         bpy.types.MetaBall.cycles = PointerProperty(
1034                 name="Cycles Mesh Settings",
1035                 description="Cycles mesh settings",
1036                 type=cls,
1037                 )
1038
1039     @classmethod
1040     def unregister(cls):
1041         del bpy.types.Mesh.cycles
1042         del bpy.types.Curve.cycles
1043         del bpy.types.MetaBall.cycles
1044
1045
1046 class CyclesObjectSettings(bpy.types.PropertyGroup):
1047     @classmethod
1048     def register(cls):
1049         bpy.types.Object.cycles = PointerProperty(
1050                 name="Cycles Object Settings",
1051                 description="Cycles object settings",
1052                 type=cls,
1053                 )
1054
1055         cls.use_motion_blur = BoolProperty(
1056                 name="Use Motion Blur",
1057                 description="Use motion blur for this object",
1058                 default=True,
1059                 )
1060
1061         cls.use_deform_motion = BoolProperty(
1062                 name="Use Deformation Motion",
1063                 description="Use deformation motion blur for this object",
1064                 default=True,
1065                 )
1066
1067         cls.motion_steps = IntProperty(
1068                 name="Motion Steps",
1069                 description="Control accuracy of deformation motion blur, more steps gives more memory usage (actual number of steps is 2^(steps - 1))",
1070                 min=1, soft_max=8,
1071                 default=1,
1072                 )
1073
1074         cls.use_camera_cull = BoolProperty(
1075                 name="Use Camera Cull",
1076                 description="Allow this object and its duplicators to be culled by camera space culling",
1077                 default=False,
1078                 )
1079
1080         cls.use_distance_cull = BoolProperty(
1081                 name="Use Distance Cull",
1082                 description="Allow this object and its duplicators to be culled by distance from camera",
1083                 default=False,
1084                 )
1085
1086         cls.use_adaptive_subdivision = BoolProperty(
1087                 name="Use Adaptive Subdivision",
1088                 description="Use adaptive render time subdivision",
1089                 default=False,
1090                 )
1091
1092         cls.dicing_rate = FloatProperty(
1093                 name="Dicing Scale",
1094                 description="Multiplier for scene dicing rate (located in the Geometry Panel)",
1095                 min=0.1, max=1000.0, soft_min=0.5,
1096                 default=1.0,
1097                 )
1098
1099         cls.is_shadow_catcher = BoolProperty(
1100                 name="Shadow Catcher",
1101                 description="Only render shadows on this object, for compositing renders into real footage",
1102                 default=False,
1103                 )
1104
1105     @classmethod
1106     def unregister(cls):
1107         del bpy.types.Object.cycles
1108
1109
1110 class CyclesCurveRenderSettings(bpy.types.PropertyGroup):
1111     @classmethod
1112     def register(cls):
1113         bpy.types.Scene.cycles_curves = PointerProperty(
1114                 name="Cycles Hair Rendering Settings",
1115                 description="Cycles hair rendering settings",
1116                 type=cls,
1117                 )
1118         cls.primitive = EnumProperty(
1119                 name="Primitive",
1120                 description="Type of primitive used for hair rendering",
1121                 items=enum_curve_primitives,
1122                 default='LINE_SEGMENTS',
1123                 )
1124         cls.shape = EnumProperty(
1125                 name="Shape",
1126                 description="Form of hair",
1127                 items=enum_curve_shape,
1128                 default='THICK',
1129                 )
1130         cls.cull_backfacing = BoolProperty(
1131                 name="Cull back-faces",
1132                 description="Do not test the back-face of each strand",
1133                 default=True,
1134                 )
1135         cls.use_curves = BoolProperty(
1136                 name="Use Cycles Hair Rendering",
1137                 description="Activate Cycles hair rendering for particle system",
1138                 default=True,
1139                 )
1140         cls.resolution = IntProperty(
1141                 name="Resolution",
1142                 description="Resolution of generated mesh",
1143                 min=3, max=64,
1144                 default=3,
1145                 )
1146         cls.minimum_width = FloatProperty(
1147                 name="Minimal width",
1148                 description="Minimal pixel width for strands (0 - deactivated)",
1149                 min=0.0, max=100.0,
1150                 default=0.0,
1151                 )
1152         cls.maximum_width = FloatProperty(
1153                 name="Maximal width",
1154                 description="Maximum extension that strand radius can be increased by",
1155                 min=0.0, max=100.0,
1156                 default=0.1,
1157                 )
1158         cls.subdivisions = IntProperty(
1159                 name="Subdivisions",
1160                 description="Number of subdivisions used in Cardinal curve intersection (power of 2)",
1161                 min=0, max=24,
1162                 default=4,
1163                 )
1164
1165     @classmethod
1166     def unregister(cls):
1167         del bpy.types.Scene.cycles_curves
1168
1169 class CyclesRenderLayerSettings(bpy.types.PropertyGroup):
1170     @classmethod
1171     def register(cls):
1172         bpy.types.SceneRenderLayer.cycles = PointerProperty(
1173                 name="Cycles SceneRenderLayer Settings",
1174                 description="Cycles SceneRenderLayer Settings",
1175                 type=cls,
1176                 )
1177         cls.pass_debug_bvh_traversed_nodes = BoolProperty(
1178                 name="Debug BVH Traversed Nodes",
1179                 description="Store Debug BVH Traversed Nodes pass",
1180                 default=False,
1181                 )
1182         cls.pass_debug_bvh_traversed_instances = BoolProperty(
1183                 name="Debug BVH Traversed Instances",
1184                 description="Store Debug BVH Traversed Instances pass",
1185                 default=False,
1186                 )
1187         cls.pass_debug_bvh_intersections = BoolProperty(
1188                 name="Debug BVH Intersections",
1189                 description="Store Debug BVH Intersections",
1190                 default=False,
1191                 )
1192         cls.pass_debug_ray_bounces = BoolProperty(
1193                 name="Debug Ray Bounces",
1194                 description="Store Debug Ray Bounces pass",
1195                 default=False,
1196                 )
1197
1198         cls.use_denoising = BoolProperty(
1199                 name="Use Denoising",
1200                 description="Denoise the rendered image",
1201                 default=False,
1202                 )
1203         cls.denoising_diffuse_direct = BoolProperty(
1204                 name="Diffuse Direct",
1205                 description="Denoise the direct diffuse lighting",
1206                 default=True,
1207                 )
1208         cls.denoising_diffuse_indirect = BoolProperty(
1209                 name="Diffuse Indirect",
1210                 description="Denoise the indirect diffuse lighting",
1211                 default=True,
1212                 )
1213         cls.denoising_glossy_direct = BoolProperty(
1214                 name="Glossy Direct",
1215                 description="Denoise the direct glossy lighting",
1216                 default=True,
1217                 )
1218         cls.denoising_glossy_indirect = BoolProperty(
1219                 name="Glossy Indirect",
1220                 description="Denoise the indirect glossy lighting",
1221                 default=True,
1222                 )
1223         cls.denoising_transmission_direct = BoolProperty(
1224                 name="Transmission Direct",
1225                 description="Denoise the direct transmission lighting",
1226                 default=True,
1227                 )
1228         cls.denoising_transmission_indirect = BoolProperty(
1229                 name="Transmission Indirect",
1230                 description="Denoise the indirect transmission lighting",
1231                 default=True,
1232                 )
1233         cls.denoising_subsurface_direct = BoolProperty(
1234                 name="Subsurface Direct",
1235                 description="Denoise the direct subsurface lighting",
1236                 default=True,
1237                 )
1238         cls.denoising_subsurface_indirect = BoolProperty(
1239                 name="Subsurface Indirect",
1240                 description="Denoise the indirect subsurface lighting",
1241                 default=True,
1242                 )
1243         cls.denoising_strength = FloatProperty(
1244                 name="Denoising Strength",
1245                 description="Controls neighbor pixel weighting for the denoising filter (lower values preserve more detail, but aren't as smooth)",
1246                 min=0.0, max=1.0,
1247                 default=0.5,
1248                 )
1249         cls.denoising_feature_strength = FloatProperty(
1250                 name="Denoising Feature Strength",
1251                 description="Controls removal of noisy image feature passes (lower values preserve more detail, but aren't as smooth)",
1252                 min=0.0, max=1.0,
1253                 default=0.5,
1254                 )
1255         cls.denoising_radius = IntProperty(
1256                 name="Denoising Radius",
1257                 description="Size of the image area that's used to denoise a pixel (higher values are smoother, but might lose detail and are slower)",
1258                 min=1, max=50,
1259                 default=8,
1260         )
1261         cls.denoising_relative_pca = BoolProperty(
1262                 name="Relative filter",
1263                 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)",
1264                 default=False,
1265         )
1266         cls.denoising_store_passes = BoolProperty(
1267                 name="Store denoising passes",
1268                 description="Store the denoising feature passes and the noisy image",
1269                 default=False,
1270         )
1271
1272     @classmethod
1273     def unregister(cls):
1274         del bpy.types.SceneRenderLayer.cycles
1275
1276
1277 class CyclesCurveSettings(bpy.types.PropertyGroup):
1278     @classmethod
1279     def register(cls):
1280         bpy.types.ParticleSettings.cycles = PointerProperty(
1281                 name="Cycles Hair Settings",
1282                 description="Cycles hair settings",
1283                 type=cls,
1284                 )
1285         cls.radius_scale = FloatProperty(
1286                 name="Radius Scaling",
1287                 description="Multiplier of width properties",
1288                 min=0.0, max=1000.0,
1289                 default=0.01,
1290                 )
1291         cls.root_width = FloatProperty(
1292                 name="Root Size",
1293                 description="Strand's width at root",
1294                 min=0.0, max=1000.0,
1295                 default=1.0,
1296                 )
1297         cls.tip_width = FloatProperty(
1298                 name="Tip Multiplier",
1299                 description="Strand's width at tip",
1300                 min=0.0, max=1000.0,
1301                 default=0.0,
1302                 )
1303         cls.shape = FloatProperty(
1304                 name="Strand Shape",
1305                 description="Strand shape parameter",
1306                 min=-1.0, max=1.0,
1307                 default=0.0,
1308                 )
1309         cls.use_closetip = BoolProperty(
1310                 name="Close tip",
1311                 description="Set tip radius to zero",
1312                 default=True,
1313                 )
1314
1315     @classmethod
1316     def unregister(cls):
1317         del bpy.types.ParticleSettings.cycles
1318
1319
1320 class CyclesDeviceSettings(bpy.types.PropertyGroup):
1321     @classmethod
1322     def register(cls):
1323         cls.id = StringProperty(name="ID")
1324         cls.name = StringProperty(name="Name")
1325         cls.use = BoolProperty(name="Use", default=True)
1326         cls.type = EnumProperty(name="Type", items=enum_device_type, default='CUDA')
1327
1328
1329 class CyclesPreferences(bpy.types.AddonPreferences):
1330     bl_idname = __package__
1331
1332     def get_device_types(self, context):
1333         import _cycles
1334         has_cuda, has_opencl = _cycles.get_device_types()
1335         list = [('NONE', "None", "Don't use compute device", 0)]
1336         if has_cuda:
1337             list.append(('CUDA', "CUDA", "Use CUDA for GPU acceleration", 1))
1338         if has_opencl:
1339             list.append(('OPENCL', "OpenCL", "Use OpenCL for GPU acceleration", 2))
1340         return list
1341
1342     compute_device_type = EnumProperty(
1343             name="Compute Device Type",
1344             description="Device to use for computation (rendering with Cycles)",
1345             items=get_device_types,
1346             )
1347
1348     devices = bpy.props.CollectionProperty(type=CyclesDeviceSettings)
1349
1350     def get_devices(self):
1351         import _cycles
1352         # Layout of the device tuples: (Name, Type, Persistent ID)
1353         device_list = _cycles.available_devices()
1354
1355         cuda_devices = []
1356         opencl_devices = []
1357         for device in device_list:
1358             if not device[1] in {'CUDA', 'OPENCL'}:
1359                 continue
1360
1361             entry = None
1362             # Try to find existing Device entry
1363             for dev in self.devices:
1364                 if dev.id == device[2] and dev.type == device[1]:
1365                     entry = dev
1366                     break
1367             # Create new entry if no existing one was found
1368             if not entry:
1369                 entry = self.devices.add()
1370                 entry.id   = device[2]
1371                 entry.name = device[0]
1372                 entry.type = device[1]
1373
1374             # Sort entries into lists
1375             if entry.type == 'CUDA':
1376                 cuda_devices.append(entry)
1377             elif entry.type == 'OPENCL':
1378                 opencl_devices.append(entry)
1379         return cuda_devices, opencl_devices
1380
1381
1382     def get_num_gpu_devices(self):
1383         import _cycles
1384         device_list = _cycles.available_devices()
1385         num = 0
1386         for device in device_list:
1387             if device[1] != self.compute_device_type:
1388                 continue
1389             for dev in self.devices:
1390                 if dev.use and dev.id == device[2]:
1391                     num += 1
1392         return num
1393
1394
1395     def has_active_device(self):
1396         return self.get_num_gpu_devices() > 0
1397
1398
1399     def draw_impl(self, layout, context):
1400         layout.label(text="Cycles Compute Device:")
1401         layout.row().prop(self, "compute_device_type", expand=True)
1402
1403         cuda_devices, opencl_devices = self.get_devices()
1404         row = layout.row()
1405
1406         if self.compute_device_type == 'CUDA' and cuda_devices:
1407             box = row.box()
1408             for device in cuda_devices:
1409                 box.prop(device, "use", text=device.name)
1410
1411         if self.compute_device_type == 'OPENCL' and opencl_devices:
1412             box = row.box()
1413             for device in opencl_devices:
1414                 box.prop(device, "use", text=device.name)
1415
1416
1417     def draw(self, context):
1418         self.draw_impl(self.layout, context)
1419
1420
1421 def register():
1422     bpy.utils.register_class(CyclesRenderSettings)
1423     bpy.utils.register_class(CyclesCameraSettings)
1424     bpy.utils.register_class(CyclesMaterialSettings)
1425     bpy.utils.register_class(CyclesLampSettings)
1426     bpy.utils.register_class(CyclesWorldSettings)
1427     bpy.utils.register_class(CyclesVisibilitySettings)
1428     bpy.utils.register_class(CyclesMeshSettings)
1429     bpy.utils.register_class(CyclesObjectSettings)
1430     bpy.utils.register_class(CyclesCurveRenderSettings)
1431     bpy.utils.register_class(CyclesCurveSettings)
1432     bpy.utils.register_class(CyclesDeviceSettings)
1433     bpy.utils.register_class(CyclesPreferences)
1434     bpy.utils.register_class(CyclesRenderLayerSettings)
1435
1436
1437 def unregister():
1438     bpy.utils.unregister_class(CyclesRenderSettings)
1439     bpy.utils.unregister_class(CyclesCameraSettings)
1440     bpy.utils.unregister_class(CyclesMaterialSettings)
1441     bpy.utils.unregister_class(CyclesLampSettings)
1442     bpy.utils.unregister_class(CyclesWorldSettings)
1443     bpy.utils.unregister_class(CyclesMeshSettings)
1444     bpy.utils.unregister_class(CyclesObjectSettings)
1445     bpy.utils.unregister_class(CyclesVisibilitySettings)
1446     bpy.utils.unregister_class(CyclesCurveRenderSettings)
1447     bpy.utils.unregister_class(CyclesCurveSettings)
1448     bpy.utils.unregister_class(CyclesDeviceSettings)
1449     bpy.utils.unregister_class(CyclesPreferences)
1450     bpy.utils.unregister_class(CyclesRenderLayerSettings)