1075 lines
32 KiB
Python
1075 lines
32 KiB
Python
# Blender.Scene.Render module and the RenderData PyType object
|
|
|
|
"""
|
|
The Blender.Scene.Render submodule.
|
|
|
|
Scene.Render
|
|
============
|
|
|
|
This module provides access to B{Scene Rendering Contexts} in Blender.
|
|
|
|
Example::
|
|
import Blender
|
|
from Blender import *
|
|
from Blender.Scene import Render
|
|
|
|
scn = Scene.GetCurrent()
|
|
context = scn.getRenderingContext()
|
|
|
|
Render.EnableDispWin()
|
|
context.extensions = True
|
|
context.renderPath = "//myRenderdir/"
|
|
context.sizePreset(Render.PC)
|
|
context.imageType = Render.AVIRAW
|
|
context.sFrame = 2
|
|
context.eFrame = 10
|
|
context.renderAnim()
|
|
|
|
context.imageType = Render.TARGA
|
|
context.fps = 15
|
|
context.sFrame = 15
|
|
context.eFrame = 22
|
|
context.renderAnim()
|
|
|
|
Render.CloseRenderWindow()
|
|
print context.fps
|
|
print context.cFrame
|
|
|
|
@type Modes: readonly dictionary
|
|
@var Modes: Constant dict used for with L{RenderData.mode} bitfield attribute.
|
|
Values can be ORed together. Individual bits can also be set/cleared with
|
|
boolean attributes.
|
|
- OSA: Oversampling (anti-aliasing) enabled
|
|
- SHADOW: Shadow calculation enabled
|
|
- GAMMA: Gamma correction enabled
|
|
- ENVMAP: Environment map rendering enabled
|
|
- TOONSHADING: Toon edge shading enabled
|
|
- FIELDRENDER: Field rendering enabled
|
|
- FIELDTIME: Time difference in field calculations I{disabled}
|
|
- RADIOSITY: Radiosity rendering enabled
|
|
- BORDER_RENDER: Small cut-out rendering enabled
|
|
- PANORAMA: Panorama rendering enabled
|
|
- CROP: Crop image during border renders
|
|
- ODDFIELD: Odd field first rendering enabled
|
|
- MBLUR: Motion blur enabled
|
|
- UNIFIED: Unified Renderer enabled
|
|
- RAYTRACING: Ray tracing enabled
|
|
- THREADS: Render in two threads enabled
|
|
|
|
@type SceModes: readonly dictionary
|
|
@var SceModes: Constant dict used for with L{RenderData.sceneMode} bitfield attribute.
|
|
Values can be ORed together. Individual bits can also be set/cleared with
|
|
boolean attributes.
|
|
- SEQUENCER: Enables sequencer output rendering.
|
|
- EXTENSION: Adds extensions to the output when rendering animations.
|
|
|
|
@type FramingModes: readonly dictionary
|
|
@var FramingModes: Constant dict used for with L{RenderData.gameFrame}
|
|
attribute. One of the following modes can be active:
|
|
- BARS: Show the entire viewport in the display window, using bar
|
|
horizontally or vertically.
|
|
- EXTEND: Show the entire viewport in the display window, viewing more
|
|
horizontally or vertically
|
|
- SCALE: Stretch or squeeze the viewport to fill the display window.
|
|
|
|
"""
|
|
|
|
def CloseRenderWindow():
|
|
"""
|
|
Closes the rendering window.
|
|
"""
|
|
|
|
def EnableDispView():
|
|
"""
|
|
Render in the 3d View area. B{Note} this method is deprecated;
|
|
use the l{displayMode} attribute instead.
|
|
"""
|
|
|
|
def EnableDispWin():
|
|
"""
|
|
Render in Render window.
|
|
B{Note} this method is deprecated; use the l{displayMode} attribute instead.
|
|
"""
|
|
|
|
def SetRenderWinPos(locationList):
|
|
"""
|
|
Set the position of the Render window on the screen.
|
|
Possible values are:
|
|
- S = south
|
|
- N = north
|
|
- W = west
|
|
- E = east
|
|
- C = center
|
|
- ne = northeast
|
|
- nw = northwest
|
|
- se = southeast
|
|
- sw = southwest
|
|
@type locationList: PyList of strings
|
|
@param locationList: a list of strings that together define
|
|
the location of the Render window on the screen.
|
|
"""
|
|
|
|
def EnableEdgeShift():
|
|
"""
|
|
Globally with the unified renderer enabled the outlines of the render
|
|
are shifted a bit.
|
|
"""
|
|
|
|
def EnableEdgeAll():
|
|
"""
|
|
Globally consider transparent faces for edge-rendering with the unified renderer.
|
|
"""
|
|
|
|
class RenderData:
|
|
"""
|
|
The RenderData object
|
|
=====================
|
|
This object gives access to Scene rendering contexts in Blender.
|
|
@ivar unified: Unified Renderer enabled.
|
|
Also see B{UNIFIED} in L{Modes} constant dict.
|
|
@type unified: boolean
|
|
@ivar renderwinSize: Size of the rendering window. Valid values are 25, 50,
|
|
75, or 100.
|
|
@type renderwinSize: int
|
|
@ivar xParts: Number of horizontal parts for image render.
|
|
Values are clamped to the range [2,512].
|
|
@type xParts: int
|
|
@ivar fieldRendering: Field rendering enabled.
|
|
Also see B{FIELDRENDER} in L{Modes} constant dict.
|
|
@type fieldRendering: boolean
|
|
@ivar gammaCorrection: Gamma correction enabled.
|
|
Also see B{GAMMA} in L{Modes} constant dict.
|
|
@type gammaCorrection: boolean
|
|
@ivar eFrame: Ending frame for rendering.
|
|
Values are clamped to the range [1,MAXFRAME].
|
|
@type eFrame: int
|
|
@ivar radiosityRender: Radiosity rendering enabled.
|
|
@type radiosityRender: boolean
|
|
@ivar sizeX: Image width (in pixels).
|
|
Values are clamped to the range [4,10000].
|
|
@type sizeX: int
|
|
@ivar shadow: Shadow calculation enabled.
|
|
Also see B{SHADOW} in L{Modes} constant dict.
|
|
@type shadow: boolean
|
|
@ivar aspectX: Horizontal aspect ratio.
|
|
Values are clamped to the range [1,200].
|
|
@type aspectX: int
|
|
@ivar mode: Mode bitfield. See L{Modes} constant dict for values.
|
|
@type mode: bitfield
|
|
@ivar fieldTimeDisable: Time difference in field calculations I{disabled}.
|
|
@type fieldTimeDisable: int
|
|
@ivar cFrame: The current frame for rendering.
|
|
Values are clamped to the range [1,MAXFRAME].
|
|
@type cFrame: int
|
|
@ivar crop: Crop image during border renders.
|
|
Also see B{CROP} in L{Modes} constant dict.
|
|
@type crop: boolean
|
|
@ivar sFrame: Starting frame for rendering.
|
|
Values are clamped to the range [1,MAXFRAME].
|
|
@type sFrame: int
|
|
@ivar backbuf: Backbuffer image enabled.
|
|
@type backbuf: boolean
|
|
@ivar OSALevel: Oversampling (anti-aliasing) level. Valid values are
|
|
5, 8, 11, or 16.
|
|
@type OSALevel: int
|
|
@ivar displayMode: Render output in separate window or 3D view.
|
|
Valid values are 0 (display in image editor view), 1 (display in render
|
|
window), or 2 (display full screen).
|
|
@type displayMode: int
|
|
@ivar threads: Render in two threads enabled.
|
|
Also see B{THREADS} in L{Modes} constant dict.
|
|
@type threads: boolean
|
|
@ivar backbufPath: Path to a background image (setting loads image).
|
|
@type backbufPath: string
|
|
@ivar toonShading: Toon edge shading enabled.
|
|
Also see B{TOONSHADING} in L{Modes} constant dict.
|
|
@type toonShading: boolean
|
|
@ivar sceneMode: Scene mode bitfield. See L{SceModes} constant dict for
|
|
values.
|
|
@type sceneMode: bitfield
|
|
@ivar gameFrameColor: RGB color triplet for bars.
|
|
Values are clamped in the range [0.0,1.0].
|
|
@type gameFrameColor: list of RGB 3 floats
|
|
@ivar extensions: Add extensions to output (when rendering animations).
|
|
Also see B{EXTENSION} in L{SceModes} constant dict.
|
|
@type extensions: boolean
|
|
@ivar sizeY: Image height (in pixels).
|
|
Values are clamped to the range [4,10000].
|
|
@type sizeY: int
|
|
@ivar renderer: Rendering engine choice.
|
|
Valid values are 0 (internal) or 1 (Yafray).
|
|
@type renderer: int
|
|
@ivar sequencer: Enables sequencer output rendering.
|
|
Also see B{SEQUENCER} in L{SceModes} constant dict.
|
|
@type sequencer: boolean
|
|
@ivar panorama: Panorama rendering enabled.
|
|
Also see B{PANORAMA} in L{Modes} constant dict.
|
|
@type panorama: boolean
|
|
@ivar rayTracing: Ray tracing enabled.
|
|
Also see B{RAYTRACING} in L{Modes} constant dict.
|
|
@type rayTracing: boolean
|
|
@ivar renderPath: The path to output the rendered images.
|
|
@type renderPath: string
|
|
@ivar gameFrame: Game framing type. See L{FramingModes} constant dict.
|
|
@type gameFrame: int
|
|
@ivar aspectY: Vertical aspect ratio.
|
|
Values are clamped to the range [1,200].
|
|
@type aspectY: int
|
|
@ivar imageType: File format for saving images. See the module's constants
|
|
for values.
|
|
@type imageType: int
|
|
@ivar ftypePath: The path to Ftype file.
|
|
@type ftypePath: string
|
|
@ivar border: The border for border rendering. The format is
|
|
[xmin,ymin,xmax,ymax]. Values are clamped to [0.0,1.0].
|
|
@type border: list of 4 floats.
|
|
@ivar edgeColor: RGB color triplet for edges in Toon shading (unified
|
|
renderer).
|
|
Values are clamped in the range [0.0,1.0].
|
|
@type edgeColor: list of 3 RGB floats
|
|
@ivar yParts: Number of vertical parts for image render.
|
|
Values are clamped to the range [2,512].
|
|
@type yParts: int
|
|
@ivar imagePlanes: Image depth in bits. Valid values are 8, 24, or 32.
|
|
@type imagePlanes: int
|
|
@ivar borderRender: Small cut-out rendering enabled.
|
|
Also see B{BORDER_RENDER} in L{Modes} constant dict.
|
|
@type borderRender: boolean
|
|
@ivar oversampling: Oversampling (anti-aliasing) enabled.
|
|
Also see B{OSA} in L{Modes} constant dict.
|
|
@type oversampling: boolean
|
|
@ivar fps: Frames per second.
|
|
Values are clamped to the range [1,120].
|
|
@type fps: int
|
|
@ivar timeCode: Get the current frame in HH:MM:SS:FF format. Read-only.
|
|
@type timeCode: string
|
|
@ivar environmentMap: Environment map rendering enabled.
|
|
Also see B{ENVMAP} in L{Modes} constant dict.
|
|
@type environmentMap: boolean
|
|
@ivar motionBlur: Motion blur enabled.
|
|
Also see B{MBLUR} in L{Modes} constant dict.
|
|
@type motionBlur: boolean
|
|
@ivar oddFieldFirst: Odd field first rendering enabled.
|
|
Also see B{ODDFIELD} in L{Modes} constant dict.
|
|
@type oddFieldFirst: boolean
|
|
@ivar alphaMode: Setting for sky/background. Valid values are 0 (fill
|
|
background with sky), 1 (multiply alpha in advance), or 2 (alpha and color
|
|
values remain unchanged).
|
|
@type alphaMode: int
|
|
@ivar gaussFilter: Gauss filter size.
|
|
Values are clamped to the range [0.5,1.5].
|
|
@type gaussFilter: float
|
|
@ivar mblurFactor: Motion blur factor.
|
|
Values are clamped to the range [0.01,5.0].
|
|
@type mblurFactor: float
|
|
@ivar mapOld: Number of frames the Map Old will last
|
|
Values are clamped to the range [1,900].
|
|
@type mapOld: int
|
|
@ivar mapNew: New mapping value (in frames).
|
|
Values are clamped to the range [1,900].
|
|
@type mapNew: int
|
|
@ivar set: The scene linked as a set to this scene. Values are an existing
|
|
scene or None (setting to None clears the set). The scene argument cannot
|
|
cause a circular link.
|
|
@type set: BPy_Scene or None
|
|
"""
|
|
|
|
def currentFrame(frame = None):
|
|
"""
|
|
Get/set the current frame.
|
|
@type frame: int (optional)
|
|
@param frame: must be between 1 - 30000
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current frame for the scene.
|
|
"""
|
|
|
|
def render():
|
|
"""
|
|
Render the scene.
|
|
"""
|
|
|
|
def renderAnim():
|
|
"""
|
|
Render a series of frames to an output directory.
|
|
"""
|
|
|
|
def saveRenderedImage(filename, zbuffer=0):
|
|
"""
|
|
Saves the image rendered using RenderData.render() to the filename and path
|
|
given in the variable 'filename'.
|
|
|
|
Make sure the filename you provide makes a valid path when added to the "render path"
|
|
(setRenderPath/getRenderPath) to make up the absolute path.
|
|
If you want to render to a new absolute path just set the renderpath to an
|
|
empty string and use the absolute path as the filename.
|
|
@param filename: The path+filename for the rendered image.
|
|
@type zbuffer: int
|
|
@param zbuffer: Whether or not to render the zbuffer along with the image.
|
|
@type filename: string
|
|
@since: 2.40
|
|
@requires: You must have an image currently rendered before calling this method
|
|
"""
|
|
|
|
def play():
|
|
"""
|
|
play animation of rendered images/avi (searches Pics: field).
|
|
"""
|
|
|
|
def getTimeCode():
|
|
"""
|
|
Get the current frame as a string in HH:MM:SS:FF format
|
|
@rtype: string
|
|
@return: current frame as a string in HH:MM:SS:FF format
|
|
"""
|
|
|
|
def setRenderPath(path):
|
|
"""
|
|
Set the path to where the renderer will write to.
|
|
@type path: string
|
|
@param path: A directory for that the renderer searches for
|
|
both playback and output from the renderAnim function.
|
|
"""
|
|
|
|
def getRenderPath():
|
|
"""
|
|
Get the path to where the renderer will write to.
|
|
@rtype: string
|
|
@return: Returns the directory that is used to playback and store rendered
|
|
sequences.
|
|
"""
|
|
|
|
def setBackbufPath(path):
|
|
"""
|
|
Set the path to a background image and load it.
|
|
@type path: string
|
|
@param path: The path to a background image for loading.
|
|
"""
|
|
|
|
def getBackbufPath():
|
|
"""
|
|
Get the path to the background image.
|
|
@rtype: string
|
|
@return: The path to a background image.
|
|
"""
|
|
|
|
def enableBackbuf(toggle):
|
|
"""
|
|
Enable/disable the backbuf image.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def setFtypePath(path):
|
|
"""
|
|
Set the path to Ftype file.
|
|
@type path: string
|
|
@param path: Path to Ftype Image type.
|
|
"""
|
|
|
|
def getFtypePath():
|
|
"""
|
|
Get the path to the Ftype file
|
|
@rtype: string
|
|
@return: Path to FtypeImage type.
|
|
"""
|
|
|
|
def enableExtensions(toggle):
|
|
"""
|
|
Enable/disable windows extensions for output files.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableSequencer(toggle):
|
|
"""
|
|
Enable/disable Do Sequence.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableRenderDaemon(toggle):
|
|
"""
|
|
Enable/disable Scene daemon.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableToonShading(toggle):
|
|
"""
|
|
Enable/disable Edge rendering.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def edgeIntensity(intensity = None):
|
|
"""
|
|
Get/set edge intensity for toon shading.
|
|
@type intensity: int (optional)
|
|
@param intensity: must be between 0 - 255
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current edge intensity for the scene.
|
|
"""
|
|
|
|
def setEdgeColor(red, green, blue):
|
|
"""
|
|
Set the edge color for toon shading.
|
|
@type red: float
|
|
@param red: must be between 0 - 1.0
|
|
@type green: float
|
|
@param green: must be between 0 - 1.0
|
|
@type blue: float
|
|
@param blue: must be between 0 - 1.0
|
|
"""
|
|
|
|
def getEdgeColor():
|
|
"""
|
|
Get the edge color for toon shading.
|
|
@rtype: string
|
|
@return: A string representing the edge color.
|
|
"""
|
|
|
|
def edgeAntiShift(intensity = None):
|
|
"""
|
|
With the unified renderer, reduce intensity on boundaries.
|
|
@type intensity: int (optional)
|
|
@param intensity: must be between 0 - 255
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current edge antishift for the scene.
|
|
"""
|
|
|
|
def enableOversampling(toggle):
|
|
"""
|
|
Enable/disable oversampling (anti-aliasing).
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def setOversamplingLevel(level):
|
|
"""
|
|
Set the edge color for toon shading.
|
|
@type level: int
|
|
@param level: can be either 5, 8, 11, or 16
|
|
"""
|
|
|
|
def enableMotionBlur(toggle):
|
|
"""
|
|
Enable/disable MBlur.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def motionBlurLevel(level = None):
|
|
"""
|
|
Get/set the length of shutter time for motion blur.
|
|
@type level: float (optional)
|
|
@param level: must be between 0.01 - 5.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current MBlur for the scene.
|
|
"""
|
|
|
|
def partsX(parts = None):
|
|
"""
|
|
Get/set the number of parts to divide the render in the X direction.
|
|
@type parts: int (optional)
|
|
@param parts: must be between 1 - 64
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current number of parts in the X for the scene.
|
|
"""
|
|
|
|
def partsY(parts = None):
|
|
"""
|
|
Get/set the number of parts to divide the render in the Y direction.
|
|
@type parts: int (optional)
|
|
@param parts: must be between 1 - 64
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current number of parts in the Y for the scene.
|
|
"""
|
|
|
|
def enableSky():
|
|
"""
|
|
Enable render background with sky.
|
|
"""
|
|
|
|
def enablePremultiply():
|
|
"""
|
|
Enable premultiply alpha.
|
|
"""
|
|
|
|
def enableKey():
|
|
"""
|
|
Enable alpha and color values remain unchanged.
|
|
"""
|
|
|
|
def enableShadow(toggle):
|
|
"""
|
|
Enable/disable shadow calculation.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableEnvironmentMap(toggle):
|
|
"""
|
|
Enable/disable environment map rendering.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableRayTracing(toggle):
|
|
"""
|
|
Enable/disable ray tracing.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableRadiosityRender(toggle):
|
|
"""
|
|
Enable/disable radiosity rendering.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enablePanorama(toggle):
|
|
"""
|
|
Enable/disable panorama rendering (output width is multiplied by Xparts).
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def setRenderWinSize(size):
|
|
"""
|
|
Set the size of the render window.
|
|
@type size: int
|
|
@param size: can be 25, 50, 75 or 100 (percent).
|
|
"""
|
|
|
|
def getRenderWinSize():
|
|
"""
|
|
Get the size of the render window.
|
|
@rtype: int
|
|
@return: window size; can be 25, 50, 75 or 100 (percent).
|
|
"""
|
|
|
|
def enableFieldRendering(toggle):
|
|
"""
|
|
Enable/disable field rendering
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableOddFieldFirst(toggle):
|
|
"""
|
|
Enable/disable Odd field first rendering (Default: Even field).
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableFieldTimeDisable(toggle):
|
|
"""
|
|
Enable/disable time difference in field calculations.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableGaussFilter(toggle):
|
|
"""
|
|
Enable/disable Gauss sampling filter for anti-aliasing.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableBorderRender(toggle):
|
|
"""
|
|
Enable/disable small cut-out rendering.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def setBorder(left,bottom,right,top):
|
|
"""
|
|
Set a border for rendering from cameras in the scene.
|
|
The left,bottom coordinates and right,top coordinates
|
|
define the size of the border. (0,0,1,1) will set the border
|
|
to the whole camera. (0,0) lower left and (1,1) upper right.
|
|
@type left: float
|
|
@param left: float between 0 and 1
|
|
@type right: float
|
|
@param right: float between 0 and 1
|
|
@type bottom: float
|
|
@param bottom: float between 0 and 1
|
|
@type top: float
|
|
@param top: float between 0 and 1
|
|
"""
|
|
|
|
def enableGammaCorrection(toggle):
|
|
"""
|
|
Enable/disable gamma correction.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def gaussFilterSize(size = None):
|
|
"""
|
|
Get/sets the Gauss filter size.
|
|
@type size: float (optional)
|
|
@param size: must be between 0.5 - 1.5
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current gauss filter size for the scene.
|
|
"""
|
|
|
|
def startFrame(frame = None):
|
|
"""
|
|
Get/set the starting frame for sequence rendering.
|
|
@type frame: int (optional)
|
|
@param frame: must be between 1 - 18000
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current starting frame for the scene.
|
|
"""
|
|
|
|
def endFrame(frame = None):
|
|
"""
|
|
Get/set the ending frame for sequence rendering.
|
|
@type frame: int (optional)
|
|
@param frame: must be between 1 - 18000
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current ending frame for the scene.
|
|
"""
|
|
|
|
def imageSizeX(size = None):
|
|
"""
|
|
Get/set the image width in pixels.
|
|
@type size: int (optional)
|
|
@param size: must be between 4 - 10000
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current image width for the scene.
|
|
"""
|
|
|
|
def imageSizeY(size = None):
|
|
"""
|
|
Get/set the image height in pixels.
|
|
@type size: int (optional)
|
|
@param size: must be between 4 - 10000
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current image height for the scene.
|
|
"""
|
|
|
|
def aspectRatioX(ratio = None):
|
|
"""
|
|
Get/set the horizontal aspect ratio.
|
|
@type ratio: int (optional)
|
|
@param ratio: must be between 1 - 200
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current horizontal aspect ratio for the scene.
|
|
"""
|
|
|
|
def aspectRatioY(ratio = None):
|
|
"""
|
|
Get/set the vertical aspect ratio.
|
|
@type ratio: int (optional)
|
|
@param ratio: must be between 1 - 200
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current vertical aspect ratio for the scene.
|
|
"""
|
|
|
|
def setRenderer(type):
|
|
"""
|
|
Get/set which renderer to render the output.
|
|
@type type: enum constant
|
|
@param type: must be one of 2 constants:
|
|
- INTERN: Blender's internal renderer
|
|
- YAFRAY: Yafray renderer
|
|
"""
|
|
|
|
def enableCropping(toggle):
|
|
"""
|
|
Enable/disable exclusion of border rendering from total image.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def setImageType(type):
|
|
"""
|
|
Set the type of image to output from the render.
|
|
@type type: enum constant
|
|
@param type: must be one of 13 constants:
|
|
- AVIRAW: Uncompressed AVI files. AVI is a commonly used format on Windows platforms
|
|
- AVIJPEG: AVI movie w/ JPEG images
|
|
- AVICODEC: AVI using win32 codec
|
|
- QUICKTIME: Quicktime movie (if enabled)
|
|
- TARGA: Targa files
|
|
- RAWTGA: Raw Targa files
|
|
- PNG: Png files
|
|
- BMP: Bitmap files
|
|
- JPEG90: JPEG files
|
|
- HAMX: Hamx files
|
|
- IRIS: Iris files
|
|
- IRIZ: Iris + z-buffer files
|
|
- FTYPE: Ftype file
|
|
"""
|
|
|
|
def quality(qual = None):
|
|
"""
|
|
Get/set quality get/setting for JPEG images, AVI JPEG and SGI movies.
|
|
@type qual: int (optional)
|
|
@param qual: must be between 10 - 100
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current image quality for the scene.
|
|
"""
|
|
|
|
def framesPerSec(qual = None):
|
|
"""
|
|
Get/set frames per second.
|
|
@type qual: int (optional)
|
|
@param qual: must be between 1 - 120
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current frames per second for the scene.
|
|
"""
|
|
|
|
def enableGrayscale():
|
|
"""
|
|
Images are saved with black and white (grayscale) data.
|
|
"""
|
|
|
|
def enableRGBColor():
|
|
"""
|
|
Images are saved with RGB (color) data.
|
|
"""
|
|
|
|
def enableRGBAColor():
|
|
"""
|
|
Images are saved with RGB and Alpha data (if supported).
|
|
"""
|
|
|
|
def sizePreset(type):
|
|
"""
|
|
Set the renderer to one of a few presets.
|
|
@type type: enum constant
|
|
@param type: must be one of 8 constants:
|
|
- PAL: The European video standard: 720 x 576 pixels, 54 x 51 aspect.
|
|
- FULL: For large screens: 1280 x 1024 pixels.
|
|
- PREVIEW: For preview rendering: 320 x 256 pixels.
|
|
- PAL169: Wide-screen PAL.
|
|
- DEFAULT: Like "PAL", but here the render settings are also set.
|
|
- PANO: Panorama render.
|
|
- NTSC: For TV playback.
|
|
- PC: For standard PC graphics: 640 x 480 pixels.
|
|
"""
|
|
|
|
def enableUnifiedRenderer(toggle):
|
|
"""
|
|
Use the unified renderer.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def setYafrayGIQuality(type):
|
|
"""
|
|
Set yafray global Illumination quality.
|
|
@type type: enum constant
|
|
@param type: must be one of 6 constants:
|
|
- NONE
|
|
- LOW
|
|
- MEDIUM
|
|
- HIGH
|
|
- HIGHER
|
|
- BEST
|
|
"""
|
|
|
|
def setYafrayGIMethod(type):
|
|
"""
|
|
Set yafray global Illumination method.
|
|
@type type: enum constant
|
|
@param type: must be one of 3 constants:
|
|
- NONE: Do not use GI illumination
|
|
- SKYDOME: Use Skydome method
|
|
- GIFULL: Use Full method
|
|
"""
|
|
|
|
def yafrayGIPower(power = None):
|
|
"""
|
|
Get/set GI lighting intensity scale.
|
|
YafrayMethod must be either SKYDOME or GIFULL.
|
|
@type power: float (optional)
|
|
@param power: must be between 0.01 - 100.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current yafray global illumination intensity for the scene.
|
|
"""
|
|
|
|
def yafrayGIIndirPower(power = None):
|
|
"""
|
|
Get/set GI indirect lighting intensity scale.
|
|
@type power: float (optional)
|
|
@param power: must be between 0.01 - 100.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current yafray indirect illumination intensity for the scene.
|
|
"""
|
|
|
|
def yafrayGIDepth(depth = None):
|
|
"""
|
|
Get/set number of bounces of the indirect light.
|
|
YafrayMethod must be GIFULL.
|
|
@type depth: int (optional)
|
|
@param depth: must be between 1 - 8
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current yafray global illumination light bounces for the scene.
|
|
"""
|
|
|
|
def yafrayGICDepth(depth = None):
|
|
"""
|
|
Get/set number of bounces inside objects (for caustics).
|
|
YafrayMethod must be GIFULL.
|
|
@type depth: int (optional)
|
|
@param depth: must be between 1 - 8
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current yafray global illumination inside light bounces for the scene.
|
|
"""
|
|
|
|
def enableYafrayGICache(toggle):
|
|
"""
|
|
Enable/disable cache irradiance samples (faster).
|
|
YafrayMethod must be GIFULL.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def enableYafrayGIPhotons(toggle):
|
|
"""
|
|
Enable/disable use of global photons to help in GI.
|
|
YafrayMethod must be GIFULL.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def yafrayGIPhotonCount(count = None):
|
|
"""
|
|
Get/set number of photons to shoot.
|
|
YafrayMethod must be GIFULL and Photons enabled.
|
|
@type count: int (optional)
|
|
@param count: must be between 0 - 10000000
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current number of photons to shoot for the scene.
|
|
"""
|
|
|
|
|
|
def yafrayGIPhotonRadius(radius = None):
|
|
"""
|
|
Get/set radius to search for photons to mix (blur).
|
|
YafrayMethod must be GIFULL and Photons enabled.
|
|
@type radius: float (optional)
|
|
@param radius: must be between 0.00001 - 100.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current photon search radius for the scene.
|
|
"""
|
|
|
|
|
|
def yafrayGIPhotonMixCount(count = None):
|
|
"""
|
|
Get/set number of photons to keep inside radius.
|
|
YafrayMethod must be GIFULL and Photons enabled.
|
|
@type count: int (optional)
|
|
@param count: must be between 0 - 1000
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current number of photons to keep inside radius for the scene.
|
|
"""
|
|
|
|
def enableYafrayGITunePhotons(toggle):
|
|
"""
|
|
Enable/disable show the photon map directly in the render for tuning.
|
|
YafrayMethod must be GIFULL and Photons enabled.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def yafrayGIShadowQuality(qual = None):
|
|
"""
|
|
Get/set the shadow quality, keep it under 0.95.
|
|
YafrayMethod must be GIFULL and Cache enabled.
|
|
@type qual: float (optional)
|
|
@param qual: must be between 0.01 - 1.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current shadow quality for the scene.
|
|
"""
|
|
|
|
def yafrayGIPixelsPerSample(pixels = None):
|
|
"""
|
|
Get/set maximum number of pixels without samples, the lower the better and slower.
|
|
YafrayMethod must be GIFULL and Cache enabled.
|
|
@type pixels: int (optional)
|
|
@param pixels: must be between 1 - 50
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current number of pixels without samples for the scene.
|
|
"""
|
|
|
|
def enableYafrayGIGradient(toggle):
|
|
"""
|
|
Enable/disable try to smooth lighting using a gradient.
|
|
YafrayMethod must be GIFULL and Cache enabled.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def yafrayGIRefinement(refine = None):
|
|
"""
|
|
Get/set threshold to refine shadows EXPERIMENTAL. 1 = no refinement.
|
|
YafrayMethod must be GIFULL and Cache enabled.
|
|
@type refine: float (optional)
|
|
@param refine: must be between 0.001 - 1.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current threshold to refine shadows for the scene.
|
|
"""
|
|
|
|
def yafrayRayBias(bias = None):
|
|
"""
|
|
Get/set shadow ray bias to avoid self shadowing.
|
|
@type bias: float (optional)
|
|
@param bias: must be between 0 - 10.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current ray bias for the scene.
|
|
"""
|
|
|
|
def yafrayRayDepth(depth = None):
|
|
"""
|
|
Get/set maximum render ray depth from the camera.
|
|
@type depth: int (optional)
|
|
@param depth: must be between 1 - 80
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current ray depth for the scene.
|
|
"""
|
|
|
|
def yafrayGamma(gamma = None):
|
|
"""
|
|
Get/set gamma correction, 1 is off.
|
|
@type gamma: float (optional)
|
|
@param gamma: must be between 0.001 - 5.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current gamma correction for the scene.
|
|
"""
|
|
|
|
def yafrayExposure(expose = None):
|
|
"""
|
|
Get/set exposure adjustment, 0 is off.
|
|
@type expose: float (optional)
|
|
@param expose: must be between 0 - 10.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current exposure adjustment for the scene.
|
|
"""
|
|
|
|
def yafrayProcessorCount(count = None):
|
|
"""
|
|
Get/set number of processors to use.
|
|
@type count: int (optional)
|
|
@param count: must be between 1 - 8
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current number of processors for the scene.
|
|
"""
|
|
|
|
def enableGameFrameStretch():
|
|
"""
|
|
Enable stretch or squeeze the viewport to fill the display window.
|
|
"""
|
|
|
|
def enableGameFrameExpose():
|
|
"""
|
|
Enable show the entire viewport in the display window, viewing more
|
|
horizontally or vertically.
|
|
"""
|
|
|
|
def enableGameFrameBars():
|
|
"""
|
|
Enable show the entire viewport in the display window, using bar
|
|
horizontally or vertically.
|
|
"""
|
|
|
|
def setGameFrameColor(red, green, blue):
|
|
"""
|
|
Set the red, green, blue component of the bars.
|
|
@type red: float
|
|
@param red: must be between 0 - 1.0
|
|
@type green: float
|
|
@param green: must be between 0 - 1.0
|
|
@type blue: float
|
|
@param blue: must be between 0 - 1.0
|
|
"""
|
|
|
|
def getGameFrameColor():
|
|
"""
|
|
Set the red, green, blue component of the bars.
|
|
@rtype: string
|
|
@return: A string representing the color component of the bars.
|
|
"""
|
|
|
|
def gammaLevel(level = None):
|
|
"""
|
|
Get/set the gamma value for blending oversampled images (1.0 = no correction).
|
|
Unified renderer must be enabled.
|
|
@type level: float (optional)
|
|
@param level: must be between 0.2 - 5.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current gamma value for the scene.
|
|
"""
|
|
|
|
def postProcessAdd(add = None):
|
|
"""
|
|
Get/set post processing add.
|
|
Unified renderer must be enabled.
|
|
@type add: float (optional)
|
|
@param add: must be between -1.0 - 1.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current processing add value for the scene.
|
|
"""
|
|
|
|
def postProcessMultiply(mult = None):
|
|
"""
|
|
Get/set post processing multiply.
|
|
Unified renderer must be enabled.
|
|
@type mult: float (optional)
|
|
@param mult: must be between 0.01 - 4.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current processing multiply value for the scene.
|
|
"""
|
|
|
|
def postProcessGamma(gamma = None):
|
|
"""
|
|
Get/set post processing gamma.
|
|
Unified renderer must be enabled.
|
|
@type gamma: float (optional)
|
|
@param gamma: must be between 0.2 - 2.0
|
|
@rtype: float (if prototype is empty)
|
|
@return: Current processing gamma value for the scene.
|
|
"""
|
|
|
|
def SGIMaxsize(size = None):
|
|
"""
|
|
Get/set maximum size per frame to save in an SGI movie.
|
|
SGI must be defined on your machine.
|
|
@type size: int (optional)
|
|
@param size: must be between 0 - 500
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current SGI maximum size per frame for the scene.
|
|
"""
|
|
|
|
def enableSGICosmo(toggle):
|
|
"""
|
|
Enable/disable attempt to save SGI movies using Cosmo hardware
|
|
SGI must be defined on your machine.
|
|
@type toggle: int
|
|
@param toggle: pass 1 for on / 0 for off
|
|
"""
|
|
|
|
def oldMapValue(value = None):
|
|
"""
|
|
Get/set specify old map value in frames.
|
|
@type value: int (optional)
|
|
@param value: must be between 1 - 900
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current old map value for the scene.
|
|
"""
|
|
|
|
def newMapValue(value = None):
|
|
"""
|
|
Get/set specify new map value in frames.
|
|
@type value: int (optional)
|
|
@param value: must be between 1 - 900
|
|
@rtype: int (if prototype is empty)
|
|
@return: Current new map value for the scene.
|
|
"""
|