Cleanup: unused imports
[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     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
67
68     def draw(self, context):
69         layout = self.layout
70         layout.use_property_split = True
71         layout.use_property_decorate = False  # No animation.
72
73         scene = context.scene
74         view = scene.view_settings
75
76         flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
77
78         col = flow.column()
79         col.prop(scene.display_settings, "display_device")
80
81         col.separator()
82
83         col.prop(view, "view_transform")
84         col.prop(view, "look")
85
86         col = flow.column()
87         col.prop(view, "exposure")
88         col.prop(view, "gamma")
89
90         col.separator()
91
92         col.prop(scene.sequencer_colorspace_settings, "name", text="Sequencer")
93
94
95 class RENDER_PT_color_management_curves(RenderButtonsPanel, Panel):
96     bl_label = "Use Curves"
97     bl_parent_id = "RENDER_PT_color_management"
98     bl_options = {'DEFAULT_CLOSED'}
99     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
100
101     def draw_header(self, context):
102
103         scene = context.scene
104         view = scene.view_settings
105
106         self.layout.prop(view, "use_curve_mapping", text="")
107
108     def draw(self, context):
109         layout = self.layout
110
111         scene = context.scene
112         view = scene.view_settings
113
114         layout.use_property_split = False
115         layout.use_property_decorate = False  # No animation.
116
117         layout.enabled = view.use_curve_mapping
118
119         layout.template_curve_mapping(view, "curve_mapping", type='COLOR', levels=True)
120
121
122 class RENDER_PT_eevee_ambient_occlusion(RenderButtonsPanel, Panel):
123     bl_label = "Ambient Occlusion"
124     bl_options = {'DEFAULT_CLOSED'}
125     COMPAT_ENGINES = {'BLENDER_EEVEE'}
126
127     @classmethod
128     def poll(cls, context):
129         return (context.engine in cls.COMPAT_ENGINES)
130
131     def draw_header(self, context):
132         scene = context.scene
133         props = scene.eevee
134         self.layout.prop(props, "use_gtao", text="")
135
136     def draw(self, context):
137         layout = self.layout
138         layout.use_property_split = True
139         scene = context.scene
140         props = scene.eevee
141
142         layout.active = props.use_gtao
143         col = layout.column()
144         col.prop(props, "gtao_distance")
145         col.prop(props, "gtao_factor")
146         col.prop(props, "gtao_quality")
147         col.prop(props, "use_gtao_bent_normals")
148         col.prop(props, "use_gtao_bounce")
149
150
151 class RENDER_PT_eevee_motion_blur(RenderButtonsPanel, Panel):
152     bl_label = "Motion Blur"
153     bl_options = {'DEFAULT_CLOSED'}
154     COMPAT_ENGINES = {'BLENDER_EEVEE'}
155
156     @classmethod
157     def poll(cls, context):
158         return (context.engine in cls.COMPAT_ENGINES)
159
160     def draw_header(self, context):
161         scene = context.scene
162         props = scene.eevee
163         self.layout.prop(props, "use_motion_blur", text="")
164
165     def draw(self, context):
166         layout = self.layout
167         layout.use_property_split = True
168         scene = context.scene
169         props = scene.eevee
170
171         layout.active = props.use_motion_blur
172         col = layout.column()
173         col.prop(props, "motion_blur_samples")
174         col.prop(props, "motion_blur_shutter")
175
176
177 class RENDER_PT_eevee_depth_of_field(RenderButtonsPanel, Panel):
178     bl_label = "Depth of Field"
179     bl_options = {'DEFAULT_CLOSED'}
180     COMPAT_ENGINES = {'BLENDER_EEVEE'}
181
182     @classmethod
183     def poll(cls, context):
184         return (context.engine in cls.COMPAT_ENGINES)
185
186     def draw_header(self, context):
187         scene = context.scene
188         props = scene.eevee
189         self.layout.prop(props, "use_dof", text="")
190
191     def draw(self, context):
192         layout = self.layout
193         layout.use_property_split = True
194         scene = context.scene
195         props = scene.eevee
196
197         layout.active = props.use_dof
198         col = layout.column()
199         col.prop(props, "bokeh_max_size")
200         # Not supported yet
201         # col.prop(props, "bokeh_threshold")
202
203
204 class RENDER_PT_eevee_bloom(RenderButtonsPanel, Panel):
205     bl_label = "Bloom"
206     bl_options = {'DEFAULT_CLOSED'}
207     COMPAT_ENGINES = {'BLENDER_EEVEE'}
208
209     @classmethod
210     def poll(cls, context):
211         return (context.engine in cls.COMPAT_ENGINES)
212
213     def draw_header(self, context):
214         scene = context.scene
215         props = scene.eevee
216         self.layout.prop(props, "use_bloom", text="")
217
218     def draw(self, context):
219         layout = self.layout
220         layout.use_property_split = True
221
222         scene = context.scene
223         props = scene.eevee
224
225         layout.active = props.use_bloom
226         col = layout.column()
227         col.prop(props, "bloom_threshold")
228         col.prop(props, "bloom_knee")
229         col.prop(props, "bloom_radius")
230         col.prop(props, "bloom_color")
231         col.prop(props, "bloom_intensity")
232         col.prop(props, "bloom_clamp")
233
234
235 class RENDER_PT_eevee_volumetric(RenderButtonsPanel, Panel):
236     bl_label = "Volumetric"
237     bl_options = {'DEFAULT_CLOSED'}
238     COMPAT_ENGINES = {'BLENDER_EEVEE'}
239
240     @classmethod
241     def poll(cls, context):
242         return (context.engine in cls.COMPAT_ENGINES)
243
244     def draw_header(self, context):
245         scene = context.scene
246         props = scene.eevee
247         self.layout.prop(props, "use_volumetric", text="")
248
249     def draw(self, context):
250         layout = self.layout
251         layout.use_property_split = True
252
253         scene = context.scene
254         props = scene.eevee
255
256         layout.active = props.use_volumetric
257
258         col = layout.column(align=True)
259         col.prop(props, "volumetric_start")
260         col.prop(props, "volumetric_end")
261
262         col = layout.column()
263         col.prop(props, "volumetric_tile_size")
264         col.prop(props, "volumetric_samples")
265         col.prop(props, "volumetric_sample_distribution", text="Distribution")
266
267
268 class RENDER_PT_eevee_volumetric_lighting(RenderButtonsPanel, Panel):
269     bl_label = "Volumetric Lighting"
270     bl_parent_id = "RENDER_PT_eevee_volumetric"
271     COMPAT_ENGINES = {'BLENDER_EEVEE'}
272
273     def draw_header(self, context):
274         scene = context.scene
275         props = scene.eevee
276         self.layout.prop(props, "use_volumetric_lights", text="")
277
278     def draw(self, context):
279         layout = self.layout
280         layout.use_property_split = True
281
282         scene = context.scene
283         props = scene.eevee
284
285         layout.active = props.use_volumetric_lights
286         layout.prop(props, "volumetric_light_clamp", text="Light Clamping")
287
288
289 class RENDER_PT_eevee_volumetric_shadows(RenderButtonsPanel, Panel):
290     bl_label = "Volumetric Shadows"
291     bl_parent_id = "RENDER_PT_eevee_volumetric"
292     COMPAT_ENGINES = {'BLENDER_EEVEE'}
293
294     def draw_header(self, context):
295         scene = context.scene
296         props = scene.eevee
297         self.layout.prop(props, "use_volumetric_shadows", text="")
298
299     def draw(self, context):
300         layout = self.layout
301         layout.use_property_split = True
302
303         scene = context.scene
304         props = scene.eevee
305
306         layout.active = props.use_volumetric_shadows
307         layout.prop(props, "volumetric_shadow_samples", text="Shadow Samples")
308
309
310 class RENDER_PT_eevee_subsurface_scattering(RenderButtonsPanel, Panel):
311     bl_label = "Subsurface Scattering"
312     bl_options = {'DEFAULT_CLOSED'}
313     COMPAT_ENGINES = {'BLENDER_EEVEE'}
314
315     @classmethod
316     def poll(cls, context):
317         return (context.engine in cls.COMPAT_ENGINES)
318
319     def draw_header(self, context):
320         scene = context.scene
321         props = scene.eevee
322         self.layout.prop(props, "use_sss", text="")
323
324     def draw(self, context):
325         layout = self.layout
326         layout.use_property_split = True
327
328         scene = context.scene
329         props = scene.eevee
330
331         layout.active = props.use_sss
332
333         col = layout.column()
334         col.prop(props, "sss_samples")
335         col.prop(props, "sss_jitter_threshold")
336         col.prop(props, "use_sss_separate_albedo")
337
338
339 class RENDER_PT_eevee_screen_space_reflections(RenderButtonsPanel, Panel):
340     bl_label = "Screen Space Reflections"
341     bl_options = {'DEFAULT_CLOSED'}
342     COMPAT_ENGINES = {'BLENDER_EEVEE'}
343
344     @classmethod
345     def poll(cls, context):
346         return (context.engine in cls.COMPAT_ENGINES)
347
348     def draw_header(self, context):
349         scene = context.scene
350         props = scene.eevee
351         self.layout.prop(props, "use_ssr", text="")
352
353     def draw(self, context):
354         layout = self.layout
355         layout.use_property_split = True
356
357         scene = context.scene
358         props = scene.eevee
359
360         col = layout.column()
361         col.active = props.use_ssr
362         col.prop(props, "use_ssr_refraction", text="Refraction")
363         col.prop(props, "use_ssr_halfres")
364         col.prop(props, "ssr_quality")
365         col.prop(props, "ssr_max_roughness")
366         col.prop(props, "ssr_thickness")
367         col.prop(props, "ssr_border_fade")
368         col.prop(props, "ssr_firefly_fac")
369
370
371 class RENDER_PT_eevee_shadows(RenderButtonsPanel, Panel):
372     bl_label = "Shadows"
373     bl_options = {'DEFAULT_CLOSED'}
374     COMPAT_ENGINES = {'BLENDER_EEVEE'}
375
376     @classmethod
377     def poll(cls, context):
378         return (context.engine in cls.COMPAT_ENGINES)
379
380     def draw(self, context):
381         layout = self.layout
382         layout.use_property_split = True
383
384         scene = context.scene
385         props = scene.eevee
386
387         col = layout.column()
388         col.prop(props, "shadow_method")
389         col.prop(props, "shadow_cube_size", text="Cube Size")
390         col.prop(props, "shadow_cascade_size", text="Cascade Size")
391         col.prop(props, "use_shadow_high_bitdepth")
392         col.prop(props, "use_soft_shadows")
393         col.prop(props, "light_threshold")
394
395
396 class RENDER_PT_eevee_sampling(RenderButtonsPanel, Panel):
397     bl_label = "Sampling"
398     COMPAT_ENGINES = {'BLENDER_EEVEE'}
399
400     @classmethod
401     def poll(cls, context):
402         return (context.engine in cls.COMPAT_ENGINES)
403
404     def draw(self, context):
405         layout = self.layout
406         layout.use_property_split = True
407         layout.use_property_decorate = False  # No animation.
408
409         scene = context.scene
410         props = scene.eevee
411
412         col = layout.column()
413         col.prop(props, "taa_render_samples", text="Render")
414         col.prop(props, "taa_samples", text="Viewport")
415         col.prop(props, "use_taa_reprojection")
416
417
418 class RENDER_PT_eevee_indirect_lighting(RenderButtonsPanel, Panel):
419     bl_label = "Indirect Lighting"
420     bl_options = {'DEFAULT_CLOSED'}
421     COMPAT_ENGINES = {'BLENDER_EEVEE'}
422
423     @classmethod
424     def poll(cls, context):
425         return (context.engine in cls.COMPAT_ENGINES)
426
427     def draw(self, context):
428         layout = self.layout
429         layout.use_property_split = True
430         layout.use_property_decorate = False  # No animation.
431
432         scene = context.scene
433         props = scene.eevee
434
435         col = layout.column()
436         col.operator("scene.light_cache_bake", text="Bake Indirect Lighting", icon='RENDER_STILL')
437         col.operator("scene.light_cache_bake", text="Bake Cubemap Only", icon='LIGHTPROBE_CUBEMAP').subset = 'CUBEMAPS'
438         col.operator("scene.light_cache_free", text="Delete Lighting Cache")
439
440         cache_info = scene.eevee.gi_cache_info
441         if cache_info:
442             col.label(text=cache_info)
443
444         col.prop(props, "gi_auto_bake")
445
446         col.prop(props, "gi_diffuse_bounces")
447         col.prop(props, "gi_cubemap_resolution")
448         col.prop(props, "gi_visibility_resolution", text="Diffuse Occlusion")
449         col.prop(props, "gi_irradiance_smoothing")
450         col.prop(props, "gi_glossy_clamp")
451         col.prop(props, "gi_filter_quality")
452
453
454 class RENDER_PT_eevee_indirect_lighting_display(RenderButtonsPanel, Panel):
455     bl_label = "Display"
456     bl_parent_id = "RENDER_PT_eevee_indirect_lighting"
457     COMPAT_ENGINES = {'BLENDER_EEVEE'}
458
459     @classmethod
460     def poll(cls, context):
461         return (context.engine in cls.COMPAT_ENGINES)
462
463     def draw(self, context):
464         layout = self.layout
465         layout.use_property_split = True
466         layout.use_property_decorate = False  # No animation.
467
468         scene = context.scene
469         props = scene.eevee
470
471         row = layout.row(align=True)
472         row.prop(props, "gi_cubemap_display_size", text="Cubemap Size")
473         row.prop(props, "gi_show_cubemaps", text="", toggle=True)
474
475         row = layout.row(align=True)
476         row.prop(props, "gi_irradiance_display_size", text="Irradiance Size")
477         row.prop(props, "gi_show_irradiance", text="", toggle=True)
478
479
480 class RENDER_PT_eevee_film(RenderButtonsPanel, Panel):
481     bl_label = "Film"
482     bl_options = {'DEFAULT_CLOSED'}
483     COMPAT_ENGINES = {'BLENDER_EEVEE'}
484
485     @classmethod
486     def poll(cls, context):
487         return (context.engine in cls.COMPAT_ENGINES)
488
489     def draw(self, context):
490         layout = self.layout
491         layout.use_property_split = True
492
493         scene = context.scene
494         props = scene.eevee
495         rd = scene.render
496
497         col = layout.column()
498         col.prop(rd, "filter_size")
499         col.prop(rd, "alpha_mode", text="Alpha")
500
501
502 class RENDER_PT_eevee_film_overscan(RenderButtonsPanel, Panel):
503     bl_label = "Overscan"
504     bl_parent_id = "RENDER_PT_eevee_film"
505     bl_options = {'DEFAULT_CLOSED'}
506     COMPAT_ENGINES = {'BLENDER_EEVEE'}
507
508     def draw_header(self, context):
509
510         scene = context.scene
511         props = scene.eevee
512
513         self.layout.prop(props, "use_overscan", text="")
514
515     def draw(self, context):
516         layout = self.layout
517         layout.use_property_split = True
518         scene = context.scene
519         props = scene.eevee
520
521         layout.active = props.use_overscan
522         layout.prop(props, "overscan_size", text="Size")
523
524
525 class RENDER_PT_eevee_hair(RenderButtonsPanel, Panel):
526     bl_label = "Hair"
527     bl_options = {'DEFAULT_CLOSED'}
528     COMPAT_ENGINES = {'BLENDER_EEVEE'}
529
530     @classmethod
531     def poll(cls, context):
532         return (context.engine in cls.COMPAT_ENGINES)
533
534     def draw(self, context):
535         layout = self.layout
536         scene = context.scene
537         rd = scene.render
538
539         layout.use_property_split = True
540
541         layout.prop(rd, "hair_type", expand=True)
542         layout.prop(rd, "hair_subdiv")
543
544
545 class RENDER_PT_opengl_film(RenderButtonsPanel, Panel):
546     bl_label = "Film"
547     bl_options = {'DEFAULT_CLOSED'}
548     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
549
550     def draw(self, context):
551         layout = self.layout
552         layout.use_property_split = True
553         layout.use_property_decorate = False  # No animation.
554
555         rd = context.scene.render
556
557         layout.prop(rd, "use_antialiasing")
558
559         layout.prop(rd, "antialiasing_samples")
560         layout.prop(rd, "alpha_mode")
561
562
563 class RENDER_PT_opengl_lighting(RenderButtonsPanel, Panel):
564     bl_label = "Lighting"
565     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
566
567     @classmethod
568     def poll(cls, context):
569         return (context.engine in cls.COMPAT_ENGINES)
570
571     def draw(self, context):
572         VIEW3D_PT_shading_lighting.draw(self, context)
573
574
575 class RENDER_PT_opengl_color(RenderButtonsPanel, Panel):
576     bl_label = "Color"
577     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
578
579     @classmethod
580     def poll(cls, context):
581         return (context.engine in cls.COMPAT_ENGINES)
582
583     def draw(self, context):
584         VIEW3D_PT_shading_color._draw_color_type(self, context)
585
586
587 class RENDER_PT_opengl_options(RenderButtonsPanel, Panel):
588     bl_label = "Options"
589     COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
590
591     @classmethod
592     def poll(cls, context):
593         return (context.engine in cls.COMPAT_ENGINES)
594
595     def draw(self, context):
596         VIEW3D_PT_shading_options.draw(self, context)
597
598
599 class RENDER_PT_simplify(RenderButtonsPanel, Panel):
600     bl_label = "Simplify"
601     bl_options = {'DEFAULT_CLOSED'}
602     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
603
604     def draw_header(self, context):
605         rd = context.scene.render
606         self.layout.prop(rd, "use_simplify", text="")
607
608     def draw(self, context):
609         pass
610
611
612 class RENDER_PT_simplify_viewport(RenderButtonsPanel, Panel):
613     bl_label = "Viewport"
614     bl_parent_id = "RENDER_PT_simplify"
615     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
616
617     def draw(self, context):
618         layout = self.layout
619         layout.use_property_split = True
620
621         rd = context.scene.render
622
623         layout.active = rd.use_simplify
624
625         flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
626
627         col = flow.column()
628         col.prop(rd, "simplify_subdivision", text="Max Subdivision")
629
630         col = flow.column()
631         col.prop(rd, "simplify_child_particles", text="Max Child Particles")
632
633         col = flow.column()
634         col.prop(rd, "use_simplify_smoke_highres", text="High-resolution Smoke")
635
636
637 class RENDER_PT_simplify_render(RenderButtonsPanel, Panel):
638     bl_label = "Render"
639     bl_parent_id = "RENDER_PT_simplify"
640     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
641
642     def draw(self, context):
643         layout = self.layout
644         layout.use_property_split = True
645
646         rd = context.scene.render
647
648         layout.active = rd.use_simplify
649
650         flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
651
652         col = flow.column()
653         col.prop(rd, "simplify_subdivision_render", text="Max Subdivision")
654
655         col = flow.column()
656         col.prop(rd, "simplify_child_particles_render", text="Max Child Particles")
657
658
659 class RENDER_PT_simplify_greasepencil(RenderButtonsPanel, Panel):
660     bl_label = "Grease Pencil"
661     bl_parent_id = "RENDER_PT_simplify"
662     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME', 'BLENDER_CLAY', 'BLENDER_EEVEE'}
663     bl_options = {'DEFAULT_CLOSED'}
664
665     def draw_header(self, context):
666         rd = context.scene.render
667         self.layout.prop(rd, "simplify_gpencil", text="")
668
669     def draw(self, context):
670         layout = self.layout
671         layout.use_property_split = True
672         layout.use_property_decorate = False
673
674         rd = context.scene.render
675
676         layout.active = rd.simplify_gpencil
677
678         col = layout.column()
679         col.prop(rd, "simplify_gpencil_onplay", text="Playback Only")
680         col.prop(rd, "simplify_gpencil_view_modifier", text="Modifiers")
681         col.prop(rd, "simplify_gpencil_shader_fx", text="ShaderFX")
682         col.prop(rd, "simplify_gpencil_blend", text="Layers Blending")
683
684         col.prop(rd, "simplify_gpencil_view_fill")
685         sub = col.column()
686         sub.active = rd.simplify_gpencil_view_fill
687         sub.prop(rd, "simplify_gpencil_remove_lines", text="Lines")
688
689
690 classes = (
691     RENDER_PT_context,
692     RENDER_PT_eevee_sampling,
693     RENDER_PT_eevee_ambient_occlusion,
694     RENDER_PT_eevee_bloom,
695     RENDER_PT_eevee_depth_of_field,
696     RENDER_PT_eevee_subsurface_scattering,
697     RENDER_PT_eevee_screen_space_reflections,
698     RENDER_PT_eevee_motion_blur,
699     RENDER_PT_eevee_volumetric,
700     RENDER_PT_eevee_volumetric_lighting,
701     RENDER_PT_eevee_volumetric_shadows,
702     RENDER_PT_eevee_hair,
703     RENDER_PT_eevee_shadows,
704     RENDER_PT_eevee_indirect_lighting,
705     RENDER_PT_eevee_indirect_lighting_display,
706     RENDER_PT_eevee_film,
707     RENDER_PT_eevee_film_overscan,
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)