Fix T50116: Light threshold broke branched path tracer
[blender-staging.git] / 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.tile_order = EnumProperty(
532                 name="Tile Order",
533                 description="Tile order for rendering",
534                 items=enum_tile_order,
535                 default='HILBERT_SPIRAL',
536                 options=set(),  # Not animatable!
537                 )
538         cls.use_progressive_refine = BoolProperty(
539                 name="Progressive Refine",
540                 description="Instead of rendering each tile until it is finished, "
541                             "refine the whole image progressively "
542                             "(this renders somewhat slower, "
543                             "but time can be saved by manually stopping the render when the noise is low enough)",
544                 default=False,
545                 )
546
547         cls.bake_type = EnumProperty(
548             name="Bake Type",
549             default='COMBINED',
550             description="Type of pass to bake",
551             items=(
552                 ('COMBINED', "Combined", ""),
553                 ('AO', "Ambient Occlusion", ""),
554                 ('SHADOW', "Shadow", ""),
555                 ('NORMAL', "Normal", ""),
556                 ('UV', "UV", ""),
557                 ('EMIT', "Emit", ""),
558                 ('ENVIRONMENT', "Environment", ""),
559                 ('DIFFUSE', "Diffuse", ""),
560                 ('GLOSSY', "Glossy", ""),
561                 ('TRANSMISSION', "Transmission", ""),
562                 ('SUBSURFACE', "Subsurface", ""),
563                 ),
564             )
565
566         cls.use_camera_cull = BoolProperty(
567                 name="Use Camera Cull",
568                 description="Allow objects to be culled based on the camera frustum",
569                 default=False,
570                 )
571
572         cls.camera_cull_margin = FloatProperty(
573                 name="Camera Cull Margin",
574                 description="Margin for the camera space culling",
575                 default=0.1,
576                 min=0.0, max=5.0
577                 )
578
579         cls.use_distance_cull = BoolProperty(
580                 name="Use Distance Cull",
581                 description="Allow objects to be culled based on the distance from camera",
582                 default=False,
583                 )
584
585         cls.distance_cull_margin = FloatProperty(
586                 name="Cull Distance",
587                 description="Cull objects which are further away from camera than this distance",
588                 default=50,
589                 min=0.0
590                 )
591
592         cls.motion_blur_position = EnumProperty(
593             name="Motion Blur Position",
594             default='CENTER',
595             description="Offset for the shutter's time interval, allows to change the motion blur trails",
596             items=(
597                 ('START', "Start on Frame", "The shutter opens at the current frame"),
598                 ('CENTER', "Center on Frame", "The shutter is open during the current frame"),
599                 ('END', "End on Frame", "The shutter closes at the current frame"),
600                 ),
601             )
602
603         cls.rolling_shutter_type = EnumProperty(
604             name="Shutter Type",
605             default='NONE',
606             description="Type of rolling shutter effect matching CMOS-based cameras",
607             items=(
608                 ('NONE', "None", "No rolling shutter effect used"),
609                 ('TOP', "Top-Bottom", "Sensor is being scanned from top to bottom")
610                 # TODO(seergey): Are there real cameras with different scanning direction?
611                 ),
612             )
613
614         cls.rolling_shutter_duration = FloatProperty(
615             name="Rolling Shutter Duration",
616             description="Scanline \"exposure\" time for the rolling shutter effect",
617             default=0.1,
618             min=0.0, max=1.0,
619             )
620
621         cls.texture_limit = EnumProperty(
622             name="Viewport Texture Limit",
623             default='OFF',
624             description="Limit texture size used by viewport rendering",
625             items=enum_texture_limit
626             )
627
628         cls.texture_limit_render = EnumProperty(
629             name="Render Texture Limit",
630             default='OFF',
631             description="Limit texture size used by final rendering",
632             items=enum_texture_limit
633             )
634
635         # Various fine-tuning debug flags
636
637         def devices_update_callback(self, context):
638             import _cycles
639             scene = context.scene.as_pointer()
640             return _cycles.debug_flags_update(scene)
641
642         cls.debug_use_cpu_avx2 = BoolProperty(name="AVX2", default=True)
643         cls.debug_use_cpu_avx = BoolProperty(name="AVX", default=True)
644         cls.debug_use_cpu_sse41 = BoolProperty(name="SSE41", default=True)
645         cls.debug_use_cpu_sse3 = BoolProperty(name="SSE3", default=True)
646         cls.debug_use_cpu_sse2 = BoolProperty(name="SSE2", default=True)
647         cls.debug_use_qbvh = BoolProperty(name="QBVH", default=True)
648
649         cls.debug_use_cuda_adaptive_compile = BoolProperty(name="Adaptive Compile", default=False)
650
651         cls.debug_opencl_kernel_type = EnumProperty(
652             name="OpenCL Kernel Type",
653             default='DEFAULT',
654             items=(
655                 ('DEFAULT', "Default", ""),
656                 ('MEGA', "Mega", ""),
657                 ('SPLIT', "Split", ""),
658                 ),
659             update=devices_update_callback
660             )
661
662         cls.debug_opencl_device_type = EnumProperty(
663             name="OpenCL Device Type",
664             default='ALL',
665             items=(
666                 ('NONE', "None", ""),
667                 ('ALL', "All", ""),
668                 ('DEFAULT', "Default", ""),
669                 ('CPU', "CPU", ""),
670                 ('GPU', "GPU", ""),
671                 ('ACCELERATOR', "Accelerator", ""),
672                 ),
673             update=devices_update_callback
674             )
675
676         cls.debug_use_opencl_debug = BoolProperty(name="Debug OpenCL", default=False)
677
678     @classmethod
679     def unregister(cls):
680         del bpy.types.Scene.cycles
681
682
683 class CyclesCameraSettings(bpy.types.PropertyGroup):
684     @classmethod
685     def register(cls):
686         import math
687
688         bpy.types.Camera.cycles = PointerProperty(
689                 name="Cycles Camera Settings",
690                 description="Cycles camera settings",
691                 type=cls,
692                 )
693
694         cls.aperture_type = EnumProperty(
695                 name="Aperture Type",
696                 description="Use f-stop number or aperture radius",
697                 items=enum_aperture_types,
698                 default='RADIUS',
699                 )
700         cls.aperture_fstop = FloatProperty(
701                 name="Aperture f-stop",
702                 description="F-stop ratio (lower numbers give more defocus, higher numbers give a sharper image)",
703                 min=0.0, soft_min=0.1, soft_max=64.0,
704                 default=5.6,
705                 step=10,
706                 precision=1,
707                 )
708         cls.aperture_size = FloatProperty(
709                 name="Aperture Size",
710                 description="Radius of the aperture for depth of field (higher values give more defocus)",
711                 min=0.0, soft_max=10.0,
712                 default=0.0,
713                 step=1,
714                 precision=4,
715                 subtype='DISTANCE',
716                 )
717         cls.aperture_blades = IntProperty(
718                 name="Aperture Blades",
719                 description="Number of blades in aperture for polygonal bokeh (at least 3)",
720                 min=0, max=100,
721                 default=0,
722                 )
723         cls.aperture_rotation = FloatProperty(
724                 name="Aperture Rotation",
725                 description="Rotation of blades in aperture",
726                 soft_min=-math.pi, soft_max=math.pi,
727                 subtype='ANGLE',
728                 default=0,
729                 )
730         cls.aperture_ratio = FloatProperty(
731                 name="Aperture Ratio",
732                 description="Distortion to simulate anamorphic lens bokeh",
733                 min=0.01, soft_min=1.0, soft_max=2.0,
734                 default=1.0,
735                 precision=4,
736                 )
737         cls.panorama_type = EnumProperty(
738                 name="Panorama Type",
739                 description="Distortion to use for the calculation",
740                 items=enum_panorama_types,
741                 default='FISHEYE_EQUISOLID',
742                 )
743         cls.fisheye_fov = FloatProperty(
744                 name="Field of View",
745                 description="Field of view for the fisheye lens",
746                 min=0.1745, soft_max=2.0 * math.pi, max=10.0 * math.pi,
747                 subtype='ANGLE',
748                 default=math.pi,
749                 )
750         cls.fisheye_lens = FloatProperty(
751                 name="Fisheye Lens",
752                 description="Lens focal length (mm)",
753                 min=0.01, soft_max=15.0, max=100.0,
754                 default=10.5,
755                 )
756         cls.latitude_min = FloatProperty(
757                 name="Min Latitude",
758                 description="Minimum latitude (vertical angle) for the equirectangular lens",
759                 min=-0.5 * math.pi, max=0.5 * math.pi,
760                 subtype='ANGLE',
761                 default=-0.5 * math.pi,
762                 )
763         cls.latitude_max = FloatProperty(
764                 name="Max Latitude",
765                 description="Maximum latitude (vertical angle) for the equirectangular lens",
766                 min=-0.5 * math.pi, max=0.5 * math.pi,
767                 subtype='ANGLE',
768                 default=0.5 * math.pi,
769                 )
770         cls.longitude_min = FloatProperty(
771                 name="Min Longitude",
772                 description="Minimum longitude (horizontal angle) for the equirectangular lens",
773                 min=-math.pi, max=math.pi,
774                 subtype='ANGLE',
775                 default=-math.pi,
776                 )
777         cls.longitude_max = FloatProperty(
778                 name="Max Longitude",
779                 description="Maximum longitude (horizontal angle) for the equirectangular lens",
780                 min=-math.pi, max=math.pi,
781                 subtype='ANGLE',
782                 default=math.pi,
783                 )
784
785     @classmethod
786     def unregister(cls):
787         del bpy.types.Camera.cycles
788
789
790 class CyclesMaterialSettings(bpy.types.PropertyGroup):
791     @classmethod
792     def register(cls):
793         bpy.types.Material.cycles = PointerProperty(
794                 name="Cycles Material Settings",
795                 description="Cycles material settings",
796                 type=cls,
797                 )
798         cls.sample_as_light = BoolProperty(
799                 name="Multiple Importance Sample",
800                 description="Use multiple importance sampling for this material, "
801                             "disabling may reduce overall noise for large "
802                             "objects that emit little light compared to other light sources",
803                 default=True,
804                 )
805         cls.use_transparent_shadow = BoolProperty(
806                 name="Transparent Shadows",
807                 description="Use transparent shadows for this material if it contains a Transparent BSDF, "
808                             "disabling will render faster but not give accurate shadows",
809                 default=True,
810                 )
811         cls.homogeneous_volume = BoolProperty(
812                 name="Homogeneous Volume",
813                 description="When using volume rendering, assume volume has the same density everywhere "
814                             "(not using any textures), for faster rendering",
815                 default=False,
816                 )
817         cls.volume_sampling = EnumProperty(
818                 name="Volume Sampling",
819                 description="Sampling method to use for volumes",
820                 items=enum_volume_sampling,
821                 default='MULTIPLE_IMPORTANCE',
822                 )
823
824         cls.volume_interpolation = EnumProperty(
825                 name="Volume Interpolation",
826                 description="Interpolation method to use for smoke/fire volumes",
827                 items=enum_volume_interpolation,
828                 default='LINEAR',
829                 )
830
831         cls.displacement_method = EnumProperty(
832                 name="Displacement Method",
833                 description="Method to use for the displacement",
834                 items=enum_displacement_methods,
835                 default='BUMP',
836                 )
837
838     @classmethod
839     def unregister(cls):
840         del bpy.types.Material.cycles
841
842
843 class CyclesLampSettings(bpy.types.PropertyGroup):
844     @classmethod
845     def register(cls):
846         bpy.types.Lamp.cycles = PointerProperty(
847                 name="Cycles Lamp Settings",
848                 description="Cycles lamp settings",
849                 type=cls,
850                 )
851         cls.cast_shadow = BoolProperty(
852                 name="Cast Shadow",
853                 description="Lamp casts shadows",
854                 default=True,
855                 )
856         cls.samples = IntProperty(
857                 name="Samples",
858                 description="Number of light samples to render for each AA sample",
859                 min=1, max=10000,
860                 default=1,
861                 )
862         cls.max_bounces = IntProperty(
863                 name="Max Bounces",
864                 description="Maximum number of bounces the light will contribute to the render",
865                 min=0, max=1024,
866                 default=1024,
867                 )
868         cls.use_multiple_importance_sampling = BoolProperty(
869                 name="Multiple Importance Sample",
870                 description="Use multiple importance sampling for the lamp, "
871                             "reduces noise for area lamps and sharp glossy materials",
872                 default=True,
873                 )
874         cls.is_portal = BoolProperty(
875                 name="Is Portal",
876                 description="Use this area lamp to guide sampling of the background, "
877                             "note that this will make the lamp invisible",
878                 default=False,
879                 )
880
881     @classmethod
882     def unregister(cls):
883         del bpy.types.Lamp.cycles
884
885
886 class CyclesWorldSettings(bpy.types.PropertyGroup):
887     @classmethod
888     def register(cls):
889         bpy.types.World.cycles = PointerProperty(
890                 name="Cycles World Settings",
891                 description="Cycles world settings",
892                 type=cls,
893                 )
894         cls.sample_as_light = BoolProperty(
895                 name="Multiple Importance Sample",
896                 description="Use multiple importance sampling for the environment, "
897                             "enabling for non-solid colors is recommended",
898                 default=True,
899                 )
900         cls.sample_map_resolution = IntProperty(
901                 name="Map Resolution",
902                 description="Importance map size is resolution x resolution; "
903                             "higher values potentially produce less noise, at the cost of memory and speed",
904                 min=4, max=8192,
905                 default=1024,
906                 )
907         cls.samples = IntProperty(
908                 name="Samples",
909                 description="Number of light samples to render for each AA sample",
910                 min=1, max=10000,
911                 default=1,
912                 )
913         cls.max_bounces = IntProperty(
914                 name="Max Bounces",
915                 description="Maximum number of bounces the background light will contribute to the render",
916                 min=0, max=1024,
917                 default=1024,
918                 )
919         cls.homogeneous_volume = BoolProperty(
920                 name="Homogeneous Volume",
921                 description="When using volume rendering, assume volume has the same density everywhere"
922                             "(not using any textures), for faster rendering",
923                 default=False,
924                 )
925         cls.volume_sampling = EnumProperty(
926                 name="Volume Sampling",
927                 description="Sampling method to use for volumes",
928                 items=enum_volume_sampling,
929                 default='EQUIANGULAR',
930                 )
931
932         cls.volume_interpolation = EnumProperty(
933                 name="Volume Interpolation",
934                 description="Interpolation method to use for volumes",
935                 items=enum_volume_interpolation,
936                 default='LINEAR',
937                 )
938
939     @classmethod
940     def unregister(cls):
941         del bpy.types.World.cycles
942
943
944 class CyclesVisibilitySettings(bpy.types.PropertyGroup):
945     @classmethod
946     def register(cls):
947         bpy.types.Object.cycles_visibility = PointerProperty(
948                 name="Cycles Visibility Settings",
949                 description="Cycles visibility settings",
950                 type=cls,
951                 )
952
953         bpy.types.World.cycles_visibility = PointerProperty(
954                 name="Cycles Visibility Settings",
955                 description="Cycles visibility settings",
956                 type=cls,
957                 )
958
959         cls.camera = BoolProperty(
960                 name="Camera",
961                 description="Object visibility for camera rays",
962                 default=True,
963                 )
964         cls.diffuse = BoolProperty(
965                 name="Diffuse",
966                 description="Object visibility for diffuse reflection rays",
967                 default=True,
968                 )
969         cls.glossy = BoolProperty(
970                 name="Glossy",
971                 description="Object visibility for glossy reflection rays",
972                 default=True,
973                 )
974         cls.transmission = BoolProperty(
975                 name="Transmission",
976                 description="Object visibility for transmission rays",
977                 default=True,
978                 )
979         cls.shadow = BoolProperty(
980                 name="Shadow",
981                 description="Object visibility for shadow rays",
982                 default=True,
983                 )
984         cls.scatter = BoolProperty(
985                 name="Volume Scatter",
986                 description="Object visibility for volume scatter rays",
987                 default=True,
988                 )
989
990     @classmethod
991     def unregister(cls):
992         del bpy.types.Object.cycles_visibility
993         del bpy.types.World.cycles_visibility
994
995
996 class CyclesMeshSettings(bpy.types.PropertyGroup):
997     @classmethod
998     def register(cls):
999         bpy.types.Mesh.cycles = PointerProperty(
1000                 name="Cycles Mesh Settings",
1001                 description="Cycles mesh settings",
1002                 type=cls,
1003                 )
1004         bpy.types.Curve.cycles = PointerProperty(
1005                 name="Cycles Mesh Settings",
1006                 description="Cycles mesh settings",
1007                 type=cls,
1008                 )
1009         bpy.types.MetaBall.cycles = PointerProperty(
1010                 name="Cycles Mesh Settings",
1011                 description="Cycles mesh settings",
1012                 type=cls,
1013                 )
1014
1015     @classmethod
1016     def unregister(cls):
1017         del bpy.types.Mesh.cycles
1018         del bpy.types.Curve.cycles
1019         del bpy.types.MetaBall.cycles
1020
1021
1022 class CyclesObjectSettings(bpy.types.PropertyGroup):
1023     @classmethod
1024     def register(cls):
1025         bpy.types.Object.cycles = PointerProperty(
1026                 name="Cycles Object Settings",
1027                 description="Cycles object settings",
1028                 type=cls,
1029                 )
1030
1031         cls.use_motion_blur = BoolProperty(
1032                 name="Use Motion Blur",
1033                 description="Use motion blur for this object",
1034                 default=True,
1035                 )
1036
1037         cls.use_deform_motion = BoolProperty(
1038                 name="Use Deformation Motion",
1039                 description="Use deformation motion blur for this object",
1040                 default=True,
1041                 )
1042
1043         cls.motion_steps = IntProperty(
1044                 name="Motion Steps",
1045                 description="Control accuracy of deformation motion blur, more steps gives more memory usage (actual number of steps is 2^(steps - 1))",
1046                 min=1, soft_max=8,
1047                 default=1,
1048                 )
1049
1050         cls.use_camera_cull = BoolProperty(
1051                 name="Use Camera Cull",
1052                 description="Allow this object and its duplicators to be culled by camera space culling",
1053                 default=False,
1054                 )
1055
1056         cls.use_distance_cull = BoolProperty(
1057                 name="Use Distance Cull",
1058                 description="Allow this object and its duplicators to be culled by distance from camera",
1059                 default=False,
1060                 )
1061
1062         cls.use_adaptive_subdivision = BoolProperty(
1063                 name="Use Adaptive Subdivision",
1064                 description="Use adaptive render time subdivision",
1065                 default=False,
1066                 )
1067
1068         cls.dicing_rate = FloatProperty(
1069                 name="Dicing Scale",
1070                 description="Multiplier for scene dicing rate (located in the Geometry Panel)",
1071                 min=0.1, max=1000.0, soft_min=0.5,
1072                 default=1.0,
1073                 )
1074
1075     @classmethod
1076     def unregister(cls):
1077         del bpy.types.Object.cycles
1078
1079
1080 class CyclesCurveRenderSettings(bpy.types.PropertyGroup):
1081     @classmethod
1082     def register(cls):
1083         bpy.types.Scene.cycles_curves = PointerProperty(
1084                 name="Cycles Hair Rendering Settings",
1085                 description="Cycles hair rendering settings",
1086                 type=cls,
1087                 )
1088         cls.primitive = EnumProperty(
1089                 name="Primitive",
1090                 description="Type of primitive used for hair rendering",
1091                 items=enum_curve_primitives,
1092                 default='LINE_SEGMENTS',
1093                 )
1094         cls.shape = EnumProperty(
1095                 name="Shape",
1096                 description="Form of hair",
1097                 items=enum_curve_shape,
1098                 default='THICK',
1099                 )
1100         cls.cull_backfacing = BoolProperty(
1101                 name="Cull back-faces",
1102                 description="Do not test the back-face of each strand",
1103                 default=True,
1104                 )
1105         cls.use_curves = BoolProperty(
1106                 name="Use Cycles Hair Rendering",
1107                 description="Activate Cycles hair rendering for particle system",
1108                 default=True,
1109                 )
1110         cls.resolution = IntProperty(
1111                 name="Resolution",
1112                 description="Resolution of generated mesh",
1113                 min=3, max=64,
1114                 default=3,
1115                 )
1116         cls.minimum_width = FloatProperty(
1117                 name="Minimal width",
1118                 description="Minimal pixel width for strands (0 - deactivated)",
1119                 min=0.0, max=100.0,
1120                 default=0.0,
1121                 )
1122         cls.maximum_width = FloatProperty(
1123                 name="Maximal width",
1124                 description="Maximum extension that strand radius can be increased by",
1125                 min=0.0, max=100.0,
1126                 default=0.1,
1127                 )
1128         cls.subdivisions = IntProperty(
1129                 name="Subdivisions",
1130                 description="Number of subdivisions used in Cardinal curve intersection (power of 2)",
1131                 min=0, max=24,
1132                 default=4,
1133                 )
1134
1135     @classmethod
1136     def unregister(cls):
1137         del bpy.types.Scene.cycles_curves
1138
1139
1140 class CyclesCurveSettings(bpy.types.PropertyGroup):
1141     @classmethod
1142     def register(cls):
1143         bpy.types.ParticleSettings.cycles = PointerProperty(
1144                 name="Cycles Hair Settings",
1145                 description="Cycles hair settings",
1146                 type=cls,
1147                 )
1148         cls.radius_scale = FloatProperty(
1149                 name="Radius Scaling",
1150                 description="Multiplier of width properties",
1151                 min=0.0, max=1000.0,
1152                 default=0.01,
1153                 )
1154         cls.root_width = FloatProperty(
1155                 name="Root Size",
1156                 description="Strand's width at root",
1157                 min=0.0, max=1000.0,
1158                 default=1.0,
1159                 )
1160         cls.tip_width = FloatProperty(
1161                 name="Tip Multiplier",
1162                 description="Strand's width at tip",
1163                 min=0.0, max=1000.0,
1164                 default=0.0,
1165                 )
1166         cls.shape = FloatProperty(
1167                 name="Strand Shape",
1168                 description="Strand shape parameter",
1169                 min=-1.0, max=1.0,
1170                 default=0.0,
1171                 )
1172         cls.use_closetip = BoolProperty(
1173                 name="Close tip",
1174                 description="Set tip radius to zero",
1175                 default=True,
1176                 )
1177
1178     @classmethod
1179     def unregister(cls):
1180         del bpy.types.ParticleSettings.cycles
1181
1182
1183 class CyclesDeviceSettings(bpy.types.PropertyGroup):
1184     @classmethod
1185     def register(cls):
1186         cls.id = StringProperty(name="ID")
1187         cls.name = StringProperty(name="Name")
1188         cls.use = BoolProperty(name="Use", default=True)
1189         cls.type = EnumProperty(name="Type", items=enum_device_type, default='CUDA')
1190
1191
1192 class CyclesPreferences(bpy.types.AddonPreferences):
1193     bl_idname = __package__
1194
1195     def get_device_types(self, context):
1196         import _cycles
1197         has_cuda, has_opencl = _cycles.get_device_types()
1198         list = [('NONE', "None", "Don't use compute device", 0)]
1199         if has_cuda:
1200             list.append(('CUDA', "CUDA", "Use CUDA for GPU acceleration", 1))
1201         if has_opencl:
1202             list.append(('OPENCL', "OpenCL", "Use OpenCL for GPU acceleration", 2))
1203         return list
1204
1205     compute_device_type = EnumProperty(
1206             name="Compute Device Type",
1207             description="Device to use for computation (rendering with Cycles)",
1208             items=get_device_types,
1209             )
1210
1211     devices = bpy.props.CollectionProperty(type=CyclesDeviceSettings)
1212
1213     def get_devices(self):
1214         import _cycles
1215         # Layout of the device tuples: (Name, Type, Persistent ID)
1216         device_list = _cycles.available_devices()
1217
1218         cuda_devices = []
1219         opencl_devices = []
1220         for device in device_list:
1221             if not device[1] in {'CUDA', 'OPENCL'}:
1222                 continue
1223
1224             entry = None
1225             # Try to find existing Device entry
1226             for dev in self.devices:
1227                 if dev.id == device[2] and dev.type == device[1]:
1228                     entry = dev
1229                     break
1230             # Create new entry if no existing one was found
1231             if not entry:
1232                 entry = self.devices.add()
1233                 entry.id   = device[2]
1234                 entry.name = device[0]
1235                 entry.type = device[1]
1236
1237             # Sort entries into lists
1238             if entry.type == 'CUDA':
1239                 cuda_devices.append(entry)
1240             elif entry.type == 'OPENCL':
1241                 opencl_devices.append(entry)
1242         return cuda_devices, opencl_devices
1243
1244
1245     def get_num_gpu_devices(self):
1246         import _cycles
1247         device_list = _cycles.available_devices()
1248         num = 0
1249         for device in device_list:
1250             if device[1] != self.compute_device_type:
1251                 continue
1252             for dev in self.devices:
1253                 if dev.use and dev.id == device[2]:
1254                     num += 1
1255         return num
1256
1257
1258     def has_active_device(self):
1259         return self.get_num_gpu_devices() > 0
1260
1261
1262     def draw_impl(self, layout, context):
1263         layout.label(text="Cycles Compute Device:")
1264         layout.row().prop(self, "compute_device_type", expand=True)
1265
1266         cuda_devices, opencl_devices = self.get_devices()
1267         row = layout.row()
1268
1269         if self.compute_device_type == 'CUDA' and cuda_devices:
1270             col = row.column(align=True)
1271             for device in cuda_devices:
1272                 col.prop(device, "use", text=device.name, toggle=True)
1273
1274         if self.compute_device_type == 'OPENCL' and opencl_devices:
1275             col = row.column(align=True)
1276             for device in opencl_devices:
1277                 col.prop(device, "use", text=device.name, toggle=True)
1278
1279
1280     def draw(self, context):
1281         self.draw_impl(self.layout, context)
1282
1283
1284 def register():
1285     bpy.utils.register_class(CyclesRenderSettings)
1286     bpy.utils.register_class(CyclesCameraSettings)
1287     bpy.utils.register_class(CyclesMaterialSettings)
1288     bpy.utils.register_class(CyclesLampSettings)
1289     bpy.utils.register_class(CyclesWorldSettings)
1290     bpy.utils.register_class(CyclesVisibilitySettings)
1291     bpy.utils.register_class(CyclesMeshSettings)
1292     bpy.utils.register_class(CyclesObjectSettings)
1293     bpy.utils.register_class(CyclesCurveRenderSettings)
1294     bpy.utils.register_class(CyclesCurveSettings)
1295     bpy.utils.register_class(CyclesDeviceSettings)
1296     bpy.utils.register_class(CyclesPreferences)
1297
1298
1299 def unregister():
1300     bpy.utils.unregister_class(CyclesRenderSettings)
1301     bpy.utils.unregister_class(CyclesCameraSettings)
1302     bpy.utils.unregister_class(CyclesMaterialSettings)
1303     bpy.utils.unregister_class(CyclesLampSettings)
1304     bpy.utils.unregister_class(CyclesWorldSettings)
1305     bpy.utils.unregister_class(CyclesMeshSettings)
1306     bpy.utils.unregister_class(CyclesObjectSettings)
1307     bpy.utils.unregister_class(CyclesVisibilitySettings)
1308     bpy.utils.unregister_class(CyclesCurveRenderSettings)
1309     bpy.utils.unregister_class(CyclesCurveSettings)
1310     bpy.utils.unregister_class(CyclesDeviceSettings)
1311     bpy.utils.unregister_class(CyclesPreferences)