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.
import properties_render
properties_render.RENDER_PT_render.COMPAT_ENGINES.add('custom_renderer')
del properties_render

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

base class — bpy_struct

subclasses — NET_RENDER

class bpy.types.RenderEngine(bpy_struct)

Render engine

bl_idname
Type :string, default “”
bl_label
Type :string, default “”
bl_use_postprocess
Type :boolean, default False
bl_use_preview
Type :boolean, default False
render(scene=None)

Render scene into an image.

begin_result(x, y, w, h)

begin_result

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
Returns:

Result

Return type:

RenderResult

update_result(result)

update_result

Parameters:result (RenderResult) – Result
end_result(result)

end_result

Parameters:result (RenderResult) – Result
test_break()

test_break

Returns:Break
Return type:boolean
update_stats(stats, info)

update_stats

Parameters:
  • stats (string) – Stats
  • info (string) – Info

Inherited Properties

Inherited Functions

Table Of Contents

Previous topic

RegionView3D(bpy_struct)

Next topic

RenderLayer(bpy_struct)