# RenderEngine(bpy_struct)

## Simple Render Engine

    import bpy

    class CustomRenderEngine(bpy.types.RenderEngine):
        # These three members are used by blender to set up the
        # RenderEngine; define its internal name, visible name and capabilities.
        bl_idname = 'custom_renderer'
        bl_label = 'Flat Color Renderer'
        bl_use_preview = True

        # This is the only method called by blender, in this example
        # we use it to detect preview rendering and call the implementation
        # in another method.
        def render(self, scene):
            scale = scene.render.resolution_percentage / 100.0
            self.size_x = int(scene.render.resolution_x * scale)
            self.size_y = int(scene.render.resolution_y * scale)

            if scene.name == 'preview':
                self.render_preview(scene)
            else:
                self.render_scene(scene)

        # In this example, we fill the preview renders with a flat green color.
        def render_preview(self, scene):
            pixel_count = self.size_x * self.size_y

            # The framebuffer is defined as a list of pixels, each pixel
            # itself being a list of R,G,B,A values
            green_rect = [[0.0, 1.0, 0.0, 1.0]] * pixel_count

            # Here we write the pixel values to the RenderResult
            result = self.begin_result(0, 0, self.size_x, self.size_y)
            layer = result.layers[0]
            layer.rect = green_rect
            self.end_result(result)

        # In this example, we fill the full renders with a flat blue color.
        def render_scene(self, scene):
            pixel_count = self.size_x * self.size_y

            # The framebuffer is defined as a list of pixels, each pixel
            # itself being a list of R,G,B,A values
            blue_rect = [[0.0, 0.0, 1.0, 1.0]] * pixel_count

            # Here we write the pixel values to the RenderResult
            result = self.begin_result(0, 0, self.size_x, self.size_y)
            layer = result.layers[0]
            layer.rect = blue_rect
            self.end_result(result)

    # Register the RenderEngine
    bpy.utils.register_class(CustomRenderEngine)

    # RenderEngines also need to tell UI Panels that they are compatible
    # Otherwise most of the UI will be empty when the engine is selected.
    # In this example, we need to see the main render image button and
    # the material preview panel.
    from bl_ui import properties_render
    properties_render.RENDER_PT_render.COMPAT_ENGINES.add('custom_renderer')
    del properties_render

    from bl_ui import properties_material
    properties_material.MATERIAL_PT_preview.COMPAT_ENGINES.add('custom_renderer')
    del properties_material

base class — `bpy_struct`

subclasses — `CYCLES`

