UI: Align Render and Viewport samples properties for EEVEE.
[blender.git] / release / scripts / startup / bl_ui / properties_render.py
1 # ##### BEGIN GPL LICENSE BLOCK #####
2
3 #
4 #  This program is free software; you can redistribute it and/or
5 #  modify it under the terms of the GNU General Public License
6 #  as published by the Free Software Foundation; either version 2
7 #  of the License, or (at your option) any later version.
8 #
9 #  This program is distributed in the hope that it will be useful,
10 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
11 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 #  GNU General Public License for more details.
13 #
14 #  You should have received a copy of the GNU General Public License
15 #  along with this program; if not, write to the Free Software Foundation,
16 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 #
18 # ##### END GPL LICENSE BLOCK #####
19
20 # <pep8 compliant>
21 from bpy.types import Panel
22 from .space_view3d import (
23     VIEW3D_PT_shading_lighting,
24     VIEW3D_PT_shading_color,
25     VIEW3D_PT_shading_options,
26 )
27
28
29 class RenderButtonsPanel:
30     bl_space_type = 'PROPERTIES'
31     bl_region_type = 'WINDOW'
32     bl_context = "render"
33     # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
34
35     @classmethod
36     def poll(cls, context):
37         return (context.engine in cls.COMPAT_ENGINES)
38
39
40 class RENDER_PT_context(Panel):
41     bl_space_type = 'PROPERTIES'
42     bl_region_type = 'WINDOW'
43     bl_context = "render"
44     bl_options = {'HIDE_HEADER'}
45     bl_label = ""
46
47     @classmethod
48     def poll(cls, context):
49         return context.scene
50
51     def draw(self, context):
52         layout = self.layout
53         layout.use_property_split = True
54         layout.use_property_decorate = False
55
56         scene = context.scene
57         rd = scene.render
58
59         if rd.has_multiple_engines:
60             layout.prop(rd, "engine", text="Render Engine")
61
62
63 class RENDER_PT_color_management(RenderButtonsPanel, Panel):
64     bl_label = "Color Management"
65     bl_options = {'DEFAULT_CLOSED'}
66     bl_order = 100
67     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
68
69     def draw(self, context):
70         layout = self.layout
71         layout.use_property_split = True
72         layout.use_property_decorate = False  # No animation.
73
74         scene = context.scene
75         view = scene.view_settings
76
77         flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
78
79         col = flow.column()
80         col.prop(scene.display_settings, "display_device")
81
82         col.separator()
83
84         col.prop(view, "view_transform")
85         col.prop(view, "look")
86
87         col = flow.column()
88         col.prop(view, "exposure")
89         col.prop(view, "gamma")
90
91         col.separator()
92
93         col.prop(scene.sequencer_colorspace_settings, "name", text="Sequencer")
94
95
96 class RENDER_PT_color_management_curves(RenderButtonsPanel, Panel):
97     bl_label = "Use Curves"
98     bl_parent_id = "RENDER_PT_color_management"
99     bl_options = {'DEFAULT_CLOSED'}
100     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
101
102     def draw_header(self, context):
103
104         scene = context.scene
105         view = scene.view_settings
106
107         self.layout.prop(view, "use_curve_mapping", text="")
108
109     def draw(self, context):
110         layout = self.layout
111
112         scene = context.scene
113         view = scene.view_settings
114
115         layout.use_property_split = False
116         layout.use_property_decorate = False  # No animation.
117
118         layout.enabled = view.use_curve_mapping
119
120         layout.template_curve_mapping(view, "curve_mapping", type='COLOR', levels=True)
121
122
123 class RENDER_PT_eevee_ambient_occlusion(RenderButtonsPanel, Panel):
124     bl_label = "Ambient Occlusion"
125     bl_options = {'DEFAULT_CLOSED'}
126     COMPAT_ENGINES = {'BLENDER_EEVEE'}
127
128     @classmethod
129     def poll(cls, context):
130         return (context.engine in cls.COMPAT_ENGINES)
131
132     def draw_header(self, context):
133         scene = context.scene
134         props = scene.eevee
135         self.layout.prop(props, "use_gtao", text="")
136
137     def draw(self, context):
138         layout = self.layout
139         layout.use_property_split = True
140         scene = context.scene
141         props = scene.eevee
142
143         layout.active = props.use_gtao
144         col = layout.column()
145         col.prop(props, "gtao_distance")
146         col.prop(props, "gtao_factor")
147         col.prop(props, "gtao_quality")
148         col.prop(props, "use_gtao_bent_normals")
149         col.prop(props, "use_gtao_bounce")
150
151
152 class RENDER_PT_eevee_motion_blur(RenderButtonsPanel, Panel):
153     bl_label = "Motion Blur"
154     bl_options = {'DEFAULT_CLOSED'}
155     COMPAT_ENGINES = {'BLENDER_EEVEE'}
156
157     @classmethod
158     def poll(cls, context):
159         return (context.engine in cls.COMPAT_ENGINES)
160
161     def draw_header(self, context):
162         scene = context.scene
163         props = scene.eevee
164         self.layout.prop(props, "use_motion_blur", text="")
165
166     def draw(self, context):
167         layout = self.layout
168         layout.use_property_split = True
169         scene = context.scene
170         props = scene.eevee
171
172         layout.active = props.use_motion_blur
173         col = layout.column()
174         col.prop(props, "motion_blur_samples")
175         col.prop(props, "motion_blur_shutter")
176
177
178 class RENDER_PT_eevee_depth_of_field(RenderButtonsPanel, Panel):
179     bl_label = "Depth of Field"
180     bl_options = {'DEFAULT_CLOSED'}
181     COMPAT_ENGINES = {'BLENDER_EEVEE'}
182
183     @classmethod
184     def poll(cls, context):
185         return (context.engine in cls.COMPAT_ENGINES)
186
187     def draw(self, context):
188         layout = self.layout
189         layout.use_property_split = True
190         scene = context.scene
191         props = scene.eevee
192
193         col = layout.column()
194         col.prop(props, "bokeh_max_size")
195         # Not supported yet
196         # col.prop(props, "bokeh_threshold")
197
198
199 class RENDER_PT_eevee_bloom(RenderButtonsPanel, Panel):
200     bl_label = "Bloom"
201     bl_options = {'DEFAULT_CLOSED'}
202     COMPAT_ENGINES = {'BLENDER_EEVEE'}
203
204     @classmethod
205     def poll(cls, context):
206         return (context.engine in cls.COMPAT_ENGINES)
207
208     def draw_header(self, context):
209         scene = context.scene
210         props = scene.eevee
211         self.layout.prop(props, "use_bloom", text="")
212
213     def draw(self, context):
214         layout = self.layout
215         layout.use_property_split = True
216
217         scene = context.scene
218         props = scene.eevee
219
220         layout.active = props.use_bloom
221         col = layout.column()
222         col.prop(props, "bloom_threshold")
223         col.prop(props, "bloom_knee")
224         col.prop(props, "bloom_radius")
225         col.prop(props, "bloom_color")
226         col.prop(props, "bloom_intensity")
227         col.prop(props, "bloom_clamp")
228
229
230 class RENDER_PT_eevee_volumetric(RenderButtonsPanel, Panel):
231     bl_label = "Volumetric"
232     bl_options = {'DEFAULT_CLOSED'}
233     COMPAT_ENGINES = {'BLENDER_EEVEE'}
234
235     @classmethod
236     def poll(cls, context):
237         return (context.engine in cls.COMPAT_ENGINES)
238
239     def draw(self, context):
240         layout = self.layout
241         layout.use_property_split = True
242
243         scene = context.scene
244         props = scene.eevee
245
246         col = layout.column(align=True)
247         col.prop(props, "volumetric_start")
248         col.prop(props, "volumetric_end")
249
250         col = layout.column()
251         col.prop(props, "volumetric_tile_size")
252         col.prop(props, "volumetric_samples")
253         col.prop(props, "volumetric_sample_distribution", text="Distribution")
254
255
256 class RENDER_PT_eevee_volumetric_lighting(RenderButtonsPanel, Panel):
257     bl_label = "Volumetric Lighting"
258     bl_parent_id = "RENDER_PT_eevee_volumetric"
259     COMPAT_ENGINES = {'BLENDER_EEVEE'}
260
261     def draw_header(self, context):
262         scene = context.scene
263         props = scene.eevee
264         self.layout.prop(props, "use_volumetric_lights", text="")
265
266     def draw(self, context):
267         layout = self.layout
268         layout.use_property_split = True
269
270         scene = context.scene
271         props = scene.eevee
272
273         layout.active = props.use_volumetric_lights
274         layout.prop(props, "volumetric_light_clamp", text="Light Clamping")
275
276
277 class RENDER_PT_eevee_volumetric_shadows(RenderButtonsPanel, Panel):
278     bl_label = "Volumetric Shadows"
279     bl_parent_id = "RENDER_PT_eevee_volumetric"
280     COMPAT_ENGINES = {'BLENDER_EEVEE'}
281
282     def draw_header(self, context):
283         scene = context.scene
284         props = scene.eevee
285         self.layout.prop(props, "use_volumetric_shadows", text="")
286
287     def draw(self, context):
288         layout = self.layout
289         layout.use_property_split = True
290
291         scene = context.scene
292         props = scene.eevee
293
294         layout.active = props.use_volumetric_shadows
295         layout.prop(props, "volumetric_shadow_samples", text="Shadow Samples")
296
297
298 class RENDER_PT_eevee_subsurface_scattering(RenderButtonsPanel, Panel):
299     bl_label = "Subsurface Scattering"
300     bl_options = {'DEFAULT_CLOSED'}
301     COMPAT_ENGINES = {'BLENDER_EEVEE'}
302
303     @classmethod
304     def poll(cls, context):
305         return (context.engine in cls.COMPAT_ENGINES)
306
307     def draw(self, context):
308         layout = self.layout
309         layout.use_property_split = True
310
311         scene = context.scene
312         props = scene.eevee
313
314         col = layout.column()
315         col.prop(props, "sss_samples")
316         col.prop(props, "sss_jitter_threshold")
317         col.prop(props, "use_sss_separate_albedo")
318
319
320 class RENDER_PT_eevee_screen_space_reflections(RenderButtonsPanel, Panel):
321     bl_label = "Screen Space Reflections"
322     bl_options = {'DEFAULT_CLOSED'}
323     COMPAT_ENGINES = {'BLENDER_EEVEE'}
324
325     @classmethod
326     def poll(cls, context):
327         return (context.engine in cls.COMPAT_ENGINES)
328
329     def draw_header(self, context):
330         scene = context.scene
331         props = scene.eevee
332         self.layout.prop(props, "use_ssr", text="")
333
334     def draw(self, context):
335         layout = self.layout
336         layout.use_property_split = True
337
338         scene = context.scene
339         props = scene.eevee
340
341         col = layout.column()
342         col.active = props.use_ssr
343         col.prop(props, "use_ssr_refraction", text="Refraction")
344         col.prop(props, "use_ssr_halfres")
345         col.prop(props, "ssr_quality")
346         col.prop(props, "ssr_max_roughness")
347         col.prop(props, "ssr_thickness")
348         col.prop(props, "ssr_border_fade")
349         col.prop(props, "ssr_firefly_fac")
350
351
352 class RENDER_PT_eevee_shadows(RenderButtonsPanel, Panel):
353     bl_label = "Shadows"
354     bl_options = {'DEFAULT_CLOSED'}
355     COMPAT_ENGINES = {'BLENDER_EEVEE'}
356
357     @classmethod
358     def poll(cls, context):
359         return (context.engine in cls.COMPAT_ENGINES)
360
361     def draw(self, context):
362         layout = self.layout
363         layout.use_property_split = True
364
365         scene = context.scene
366         props = scene.eevee
367
368         col = layout.column()
369         col.prop(props, "shadow_method")
370         col.prop(props, "shadow_cube_size", text="Cube Size")
371         col.prop(props, "shadow_cascade_size", text="Cascade Size")
372         col.prop(props, "use_shadow_high_bitdepth")
373         col.prop(props, "use_soft_shadows")
374         col.prop(props, "light_threshold")
375
376
377 class RENDER_PT_eevee_sampling(RenderButtonsPanel, Panel):
378     bl_label = "Sampling"
379     COMPAT_ENGINES = {'BLENDER_EEVEE'}
380
381     @classmethod
382     def poll(cls, context):
383         return (context.engine in cls.COMPAT_ENGINES)
384
385     def draw(self, context):
386         layout = self.layout
387         layout.use_property_split = True
388         layout.use_property_decorate = False  # No animation.
389
390         scene = context.scene
391         props = scene.eevee
392
393         col = layout.column(align=True)
394         col.prop(props, "taa_render_samples", text="Render")
395         col.prop(props, "taa_samples", text="Viewport")
396
397         col = layout.column()
398         col.prop(props, "use_taa_reprojection")
399
400
401 class RENDER_PT_eevee_indirect_lighting(RenderButtonsPanel, Panel):
402     bl_label = "Indirect Lighting"
403     bl_options = {'DEFAULT_CLOSED'}
404     COMPAT_ENGINES = {'BLENDER_EEVEE'}
405
406     @classmethod
407     def poll(cls, context):
408         return (context.engine in cls.COMPAT_ENGINES)
409
410     def draw(self, context):
411         layout = self.layout
412         layout.use_property_split = True
413         layout.use_property_decorate = False  # No animation.
414
415         scene = context.scene
416         props = scene.eevee
417
418         col = layout.column()
419         col.operator("scene.light_cache_bake", text="Bake Indirect Lighting", icon='RENDER_STILL')
420         col.operator("scene.light_cache_bake", text="Bake Cubemap Only", icon='LIGHTPROBE_CUBEMAP').subset = 'CUBEMAPS'
421         col.operator("scene.light_cache_free", text="Delete Lighting Cache")
422
423         cache_info = scene.eevee.gi_cache_info
424         if cache_info:
425             col.label(text=cache_info)
426
427         col.prop(props, "gi_auto_bake")
428
429         col.prop(props, "gi_diffuse_bounces")
430         col.prop(props, "gi_cubemap_resolution")
431         col.prop(props, "gi_visibility_resolution", text="Diffuse Occlusion")
432         col.prop(props, "gi_irradiance_smoothing")
433         col.prop(props, "gi_glossy_clamp")
434         col.prop(props, "gi_filter_quality")
435
436
437 class RENDER_PT_eevee_indirect_lighting_display(RenderButtonsPanel, Panel):
438     bl_label = "Display"
439     bl_parent_id = "RENDER_PT_eevee_indirect_lighting"
440     COMPAT_ENGINES = {'BLENDER_EEVEE'}
441
442     @classmethod
443     def poll(cls, context):
444         return (context.engine in cls.COMPAT_ENGINES)
445
446     def draw(self, context):
447         layout = self.layout
448         layout.use_property_split = True
449         layout.use_property_decorate = False  # No animation.
450
451         scene = context.scene
452         props = scene.eevee
453
454         row = layout.row(align=True)
455         row.prop(props, "gi_cubemap_display_size", text="Cubemap Size")
456         row.prop(props, "gi_show_cubemaps", text="", toggle=True)
457
458         row = layout.row(align=True)
459         row.prop(props, "gi_irradiance_display_size", text="Irradiance Size")
460         row.prop(props, "gi_show_irradiance", text="", toggle=True)
461
462
463 class RENDER_PT_eevee_film(RenderButtonsPanel, Panel):
464     bl_label = "Film"
465     bl_options = {'DEFAULT_CLOSED'}
466     COMPAT_ENGINES = {'BLENDER_EEVEE'}
467
468     @classmethod
469     def poll(cls, context):
470         return (context.engine in cls.COMPAT_ENGINES)
471
472     def draw(self, context):
473         layout = self.layout
474         layout.use_property_split = True
475
476         scene = context.scene
477         rd = scene.render
478
479         col = layout.column()
480         col.prop(rd, "filter_size")
481         col.prop(rd, "film_transparent", text="Transparent")
482
483
484 class RENDER_PT_eevee_film_overscan(RenderButtonsPanel, Panel):
485     bl_label = "Overscan"
486     bl_parent_id = "RENDER_PT_eevee_film"
487     bl_options = {'DEFAULT_CLOSED'}
488     COMPAT_ENGINES = {'BLENDER_EEVEE'}
489
490     def draw_header(self, context):
491
492         scene = context.scene
493         props = scene.eevee
494
495         self.layout.prop(props, "use_overscan", text="")
496
497     def draw(self, context):
498         layout = self.layout
499         layout.use_property_split = True
500         scene = context.scene
501         props = scene.eevee
502
503         layout.active = props.use_overscan
504         layout.prop(props, "overscan_size", text="Size")
505
506
507 class RENDER_PT_eevee_hair(RenderButtonsPanel, Panel):
508     bl_label = "Hair"
509     bl_options = {'DEFAULT_CLOSED'}
510     COMPAT_ENGINES = {'BLENDER_EEVEE'}
511
512     @classmethod
513     def poll(cls, context):
514         return (context.engine in cls.COMPAT_ENGINES)
515
516     def draw(self, context):
517         layout = self.layout
518         scene = context.scene
519         rd = scene.render
520
521         layout.use_property_split = True
522
523         layout.prop(rd, "hair_type", expand=True)
524         layout.prop(rd, "hair_subdiv")
525
526
527 class RENDER_PT_opengl_sampling(RenderButtonsPanel, Panel):
528     bl_label = "Sampling"
529     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
530
531     @classmethod
532     def poll(cls, context):
533         return (context.engine in cls.COMPAT_ENGINES)
534
535     def draw(self, context):
536         layout = self.layout
537         layout.use_property_split = True
538         layout.use_property_decorate = False  # No animation.
539
540         scene = context.scene
541         props = scene.display
542
543         col = layout.column()
544         col.prop(props, "render_aa", text="Render")
545         col.prop(props, "viewport_aa", text="Viewport Render")
546
547
548 class RENDER_PT_opengl_film(RenderButtonsPanel, Panel):
549     bl_label = "Film"
550     bl_options = {'DEFAULT_CLOSED'}
551     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
552
553     def draw(self, context):
554         layout = self.layout
555         layout.use_property_split = True
556         layout.use_property_decorate = False  # No animation.
557
558         rd = context.scene.render
559         layout.prop(rd, "film_transparent", text="Transparent")
560
561
562 class RENDER_PT_opengl_lighting(RenderButtonsPanel, Panel):
563     bl_label = "Lighting"
564     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
565
566     @classmethod
567     def poll(cls, context):
568         return (context.engine in cls.COMPAT_ENGINES)
569
570     def draw(self, context):
571         VIEW3D_PT_shading_lighting.draw(self, context)
572
573
574 class RENDER_PT_opengl_color(RenderButtonsPanel, Panel):
575     bl_label = "Color"
576     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
577
578     @classmethod
579     def poll(cls, context):
580         return (context.engine in cls.COMPAT_ENGINES)
581
582     def draw(self, context):
583         VIEW3D_PT_shading_color._draw_color_type(self, context)
584
585
586 class RENDER_PT_opengl_options(RenderButtonsPanel, Panel):
587     bl_label = "Options"
588     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
589
590     @classmethod
591     def poll(cls, context):
592         return (context.engine in cls.COMPAT_ENGINES)
593
594     def draw(self, context):
595         VIEW3D_PT_shading_options.draw(self, context)
596
597
598 class RENDER_PT_simplify(RenderButtonsPanel, Panel):
599     bl_label = "Simplify"
600     bl_options = {'DEFAULT_CLOSED'}
601     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
602
603     def draw_header(self, context):
604         rd = context.scene.render
605         self.layout.prop(rd, "use_simplify", text="")
606
607     def draw(self, context):
608         pass
609
610
611 class RENDER_PT_simplify_viewport(RenderButtonsPanel, Panel):
612     bl_label = "Viewport"
613     bl_parent_id = "RENDER_PT_simplify"
614     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
615
616     def draw(self, context):
617         layout = self.layout
618         layout.use_property_split = True
619
620         rd = context.scene.render
621
622         layout.active = rd.use_simplify
623
624         flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
625
626         col = flow.column()
627         col.prop(rd, "simplify_subdivision", text="Max Subdivision")
628
629         col = flow.column()
630         col.prop(rd, "simplify_child_particles", text="Max Child Particles")
631
632         col = flow.column()
633         col.prop(rd, "use_simplify_smoke_highres", text="High-resolution Smoke")
634
635
636 class RENDER_PT_simplify_render(RenderButtonsPanel, Panel):
637     bl_label = "Render"
638     bl_parent_id = "RENDER_PT_simplify"
639     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
640
641     def draw(self, context):
642         layout = self.layout
643         layout.use_property_split = True
644
645         rd = context.scene.render
646
647         layout.active = rd.use_simplify
648
649         flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
650
651         col = flow.column()
652         col.prop(rd, "simplify_subdivision_render", text="Max Subdivision")
653
654         col = flow.column()
655         col.prop(rd, "simplify_child_particles_render", text="Max Child Particles")
656
657
658 class RENDER_PT_simplify_greasepencil(RenderButtonsPanel, Panel):
659     bl_label = "Grease Pencil"
660     bl_parent_id = "RENDER_PT_simplify"
661     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME', 'BLENDER_CLAY', 'BLENDER_EEVEE'}
662     bl_options = {'DEFAULT_CLOSED'}
663
664     def draw_header(self, context):
665         rd = context.scene.render
666         self.layout.prop(rd, "simplify_gpencil", text="")
667
668     def draw(self, context):
669         layout = self.layout
670         layout.use_property_split = True
671         layout.use_property_decorate = False
672
673         rd = context.scene.render
674
675         layout.active = rd.simplify_gpencil
676
677         col = layout.column()
678         col.prop(rd, "simplify_gpencil_onplay", text="Playback Only")
679         col.prop(rd, "simplify_gpencil_view_modifier", text="Modifiers")
680         col.prop(rd, "simplify_gpencil_shader_fx", text="ShaderFX")
681         col.prop(rd, "simplify_gpencil_blend", text="Layers Blending")
682
683         col.prop(rd, "simplify_gpencil_view_fill")
684         sub = col.column()
685         sub.active = rd.simplify_gpencil_view_fill
686         sub.prop(rd, "simplify_gpencil_remove_lines", text="Lines")
687
688
689 classes = (
690     RENDER_PT_context,
691     RENDER_PT_eevee_sampling,
692     RENDER_PT_eevee_ambient_occlusion,
693     RENDER_PT_eevee_bloom,
694     RENDER_PT_eevee_depth_of_field,
695     RENDER_PT_eevee_subsurface_scattering,
696     RENDER_PT_eevee_screen_space_reflections,
697     RENDER_PT_eevee_motion_blur,
698     RENDER_PT_eevee_volumetric,
699     RENDER_PT_eevee_volumetric_lighting,
700     RENDER_PT_eevee_volumetric_shadows,
701     RENDER_PT_eevee_hair,
702     RENDER_PT_eevee_shadows,
703     RENDER_PT_eevee_indirect_lighting,
704     RENDER_PT_eevee_indirect_lighting_display,
705     RENDER_PT_eevee_film,
706     RENDER_PT_eevee_film_overscan,
707     RENDER_PT_opengl_sampling,
708     RENDER_PT_opengl_lighting,
709     RENDER_PT_opengl_color,
710     RENDER_PT_opengl_options,
711     RENDER_PT_opengl_film,
712     RENDER_PT_color_management,
713     RENDER_PT_color_management_curves,
714     RENDER_PT_simplify,
715     RENDER_PT_simplify_viewport,
716     RENDER_PT_simplify_render,
717     RENDER_PT_simplify_greasepencil,
718 )
719
720 if __name__ == "__main__":  # only for live edit.
721     from bpy.utils import register_class
722     for cls in classes:
723         register_class(cls)