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