class `bpy.types.``RenderEngine`(bpy_struct)

  Render engine

  `bl_idname`

    Type: | string, default “”, (never None)

  `bl_label`

    Type: | string, default “”, (never None)

  `bl_use_exclude_layers`

    Type: | boolean, default False

  `bl_use_postprocess`

    Type: | boolean, default False

  `bl_use_preview`

    Type: | boolean, default False

  `bl_use_save_buffers`

    Type: | boolean, default False

  `bl_use_shading_nodes`

    Type: | boolean, default False

  `bl_use_shading_nodes_custom`

    Type: | boolean, default True

  `bl_use_texture_preview`

    Type: | boolean, default False

  `camera_override`

    Type: | `Object`, (readonly)

  `is_animation`

    Type: | boolean, default False

  `is_preview`

    Type: | boolean, default False

  `layer_override`

    Type: | boolean array of 20 items, default (False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False)

  `render`

    Type: | `RenderSettings`, (readonly)

  `resolution_x`

    Type: | int in [-inf, inf], default 0, (readonly)

  `resolution_y`

    Type: | int in [-inf, inf], default 0, (readonly)

  `tile_x`

    Type: | int in [0, inf], default 0

  `tile_y`

    Type: | int in [0, inf], default 0

  `use_highlight_tiles`

    Type: | boolean, default False

  `update`(data=None, scene=None)

    Export scene data for render

  `render`(scene=None)

    Render scene into an image

  `bake`(scene, object, pass_type, object_id, pixel_array, num_pixels, depth, result)

    Bake passes

    Parameters: | pass_type (enum in [‘COMBINED’, ‘Z’, ‘COLOR’, ‘DIFFUSE’, ‘SPECULAR’, ‘SHADOW’, ‘AO’, ‘REFLECTION’, ‘NORMAL’, ‘VECTOR’, ‘REFRACTION’, ‘OBJECT_INDEX’, ‘UV’, ‘MIST’, ‘EMIT’, ‘ENVIRONMENT’, ‘MATERIAL_INDEX’, ‘DIFFUSE_DIRECT’, ‘DIFFUSE_INDIRECT’, ‘DIFFUSE_COLOR’, ‘GLOSSY_DIRECT’, ‘GLOSSY_INDIRECT’, ‘GLOSSY_COLOR’, ‘TRANSMISSION_DIRECT’, ‘TRANSMISSION_INDIRECT’, ‘TRANSMISSION_COLOR’, ‘SUBSURFACE_DIRECT’, ‘SUBSURFACE_INDIRECT’, ‘SUBSURFACE_COLOR’]) – Pass, Pass to bake object_id (int in [0, inf]) – Object Id, Id of the current object being baked in relation to the others num_pixels (int in [0, inf]) – Number of Pixels, Size of the baking batch depth (int in [0, inf]) – Pixels depth, Number of channels

  `view_update`(context=None)

    Update on data changes for viewport render

  `view_draw`(context=None)

    Draw viewport render

  `update_script_node`(node=None)

    Compile shader script node

  `tag_redraw`()

    Request redraw for viewport rendering

  `tag_update`()

    Request update call for viewport rendering

  `begin_result`(x, y, w, h, layer="", view="")

    Create render result to write linear floating point render layers and passes

    Parameters: | x (int in [0, inf]) – X y (int in [0, inf]) – Y w (int in [0, inf]) – Width h (int in [0, inf]) – Height layer (string, (optional, never None)) – Layer, Single layer to get render result for view (string, (optional, never None)) – View, Single view to get render result for
    Returns: | Result
    Return type: | `RenderResult`

  `update_result`(result)

    Signal that pixels have been updated and can be redrawn in the user interface

    Parameters: | result (`RenderResult`) – Result

  `end_result`(result, cancel=False, do_merge_results=False)

    All pixels in the render result have been set and are final

    Parameters: | result (`RenderResult`) – Result cancel (boolean, (optional)) – Cancel, Don’t mark tile as done, don’t merge results unless forced do_merge_results (boolean, (optional)) – Merge Results, Merge results even if cancel=true

  `test_break`()

    Test if the render operation should been canceled, this is a fast call that should be used regularly for responsiveness

    Returns: | Break
    Return type: | boolean

  `active_view_set`(view="")

    active_view_set

    Parameters: | view (string, (optional, never None)) – View, Single view to set as active

  `camera_shift_x`(camera)

    camera_shift_x

    Returns: | Shift X
    Return type: | float in [0, inf]

  `camera_model_matrix`(camera, r_model_matrix)

    camera_model_matrix

    Parameters: | r_model_matrix (float array of 16 items in [-inf, inf]) – Model Matrix, Normalized camera model matrix

  `update_stats`(stats, info)

    Update and signal to redraw render status text

    Parameters: | stats (string, (never None)) – Stats info (string, (never None)) – Info

  `frame_set`(frame, subframe)

    Evaluate scene at a different frame (for motion blur)

    Parameters: | frame (int in [-inf, inf]) – Frame subframe (float in [0, 1]) – Subframe

  `update_progress`(progress)

    Update progress percentage of render

    Parameters: | progress (float in [0, 1]) – Percentage of render that’s done

  `update_memory_stats`(memory_used=0.0, memory_peak=0.0)

    Update memory usage statistics

    Parameters: | memory_used (float in [0, inf], (optional)) – Current memory usage in megabytes memory_peak (float in [0, inf], (optional)) – Peak memory usage in megabytes

  `report`(type, message)

    Report info, warning or error messages

    Parameters: | type (enum set in {‘DEBUG’, ‘INFO’, ‘OPERATOR’, ‘PROPERTY’, ‘WARNING’, ‘ERROR’, ‘ERROR_INVALID_INPUT’, ‘ERROR_INVALID_CONTEXT’, ‘ERROR_OUT_OF_MEMORY’}) – Type message (string, (never None)) – Report Message

  `error_set`(message)

    Set error message displaying after the render is finished

    Parameters: | message (string, (never None)) – Report Message

  `bind_display_space_shader`(scene)

    Bind GLSL fragment shader that converts linear colors to display space colors using scene color management settings

  `unbind_display_space_shader`()

    Unbind GLSL display space shader, must always be called after binding the shader

  `support_display_space_shader`(scene)

    Test if GLSL display space shader is supported for the combination of graphics card and scene settings

    Returns: | Supported
    Return type: | boolean

Inherited Properties

`bpy_struct.id_data` |

Inherited Functions

`bpy_struct.as_pointer` `bpy_struct.driver_add` `bpy_struct.driver_remove` `bpy_struct.get` `bpy_struct.is_property_hidden` `bpy_struct.is_property_readonly` `bpy_struct.is_property_set` `bpy_struct.items` | `bpy_struct.keyframe_delete` `bpy_struct.keyframe_insert` `bpy_struct.keys` `bpy_struct.path_from_id` `bpy_struct.path_resolve` `bpy_struct.property_unset` `bpy_struct.type_recast` `bpy_struct.values`