diff options
author | Campbell Barton <ideasman42@gmail.com> | 2010-07-13 02:11:44 +0400 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2010-07-13 02:11:44 +0400 |
commit | fd560e86970e1e9f34e24bf09aa2ab6ab554e0b5 (patch) | |
tree | 6fe7a232bf846481e5b2423c37185429004cd11c /source/blender/makesrna | |
parent | 64091ff5bd6258cd05cf4b1d96da22cb3aef6976 (diff) |
unmodified property names ready for editing (all props excluding bools)
Diffstat (limited to 'source/blender/makesrna')
-rw-r--r-- | source/blender/makesrna/rna_cleanup/rna_properties.txt | 3190 |
1 files changed, 3190 insertions, 0 deletions
diff --git a/source/blender/makesrna/rna_cleanup/rna_properties.txt b/source/blender/makesrna/rna_cleanup/rna_properties.txt new file mode 100644 index 00000000000..4ea22e422b0 --- /dev/null +++ b/source/blender/makesrna/rna_cleanup/rna_properties.txt @@ -0,0 +1,3190 @@ +Action.fcurves -> fcurves: collection, (read-only) The individual F-Curves that make up the Action +Action.groups -> groups: collection, (read-only) Convenient groupings of F-Curves +Action.pose_markers -> pose_markers: collection, (read-only) Markers specific to this Action, for labeling poses +ActionActuator.action -> action: pointer +ActionActuator.blendin -> blendin: int Number of frames of motion blending +ActionActuator.frame_end -> frame_end: int +ActionActuator.frame_property -> frame_property: string Assign the action's current frame number to this property +ActionActuator.frame_start -> frame_start: int +ActionActuator.mode -> mode: enum Action playback type +ActionActuator.priority -> priority: int Execution priority - lower numbers will override actions with higher numbers. With 2 or more actions at once, the overriding channels must be lower in the stack +ActionActuator.property -> property: string Use this property to define the Action position +ActionConstraint.action -> action: pointer +ActionConstraint.frame_end -> frame_end: int Last frame of the Action to use +ActionConstraint.frame_start -> frame_start: int First frame of the Action to use +ActionConstraint.maximum -> maximum: float Maximum value for target channel range +ActionConstraint.minimum -> minimum: float Minimum value for target channel range +ActionConstraint.subtarget -> subtarget: string +ActionConstraint.target -> target: pointer Target Object +ActionConstraint.transform_channel -> transform_channel: enum Transformation channel from the target that is used to key the Action +ActionGroup.channels -> channels: collection, (read-only) F-Curves in this group +ActionGroup.custom_color -> custom_color: int Index of custom color set +ActionGroup.name -> name: string +Actuator.name -> name: string +Actuator.type -> type: enum +ActuatorSensor.actuator -> actuator: string Actuator name, actuator active state modifications will be detected +Addon.module -> module: string Module name +AnimData.action -> action: pointer Active Action for this datablock +AnimData.action_blending -> action_blending: enum Method used for combining Active Action's result with result of NLA stack +AnimData.action_extrapolation -> action_extrapolation: enum Action to take for gaps past the Active Action's range (when evaluating with NLA) +AnimData.action_influence -> action_influence: float Amount the Active Action contributes to the result of the NLA stack +AnimData.drivers -> drivers: collection, (read-only) The Drivers/Expressions for this datablock +AnimData.nla_tracks -> nla_tracks: collection, (read-only) NLA Tracks (i.e. Animation Layers) +AnimViz.motion_paths -> motion_paths: pointer, (read-only) Motion Path settings for visualisation +AnimViz.onion_skinning -> onion_skinning: pointer, (read-only) Onion Skinning (ghosting) settings for visualisation +AnimVizMotionPaths.after_current -> after_current: int Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method) +AnimVizMotionPaths.bake_location -> bake_location: enum When calculating Bone Paths, use Head or Tips +AnimVizMotionPaths.before_current -> before_current: int Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method) +AnimVizMotionPaths.frame_end -> frame_end: int End frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method) +AnimVizMotionPaths.frame_start -> frame_start: int Starting frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method) +AnimVizMotionPaths.frame_step -> frame_step: int Number of frames between paths shown (not for 'On Keyframes' Onion-skinning method) +AnimVizMotionPaths.type -> type: enum Type of range to show for Motion Paths +AnimVizOnionSkinning.after_current -> after_current: int Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method) +AnimVizOnionSkinning.before_current -> before_current: int Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method) +AnimVizOnionSkinning.frame_end -> frame_end: int End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method) +AnimVizOnionSkinning.frame_start -> frame_start: int Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method) +AnimVizOnionSkinning.frame_step -> frame_step: int Number of frames between ghosts shown (not for 'On Keyframes' Onion-skinning method) +AnimVizOnionSkinning.type -> type: enum Method used for determining what ghosts get drawn +Area.active_space -> active_space: pointer, (read-only) Space currently being displayed in this area +Area.regions -> regions: collection, (read-only) Regions this area is subdivided in +Area.spaces -> spaces: collection, (read-only) Spaces contained in this area, the first space is active +Area.type -> type: enum Space type +AreaLamp.gamma -> gamma: float Light gamma correction value +AreaLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold: float Threshold for Adaptive Sampling (Raytraced shadows) +AreaLamp.shadow_color -> shadow_color: float Color of shadows cast by the lamp +AreaLamp.shadow_method -> shadow_method: enum Method to compute lamp shadow with +AreaLamp.shadow_ray_samples_x -> shadow_ray_samples_x: int Amount of samples taken extra (samples x samples) +AreaLamp.shadow_ray_samples_y -> shadow_ray_samples_y: int Amount of samples taken extra (samples x samples) +AreaLamp.shadow_ray_sampling_method -> shadow_ray_sampling_method: enum Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower +AreaLamp.shadow_soft_size -> shadow_soft_size: float Light size for ray shadow sampling (Raytraced shadows) +AreaLamp.shape -> shape: enum Shape of the area lamp +AreaLamp.size -> size: float Size of the area of the area Lamp, X direction size for Rectangle shapes +AreaLamp.size_y -> size_y: float Size of the area of the area Lamp in the Y direction for Rectangle shapes +Armature.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Armature.bones -> bones: collection, (read-only) +Armature.drawtype -> drawtype: enum +Armature.edit_bones -> edit_bones: collection, (read-only) +Armature.ghost_frame_end -> ghost_frame_end: int End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method) +Armature.ghost_frame_start -> ghost_frame_start: int Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method) +Armature.ghost_size -> ghost_size: int Frame step for Ghosts (not for 'On Keyframes' Onion-skinning method) +Armature.ghost_step -> ghost_step: int Number of frame steps on either side of current frame to show as ghosts (only for 'Around Current Frame' Onion-skinning method) +Armature.ghost_type -> ghost_type: enum Method of Onion-skinning for active Action +Armature.pose_position -> pose_position: enum Show armature in binding pose or final posed state +ArmatureActuator.bone -> bone: string Bone on which the constraint is defined +ArmatureActuator.constraint -> constraint: string Name of the constraint you want to control +ArmatureActuator.mode -> mode: enum +ArmatureActuator.secondary_target -> secondary_target: pointer Set weight of this constraint +ArmatureActuator.target -> target: pointer Set this object as the target of the constraint +ArmatureActuator.weight -> weight: float Set weight of this constraint +ArmatureBones.active -> active: pointer Armatures active bone +ArmatureEditBones.active -> active: pointer Armatures active edit bone +ArmatureModifier.object -> object: pointer Armature object to deform with +ArmatureModifier.vertex_group -> vertex_group: string Vertex group name +ArmatureSensor.bone -> bone: string Identify the bone to check value from +ArmatureSensor.constraint -> constraint: string Identify the bone constraint to check value from +ArmatureSensor.test_type -> test_type: enum Type of value and test +ArmatureSensor.value -> value: float Specify value to be used in comparison +ArrayModifier.constant_offset_displacement -> constant_offset_displacement: float +ArrayModifier.count -> count: int Number of duplicates to make +ArrayModifier.curve -> curve: pointer Curve object to fit array length to +ArrayModifier.end_cap -> end_cap: pointer Mesh object to use as an end cap +ArrayModifier.fit_type -> fit_type: enum Array length calculation method +ArrayModifier.length -> length: float Length to fit array within +ArrayModifier.merge_distance -> merge_distance: float Limit below which to merge vertices +ArrayModifier.offset_object -> offset_object: pointer +ArrayModifier.relative_offset_displacement -> relative_offset_displacement: float +ArrayModifier.start_cap -> start_cap: pointer Mesh object to use as a start cap +BackgroundImage.image -> image: pointer Image displayed and edited in this space +BackgroundImage.image_user -> image_user: pointer, (read-only) Parameters defining which layer, pass and frame of the image is displayed +BackgroundImage.offset_x -> offset_x: float Offsets image horizontally from the world origin +BackgroundImage.offset_y -> offset_y: float Offsets image vertically from the world origin +BackgroundImage.size -> size: float Scaling factor for the background image +BackgroundImage.transparency -> transparency: float Amount to blend the image against the background color +BackgroundImage.view_axis -> view_axis: enum The axis to display the image on +BevelModifier.angle -> angle: float Angle above which to bevel edges +BevelModifier.edge_weight_method -> edge_weight_method: enum What edge weight to use for weighting a vertex +BevelModifier.limit_method -> limit_method: enum +BevelModifier.width -> width: float Bevel value/amount +BezierSplinePoint.co -> co: float Coordinates of the control point +BezierSplinePoint.handle1 -> handle1: float Coordinates of the first handle +BezierSplinePoint.handle1_type -> handle1_type: enum Handle types +BezierSplinePoint.handle2 -> handle2: float Coordinates of the second handle +BezierSplinePoint.handle2_type -> handle2_type: enum Handle types +BezierSplinePoint.radius -> radius: float, (read-only) Radius for bevelling +BezierSplinePoint.tilt -> tilt: float Tilt in 3D View +BezierSplinePoint.weight -> weight: float Softbody goal weight +BlendTexture.flip_axis -> flip_axis: enum Flips the texture's X and Y axis +BlendTexture.progression -> progression: enum Sets the style of the color blending +BlenderRNA.structs -> structs: collection, (read-only) +BoidRule.name -> name: string Boid rule name +BoidRule.type -> type: enum, (read-only) +BoidRuleAverageSpeed.level -> level: float How much velocity's z-component is kept constant +BoidRuleAverageSpeed.speed -> speed: float Percentage of maximum speed +BoidRuleAverageSpeed.wander -> wander: float How fast velocity's direction is randomized +BoidRuleAvoid.fear_factor -> fear_factor: float Avoid object if danger from it is above this threshold +BoidRuleAvoid.object -> object: pointer Object to avoid +BoidRuleAvoidCollision.look_ahead -> look_ahead: float Time to look ahead in seconds +BoidRuleFight.distance -> distance: float Attack boids at max this distance +BoidRuleFight.flee_distance -> flee_distance: float Flee to this distance +BoidRuleFollowLeader.distance -> distance: float Distance behind leader to follow +BoidRuleFollowLeader.object -> object: pointer Follow this object instead of a boid +BoidRuleFollowLeader.queue_size -> queue_size: int How many boids in a line +BoidRuleGoal.object -> object: pointer Goal object +BoidSettings.accuracy -> accuracy: float Accuracy of attack +BoidSettings.active_boid_state -> active_boid_state: pointer, (read-only) +BoidSettings.active_boid_state_index -> active_boid_state_index: int +BoidSettings.aggression -> aggression: float Boid will fight this times stronger enemy +BoidSettings.air_max_acc -> air_max_acc: float Maximum acceleration in air (relative to maximum speed) +BoidSettings.air_max_ave -> air_max_ave: float Maximum angular velocity in air (relative to 180 degrees) +BoidSettings.air_max_speed -> air_max_speed: float Maximum speed in air +BoidSettings.air_min_speed -> air_min_speed: float Minimum speed in air (relative to maximum speed) +BoidSettings.air_personal_space -> air_personal_space: float Radius of boids personal space in air (% of particle size) +BoidSettings.banking -> banking: float Amount of rotation around velocity vector on turns +BoidSettings.health -> health: float Initial boid health when born +BoidSettings.height -> height: float Boid height relative to particle size +BoidSettings.land_jump_speed -> land_jump_speed: float Maximum speed for jumping +BoidSettings.land_max_acc -> land_max_acc: float Maximum acceleration on land (relative to maximum speed) +BoidSettings.land_max_ave -> land_max_ave: float Maximum angular velocity on land (relative to 180 degrees) +BoidSettings.land_max_speed -> land_max_speed: float Maximum speed on land +BoidSettings.land_personal_space -> land_personal_space: float Radius of boids personal space on land (% of particle size) +BoidSettings.land_stick_force -> land_stick_force: float How strong a force must be to start effecting a boid on land +BoidSettings.landing_smoothness -> landing_smoothness: float How smoothly the boids land +BoidSettings.range -> range: float The maximum distance from which a boid can attack +BoidSettings.states -> states: collection, (read-only) +BoidSettings.strength -> strength: float Maximum caused damage on attack per second +BoidState.active_boid_rule -> active_boid_rule: pointer, (read-only) +BoidState.active_boid_rule_index -> active_boid_rule_index: int +BoidState.falloff -> falloff: float +BoidState.name -> name: string Boid state name +BoidState.rule_fuzziness -> rule_fuzziness: float +BoidState.rules -> rules: collection, (read-only) +BoidState.ruleset_type -> ruleset_type: enum How the rules in the list are evaluated +BoidState.volume -> volume: float +Bone.bbone_in -> bbone_in: float Length of first Bezier Handle (for B-Bones only) +Bone.bbone_out -> bbone_out: float Length of second Bezier Handle (for B-Bones only) +Bone.bbone_segments -> bbone_segments: int Number of subdivisions of bone (for B-Bones only) +Bone.children -> children: collection, (read-only) Bones which are children of this bone +Bone.envelope_distance -> envelope_distance: float Bone deformation distance (for Envelope deform only) +Bone.envelope_weight -> envelope_weight: float Bone deformation weight (for Envelope deform only) +Bone.head -> head: float Location of head end of the bone relative to its parent +Bone.head_local -> head_local: float Location of head end of the bone relative to armature +Bone.head_radius -> head_radius: float Radius of head of bone (for Envelope deform only) +Bone.matrix -> matrix: float 3x3 bone matrix +Bone.matrix_local -> matrix_local: float 4x4 bone matrix relative to armature +Bone.name -> name: string +Bone.parent -> parent: pointer, (read-only) Parent bone (in same Armature) +Bone.tail -> tail: float Location of tail end of the bone +Bone.tail_local -> tail_local: float Location of tail end of the bone relative to armature +Bone.tail_radius -> tail_radius: float Radius of tail of bone (for Envelope deform only) +BoneGroup.color_set -> color_set: enum Custom color set to use +BoneGroup.colors -> colors: pointer, (read-only) Copy of the colors associated with the group's color set +BoneGroup.name -> name: string +BooleanModifier.object -> object: pointer Mesh object to use for Boolean operation +BooleanModifier.operation -> operation: enum +BooleanProperty.array_length -> array_length: int, (read-only) Maximum length of the array, 0 means unlimited +Brush.blend -> blend: enum Brush blending mode +Brush.clone_alpha -> clone_alpha: float Opacity of clone image display +Brush.clone_image -> clone_image: pointer Image for clone tool +Brush.clone_offset -> clone_offset: float +Brush.color -> color: float +Brush.curve -> curve: pointer, (read-only) Editable falloff curve +Brush.direction -> direction: enum Mapping type to use for this image in the game engine +Brush.imagepaint_tool -> imagepaint_tool: enum +Brush.jitter -> jitter: float Jitter the position of the brush while painting +Brush.rate -> rate: float Interval between paints for Airbrush +Brush.sculpt_tool -> sculpt_tool: enum +Brush.size -> size: int Diameter of the brush +Brush.smooth_stroke_factor -> smooth_stroke_factor: float Higher values give a smoother stroke +Brush.smooth_stroke_radius -> smooth_stroke_radius: int Minimum distance from last point before stroke continues +Brush.spacing -> spacing: float Spacing between brush stamps +Brush.strength -> strength: float The amount of pressure on the brush +Brush.texture -> texture: pointer +Brush.texture_slot -> texture_slot: pointer, (read-only) +Brush.vertexpaint_tool -> vertexpaint_tool: enum +BrushTextureSlot.angle -> angle: float Defines brush texture rotation +BrushTextureSlot.map_mode -> map_mode: enum +BuildModifier.frame_start -> frame_start: float Specify the start frame of the effect +BuildModifier.length -> length: float Specify the total time the build effect requires +BuildModifier.seed -> seed: int Specify the seed for random if used +Camera.angle -> angle: float Perspective Camera lens field of view in degrees +Camera.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Camera.clip_end -> clip_end: float Camera far clipping distance +Camera.clip_start -> clip_start: float Camera near clipping distance +Camera.dof_distance -> dof_distance: float Distance to the focus point for depth of field +Camera.dof_object -> dof_object: pointer Use this object to define the depth of field focal point +Camera.draw_size -> draw_size: float Apparent size of the Camera object in the 3D View +Camera.lens -> lens: float Perspective Camera lens value in millimeters +Camera.lens_unit -> lens_unit: enum Unit to edit lens in for the user interface +Camera.ortho_scale -> ortho_scale: float Orthographic Camera scale (similar to zoom) +Camera.passepartout_alpha -> passepartout_alpha: float Opacity (alpha) of the darkened overlay in Camera view +Camera.shift_x -> shift_x: float Perspective Camera horizontal shift +Camera.shift_y -> shift_y: float Perspective Camera vertical shift +Camera.type -> type: enum Camera types +CameraActuator.axis -> axis: enum Specify the axis the Camera will try to get behind +CameraActuator.height -> height: float +CameraActuator.max -> max: float +CameraActuator.min -> min: float +CameraActuator.object -> object: pointer Look at this Object +CastModifier.cast_type -> cast_type: enum +CastModifier.factor -> factor: float +CastModifier.object -> object: pointer Control object: if available, its location determines the center of the effect +CastModifier.radius -> radius: float Only deform vertices within this distance from the center of the effect (leave as 0 for infinite.) +CastModifier.size -> size: float Size of projection shape (leave as 0 for auto.) +CastModifier.vertex_group -> vertex_group: string Vertex group name +ChildOfConstraint.subtarget -> subtarget: string +ChildOfConstraint.target -> target: pointer Target Object +ClampToConstraint.main_axis -> main_axis: enum Main axis of movement +ClampToConstraint.target -> target: pointer Target Object +ClothCollisionSettings.collision_quality -> collision_quality: int How many collision iterations should be done. (higher is better quality but slower) +ClothCollisionSettings.friction -> friction: float Friction force if a collision happened. (higher = less movement) +ClothCollisionSettings.group -> group: pointer Limit colliders to this Group +ClothCollisionSettings.min_distance -> min_distance: float Minimum distance between collision objects before collision response takes in +ClothCollisionSettings.self_collision_quality -> self_collision_quality: int How many self collision iterations should be done. (higher is better quality but slower) +ClothCollisionSettings.self_friction -> self_friction: float Friction/damping with self contact +ClothCollisionSettings.self_min_distance -> self_min_distance: float 0.5 means no distance at all, 1.0 is maximum distance +ClothModifier.collision_settings -> collision_settings: pointer, (read-only) +ClothModifier.point_cache -> point_cache: pointer, (read-only) +ClothModifier.settings -> settings: pointer, (read-only) +ClothSettings.air_damping -> air_damping: float Air has normally some thickness which slows falling things down +ClothSettings.bending_stiffness -> bending_stiffness: float Wrinkle coefficient. (higher = less smaller but more big wrinkles) +ClothSettings.bending_stiffness_max -> bending_stiffness_max: float Maximum bending stiffness value +ClothSettings.bending_vertex_group -> bending_vertex_group: string Vertex group for fine control over bending stiffness +ClothSettings.collider_friction -> collider_friction: float +ClothSettings.effector_weights -> effector_weights: pointer, (read-only) +ClothSettings.goal_default -> goal_default: float Default Goal (vertex target position) value, when no Vertex Group used +ClothSettings.goal_friction -> goal_friction: float Goal (vertex target position) friction +ClothSettings.goal_max -> goal_max: float Goal maximum, vertex group weights are scaled to match this range +ClothSettings.goal_min -> goal_min: float Goal minimum, vertex group weights are scaled to match this range +ClothSettings.goal_spring -> goal_spring: float Goal (vertex target position) spring stiffness +ClothSettings.gravity -> gravity: float Gravity or external force vector +ClothSettings.internal_friction -> internal_friction: float +ClothSettings.mass -> mass: float Mass of cloth material +ClothSettings.mass_vertex_group -> mass_vertex_group: string Vertex Group for pinning of vertices +ClothSettings.pin_stiffness -> pin_stiffness: float Pin (vertex target position) spring stiffness +ClothSettings.pre_roll -> pre_roll: int Simulation starts on this frame +ClothSettings.quality -> quality: int Quality of the simulation in steps per frame. (higher is better quality but slower) +ClothSettings.rest_shape_key -> rest_shape_key: pointer Shape key to use the rest spring lengths from +ClothSettings.spring_damping -> spring_damping: float Damping of cloth velocity. (higher = more smooth, less jiggling) +ClothSettings.structural_stiffness -> structural_stiffness: float Overall stiffness of structure +ClothSettings.structural_stiffness_max -> structural_stiffness_max: float Maximum structural stiffness value +ClothSettings.structural_stiffness_vertex_group -> structural_stiffness_vertex_group: string Vertex group for fine control over structural stiffness +CloudsTexture.nabla -> nabla: float Size of derivative offset used for calculating normal +CloudsTexture.noise_basis -> noise_basis: enum Sets the noise basis used for turbulence +CloudsTexture.noise_depth -> noise_depth: int Sets the depth of the cloud calculation +CloudsTexture.noise_size -> noise_size: float Sets scaling for noise input +CloudsTexture.noise_type -> noise_type: enum +CloudsTexture.stype -> stype: enum +CollectionProperty.fixed_type -> fixed_type: pointer, (read-only) Fixed pointer type, empty if variable type +CollisionModifier.settings -> settings: pointer, (read-only) +CollisionSensor.material -> material: string Only look for Objects with this material +CollisionSensor.property -> property: string Only look for Objects with this property +CollisionSettings.absorption -> absorption: float How much of effector force gets lost during collision with this object (in percent) +CollisionSettings.damping -> damping: float Amount of damping during collision +CollisionSettings.damping_factor -> damping_factor: float Amount of damping during particle collision +CollisionSettings.friction_factor -> friction_factor: float Amount of friction during particle collision +CollisionSettings.inner_thickness -> inner_thickness: float Inner face thickness +CollisionSettings.outer_thickness -> outer_thickness: float Outer face thickness +CollisionSettings.permeability -> permeability: float Chance that the particle will pass through the mesh +CollisionSettings.random_damping -> random_damping: float Random variation of damping +CollisionSettings.random_friction -> random_friction: float Random variation of friction +CollisionSettings.stickness -> stickness: float Amount of stickness to surface collision +ColorRamp.elements -> elements: collection, (read-only) +ColorRamp.interpolation -> interpolation: enum +ColorRampElement.color -> color: float +ColorRampElement.position -> position: float +ColorSequence.color -> color: float +CompositorNode.type -> type: enum, (read-only) +CompositorNodeAlphaOver.premul -> premul: float Mix Factor +CompositorNodeBilateralblur.iterations -> iterations: int +CompositorNodeBilateralblur.sigma_color -> sigma_color: float +CompositorNodeBilateralblur.sigma_space -> sigma_space: float +CompositorNodeBlur.factor -> factor: float +CompositorNodeBlur.factor_x -> factor_x: float +CompositorNodeBlur.factor_y -> factor_y: float +CompositorNodeBlur.filter_type -> filter_type: enum +CompositorNodeBlur.sizex -> sizex: int +CompositorNodeBlur.sizey -> sizey: int +CompositorNodeChannelMatte.algorithm -> algorithm: enum Algorithm to use to limit channel +CompositorNodeChannelMatte.channel -> channel: enum Channel used to determine matte +CompositorNodeChannelMatte.color_space -> color_space: enum +CompositorNodeChannelMatte.high -> high: float Values higher than this setting are 100% opaque +CompositorNodeChannelMatte.limit_channel -> limit_channel: enum Limit by this channels value +CompositorNodeChannelMatte.low -> low: float Values lower than this setting are 100% keyed +CompositorNodeChromaMatte.acceptance -> acceptance: float Tolerance for a color to be considered a keying color +CompositorNodeChromaMatte.cutoff -> cutoff: float Tolerance below which colors will be considered as exact matches +CompositorNodeChromaMatte.gain -> gain: float Alpha gain +CompositorNodeChromaMatte.lift -> lift: float Alpha lift +CompositorNodeChromaMatte.shadow_adjust -> shadow_adjust: float Adjusts the brightness of any shadows captured +CompositorNodeColorBalance.correction_formula -> correction_formula: enum +CompositorNodeColorBalance.gain -> gain: float Correction for Highlights +CompositorNodeColorBalance.gamma -> gamma: float Correction for Midtones +CompositorNodeColorBalance.lift -> lift: float Correction for Shadows +CompositorNodeColorBalance.offset -> offset: float Correction for Shadows +CompositorNodeColorBalance.power -> power: float Correction for Midtones +CompositorNodeColorBalance.slope -> slope: float Correction for Highlights +CompositorNodeColorMatte.h -> h: float Hue tolerance for colors to be considered a keying color +CompositorNodeColorMatte.s -> s: float Saturation Tolerance for the color +CompositorNodeColorMatte.v -> v: float Value Tolerance for the color +CompositorNodeColorSpill.algorithm -> algorithm: enum +CompositorNodeColorSpill.channel -> channel: enum +CompositorNodeColorSpill.limit_channel -> limit_channel: enum +CompositorNodeColorSpill.ratio -> ratio: float Scale limit by value +CompositorNodeColorSpill.unspill_blue -> unspill_blue: float Blue spillmap scale +CompositorNodeColorSpill.unspill_green -> unspill_green: float Green spillmap scale +CompositorNodeColorSpill.unspill_red -> unspill_red: float Red spillmap scale +CompositorNodeCrop.x1 -> x1: int +CompositorNodeCrop.x2 -> x2: int +CompositorNodeCrop.y1 -> y1: int +CompositorNodeCrop.y2 -> y2: int +CompositorNodeCurveRGB.mapping -> mapping: pointer, (read-only) +CompositorNodeCurveVec.mapping -> mapping: pointer, (read-only) +CompositorNodeDBlur.angle -> angle: float +CompositorNodeDBlur.center_x -> center_x: float +CompositorNodeDBlur.center_y -> center_y: float +CompositorNodeDBlur.distance -> distance: float +CompositorNodeDBlur.iterations -> iterations: int +CompositorNodeDBlur.spin -> spin: float +CompositorNodeDBlur.zoom -> zoom: float +CompositorNodeDefocus.angle -> angle: int Bokeh shape rotation offset in degrees +CompositorNodeDefocus.bokeh -> bokeh: enum +CompositorNodeDefocus.f_stop -> f_stop: float Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius +CompositorNodeDefocus.max_blur -> max_blur: float blur limit, maximum CoC radius, 0=no limit +CompositorNodeDefocus.samples -> samples: int Number of samples (16=grainy, higher=less noise) +CompositorNodeDefocus.threshold -> threshold: float CoC radius threshold, prevents background bleed on in-focus midground, 0=off +CompositorNodeDefocus.z_scale -> z_scale: float Scales the Z input when not using a zbuffer, controls maximum blur designated by the color white or input value 1 +CompositorNodeDiffMatte.falloff -> falloff: float Color distances below this additional threshold are partially keyed +CompositorNodeDiffMatte.tolerance -> tolerance: float Color distances below this threshold are keyed +CompositorNodeDilateErode.distance -> distance: int Distance to grow/shrink (number of iterations) +CompositorNodeDistanceMatte.falloff -> falloff: float Color distances below this additional threshold are partially keyed +CompositorNodeDistanceMatte.tolerance -> tolerance: float Color distances below this threshold are keyed +CompositorNodeFilter.filter_type -> filter_type: enum +CompositorNodeFlip.axis -> axis: enum +CompositorNodeGlare.angle_offset -> angle_offset: float Streak angle offset in degrees +CompositorNodeGlare.color_modulation -> color_modulation: float Amount of Color Modulation, modulates colors of streaks and ghosts for a spectral dispersion effect +CompositorNodeGlare.fade -> fade: float Streak fade-out factor +CompositorNodeGlare.glare_type -> glare_type: enum +CompositorNodeGlare.iterations -> iterations: int +CompositorNodeGlare.mix -> mix: float -1 is original image only, 0 is exact 50/50 mix, 1 is processed image only +CompositorNodeGlare.quality -> quality: enum If not set to high quality, the effect will be applied to a low-res copy of the source image +CompositorNodeGlare.size -> size: int Glow/glare size (not actual size; relative to initial size of bright area of pixels) +CompositorNodeGlare.streaks -> streaks: int Total number of streaks +CompositorNodeGlare.threshold -> threshold: float The glare filter will only be applied to pixels brighter than this value +CompositorNodeHueCorrect.mapping -> mapping: pointer, (read-only) +CompositorNodeHueSat.hue -> hue: float +CompositorNodeHueSat.sat -> sat: float +CompositorNodeHueSat.val -> val: float +CompositorNodeIDMask.index -> index: int Pass index number to convert to alpha +CompositorNodeImage.frames -> frames: int Number of images used in animation +CompositorNodeImage.image -> image: pointer +CompositorNodeImage.layer -> layer: enum +CompositorNodeImage.offset -> offset: int Offsets the number of the frame to use in the animation +CompositorNodeImage.start -> start: int +CompositorNodeLevels.channel -> channel: enum +CompositorNodeLumaMatte.high -> high: float Values higher than this setting are 100% opaque +CompositorNodeLumaMatte.low -> low: float Values lower than this setting are 100% keyed +CompositorNodeMapUV.alpha -> alpha: int +CompositorNodeMapValue.max -> max: float +CompositorNodeMapValue.min -> min: float +CompositorNodeMapValue.offset -> offset: float +CompositorNodeMapValue.size -> size: float +CompositorNodeMath.operation -> operation: enum +CompositorNodeMixRGB.blend_type -> blend_type: enum +CompositorNodeOutputFile.exr_codec -> exr_codec: enum +CompositorNodeOutputFile.filepath -> filepath: string Output path for the image, same functionality as render output. +CompositorNodeOutputFile.frame_end -> frame_end: int +CompositorNodeOutputFile.frame_start -> frame_start: int +CompositorNodeOutputFile.image_type -> image_type: enum +CompositorNodeOutputFile.quality -> quality: int +CompositorNodePremulKey.mapping -> mapping: enum Conversion between premultiplied alpha and key alpha +CompositorNodeRLayers.layer -> layer: enum +CompositorNodeRLayers.scene -> scene: pointer +CompositorNodeRotate.filter -> filter: enum Method to use to filter rotation +CompositorNodeScale.space -> space: enum Coordinate space to scale relative to +CompositorNodeSplitViewer.axis -> axis: enum +CompositorNodeSplitViewer.factor -> factor: int +CompositorNodeTexture.node_output -> node_output: int For node-based textures, which output node to use +CompositorNodeTexture.texture -> texture: pointer +CompositorNodeTime.curve -> curve: pointer, (read-only) +CompositorNodeTime.end -> end: int +CompositorNodeTime.start -> start: int +CompositorNodeTonemap.adaptation -> adaptation: float If 0, global; if 1, based on pixel intensity +CompositorNodeTonemap.contrast -> contrast: float Set to 0 to use estimate from input image +CompositorNodeTonemap.correction -> correction: float If 0, same for all channels; if 1, each independent +CompositorNodeTonemap.gamma -> gamma: float If not used, set to 1 +CompositorNodeTonemap.intensity -> intensity: float If less than zero, darkens image; otherwise, makes it brighter +CompositorNodeTonemap.key -> key: float The value the average luminance is mapped to +CompositorNodeTonemap.offset -> offset: float Normally always 1, but can be used as an extra control to alter the brightness curve +CompositorNodeTonemap.tonemap_type -> tonemap_type: enum +CompositorNodeValToRGB.color_ramp -> color_ramp: pointer, (read-only) +CompositorNodeVecBlur.factor -> factor: float Scaling factor for motion vectors; actually 'shutter speed' in frames +CompositorNodeVecBlur.max_speed -> max_speed: int Maximum speed, or zero for none +CompositorNodeVecBlur.min_speed -> min_speed: int Minimum speed for a pixel to be blurred; used to separate background from foreground +CompositorNodeVecBlur.samples -> samples: int +ConsoleLine.current_character -> current_character: int +ConsoleLine.line -> line: string Text in the line +Constraint.influence -> influence: float Amount of influence constraint will have on the final solution +Constraint.lin_error -> lin_error: float, (read-only) Amount of residual error in Blender space unit for constraints that work on position +Constraint.name -> name: string Constraint name +Constraint.owner_space -> owner_space: enum Space that owner is evaluated in +Constraint.rot_error -> rot_error: float, (read-only) Amount of residual error in radiant for constraints that work on orientation +Constraint.target_space -> target_space: enum Space that target is evaluated in +Constraint.type -> type: enum, (read-only) +ConstraintActuator.damping -> damping: int Damping factor: time constant (in frame) of low pass filter +ConstraintActuator.damping_rotation -> damping_rotation: int Use a different damping for orientation +ConstraintActuator.direction -> direction: enum Set the direction of the ray +ConstraintActuator.direction_axis -> direction_axis: enum Select the axis to be aligned along the reference direction +ConstraintActuator.distance -> distance: float Set the maximum length of ray +ConstraintActuator.fh_damping -> fh_damping: float Damping factor of the Fh spring force +ConstraintActuator.fh_height -> fh_height: float Height of the Fh area +ConstraintActuator.limit -> limit: enum +ConstraintActuator.limit_max -> limit_max: float +ConstraintActuator.limit_min -> limit_min: float +ConstraintActuator.material -> material: string Ray detects only Objects with this material +ConstraintActuator.max_angle -> max_angle: float Maximum angle (in degree) allowed with target direction. No correction is done if angle with target direction is between min and max +ConstraintActuator.max_rotation -> max_rotation: float Reference Direction +ConstraintActuator.min_angle -> min_angle: float Minimum angle (in degree) to maintain with target direction. No correction is done if angle with target direction is between min and max +ConstraintActuator.mode -> mode: enum The type of the constraint +ConstraintActuator.property -> property: string Ray detect only Objects with this property +ConstraintActuator.range -> range: float Set the maximum length of ray +ConstraintActuator.spring -> spring: float Spring force within the Fh area +ConstraintActuator.time -> time: int Maximum activation time in frame, 0 for unlimited +ConstraintTarget.subtarget -> subtarget: string +ConstraintTarget.target -> target: pointer Target Object +Context.area -> area: pointer, (read-only) +Context.main -> main: pointer, (read-only) +Context.manager -> manager: pointer, (read-only) +Context.mode -> mode: enum, (read-only) +Context.region -> region: pointer, (read-only) +Context.scene -> scene: pointer, (read-only) +Context.screen -> screen: pointer, (read-only) +Context.space_data -> space_data: pointer, (read-only) +Context.tool_settings -> tool_settings: pointer, (read-only) +Context.user_preferences -> user_preferences: pointer, (read-only) +Context.window -> window: pointer, (read-only) +ControlFluidSettings.attraction_radius -> attraction_radius: float Specifies the force field radius around the control object +ControlFluidSettings.attraction_strength -> attraction_strength: float Force strength for directional attraction towards the control object +ControlFluidSettings.end_time -> end_time: float Specifies time when the control particles are deactivated +ControlFluidSettings.quality -> quality: float Specifies the quality which is used for object sampling. (higher = better but slower) +ControlFluidSettings.start_time -> start_time: float Specifies time when the control particles are activated +ControlFluidSettings.velocity_radius -> velocity_radius: float Specifies the force field radius around the control object +ControlFluidSettings.velocity_strength -> velocity_strength: float Force strength of how much of the control object's velocity is influencing the fluid velocity +Controller.name -> name: string +Controller.state_number -> state_number: int Set Controller state index (1 to 30) +Controller.type -> type: enum +CopyLocationConstraint.head_tail -> head_tail: float Target along length of bone: Head=0, Tail=1 +CopyLocationConstraint.subtarget -> subtarget: string +CopyLocationConstraint.target -> target: pointer Target Object +CopyRotationConstraint.subtarget -> subtarget: string +CopyRotationConstraint.target -> target: pointer Target Object +CopyScaleConstraint.subtarget -> subtarget: string +CopyScaleConstraint.target -> target: pointer Target Object +CopyTransformsConstraint.head_tail -> head_tail: float Target along length of bone: Head=0, Tail=1 +CopyTransformsConstraint.subtarget -> subtarget: string +CopyTransformsConstraint.target -> target: pointer Target Object +Curve.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Curve.bevel_depth -> bevel_depth: float Bevel depth when not using a bevel object +Curve.bevel_object -> bevel_object: pointer Curve object name that defines the bevel shape +Curve.bevel_resolution -> bevel_resolution: int Bevel resolution when depth is non-zero and no specific bevel object has been defined +Curve.dimensions -> dimensions: enum Select 2D or 3D curve type +Curve.eval_time -> eval_time: float Parametric position along the length of the curve that Objects 'following' it should be at. Position is evaluated by dividing by the 'Path Length' value +Curve.extrude -> extrude: float Amount of curve extrusion when not using a bevel object +Curve.materials -> materials: collection, (read-only) +Curve.path_length -> path_length: int The number of frames that are needed to traverse the path, defining the maximum value for the 'Evaluation Time' setting +Curve.render_resolution_u -> render_resolution_u: int Surface resolution in U direction used while rendering. Zero skips this property +Curve.render_resolution_v -> render_resolution_v: int Surface resolution in V direction used while rendering. Zero skips this property +Curve.resolution_u -> resolution_u: int Surface resolution in U direction +Curve.resolution_v -> resolution_v: int Surface resolution in V direction +Curve.shape_keys -> shape_keys: pointer, (read-only) +Curve.splines -> splines: collection, (read-only) Collection of splines in this curve data object +Curve.taper_object -> taper_object: pointer Curve object name that defines the taper (width) +Curve.texspace_loc -> texspace_loc: float Texture space location +Curve.texspace_size -> texspace_size: float Texture space size +Curve.twist_mode -> twist_mode: enum The type of tilt calculation for 3D Curves +Curve.twist_smooth -> twist_smooth: float Smoothing iteration for tangents +Curve.width -> width: float Scale the original width (1.0) based on given factor +CurveMap.extend -> extend: enum, (read-only) Extrapolate the curve or extend it horizontally +CurveMap.points -> points: collection, (read-only) +CurveMapPoint.handle_type -> handle_type: enum, (read-only) Curve interpolation at this point: bezier or vector +CurveMapPoint.location -> location: float, (read-only) X/Y coordinates of the curve point +CurveMapping.black_level -> black_level: float For RGB curves, the color that black is mapped to +CurveMapping.clip_max_x -> clip_max_x: float +CurveMapping.clip_max_y -> clip_max_y: float +CurveMapping.clip_min_x -> clip_min_x: float +CurveMapping.clip_min_y -> clip_min_y: float +CurveMapping.curves -> curves: collection, (read-only) +CurveMapping.white_level -> white_level: float For RGB curves, the color that white is mapped to +CurveModifier.deform_axis -> deform_axis: enum The axis that the curve deforms along +CurveModifier.object -> object: pointer Curve object to deform with +CurveModifier.vertex_group -> vertex_group: string Vertex group name +CurveSplines.active -> active: pointer Active curve spline +DampedTrackConstraint.subtarget -> subtarget: string +DampedTrackConstraint.target -> target: pointer Target Object +DampedTrackConstraint.track -> track: enum Axis that points to the target object +DecimateModifier.face_count -> face_count: int, (read-only) The current number of faces in the decimated mesh +DecimateModifier.ratio -> ratio: float Defines the ratio of triangles to reduce to +DelaySensor.delay -> delay: int Delay in number of logic tics before the positive trigger (default 60 per second) +DelaySensor.duration -> duration: int If >0, delay in number of logic tics before the negative trigger following the positive trigger +DisplaceModifier.direction -> direction: enum +DisplaceModifier.midlevel -> midlevel: float Material value that gives no displacement +DisplaceModifier.strength -> strength: float +DisplaceModifier.texture -> texture: pointer +DisplaceModifier.texture_coordinate_object -> texture_coordinate_object: pointer +DisplaceModifier.texture_coordinates -> texture_coordinates: enum +DisplaceModifier.uv_layer -> uv_layer: string UV layer name +DisplaceModifier.vertex_group -> vertex_group: string Vertex group name +DistortedNoiseTexture.distortion -> distortion: float +DistortedNoiseTexture.nabla -> nabla: float Size of derivative offset used for calculating normal +DistortedNoiseTexture.noise_basis -> noise_basis: enum Sets the noise basis used for turbulence +DistortedNoiseTexture.noise_distortion -> noise_distortion: enum Sets the noise basis for the distortion +DistortedNoiseTexture.noise_size -> noise_size: float Sets scaling for noise input +DomainFluidSettings.compressibility -> compressibility: float Allowed compressibility due to gravitational force for standing fluid. (directly affects simulation step size) +DomainFluidSettings.end_time -> end_time: float Simulation time of the last blender frame +DomainFluidSettings.generate_particles -> generate_particles: float Amount of particles to generate (0=off, 1=normal, >1=more) +DomainFluidSettings.gravity -> gravity: float Gravity in X, Y and Z direction +DomainFluidSettings.grid_levels -> grid_levels: int Number of coarsened grids to use (-1 for automatic) +DomainFluidSettings.memory_estimate -> memory_estimate: string, (read-only) Estimated amount of memory needed for baking the domain +DomainFluidSettings.partial_slip_factor -> partial_slip_factor: float Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip +DomainFluidSettings.path -> path: string Directory (and/or filename prefix) to store baked fluid simulation files in +DomainFluidSettings.preview_resolution -> preview_resolution: int Preview resolution in X,Y and Z direction +DomainFluidSettings.real_world_size -> real_world_size: float Size of the simulation domain in metres +DomainFluidSettings.render_display_mode -> render_display_mode: enum How to display the mesh for rendering +DomainFluidSettings.resolution -> resolution: int Domain resolution in X,Y and Z direction +DomainFluidSettings.slip_type -> slip_type: enum +DomainFluidSettings.start_time -> start_time: float Simulation time of the first blender frame +DomainFluidSettings.surface_smoothing -> surface_smoothing: float Amount of surface smoothing. A value of 0 is off, 1 is normal smoothing and more than 1 is extra smoothing +DomainFluidSettings.surface_subdivisions -> surface_subdivisions: int Number of isosurface subdivisions. This is necessary for the inclusion of particles into the surface generation. Warning - can lead to longer computation times! +DomainFluidSettings.tracer_particles -> tracer_particles: int Number of tracer particles to generate +DomainFluidSettings.viewport_display_mode -> viewport_display_mode: enum How to display the mesh in the viewport +DomainFluidSettings.viscosity_base -> viscosity_base: float Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1) +DomainFluidSettings.viscosity_exponent -> viscosity_exponent: int Negative exponent for the viscosity value (to simplify entering small values e.g. 5*10^-6.) +DomainFluidSettings.viscosity_preset -> viscosity_preset: enum Set viscosity of the fluid to a preset value, or use manual input +DopeSheet.filtering_group -> filtering_group: pointer Group that included Object should be a member of +DopeSheet.source -> source: pointer, (read-only) ID-Block representing source data, currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil) +Driver.expression -> expression: string Expression to use for Scripted Expression +Driver.type -> type: enum Driver type +Driver.variables -> variables: collection, (read-only) Properties acting as inputs for this driver +DriverTarget.bone_target -> bone_target: string Name of PoseBone to use as target +DriverTarget.data_path -> data_path: string RNA Path (from ID-block) to property used +DriverTarget.id -> id: pointer ID-block that the specific property used can be found from (id_type property must be set first) +DriverTarget.id_type -> id_type: enum Type of ID-block that can be used +DriverTarget.transform_type -> transform_type: enum Driver variable type +DriverVariable.name -> name: string Name to use in scripted expressions/functions. (No spaces or dots are allowed. Also, must not start with a symbol or digit) +DriverVariable.targets -> targets: collection, (read-only) Sources of input data for evaluating this variable +DriverVariable.type -> type: enum Driver variable type +DupliObject.matrix -> matrix: float Object duplicate transformation matrix +DupliObject.object -> object: pointer, (read-only) Object being duplicated +DupliObject.object_matrix -> object_matrix: float Duplicated object transformation matrix +EdgeSplitModifier.split_angle -> split_angle: float Angle above which to split edges +EditBone.bbone_in -> bbone_in: float Length of first Bezier Handle (for B-Bones only) +EditBone.bbone_out -> bbone_out: float Length of second Bezier Handle (for B-Bones only) +EditBone.bbone_segments -> bbone_segments: int Number of subdivisions of bone (for B-Bones only) +EditBone.envelope_distance -> envelope_distance: float Bone deformation distance (for Envelope deform only) +EditBone.envelope_weight -> envelope_weight: float Bone deformation weight (for Envelope deform only) +EditBone.head -> head: float Location of head end of the bone +EditBone.head_radius -> head_radius: float Radius of head of bone (for Envelope deform only) +EditBone.matrix -> matrix: float, (read-only) Read-only matrix calculated from the roll (armature space) +EditBone.name -> name: string +EditBone.parent -> parent: pointer Parent edit bone (in same Armature) +EditBone.roll -> roll: float Bone rotation around head-tail axis +EditBone.tail -> tail: float Location of tail end of the bone +EditBone.tail_radius -> tail_radius: float Radius of tail of bone (for Envelope deform only) +EditObjectActuator.angular_velocity -> angular_velocity: float Angular velocity upon creation +EditObjectActuator.dynamic_operation -> dynamic_operation: enum +EditObjectActuator.linear_velocity -> linear_velocity: float Velocity upon creation +EditObjectActuator.mass -> mass: float The mass of the object +EditObjectActuator.mesh -> mesh: pointer Replace the existing, when left blank 'Phys' will remake the existing physics mesh +EditObjectActuator.mode -> mode: enum The mode of the actuator +EditObjectActuator.object -> object: pointer Add this Object and all its children (cant be on an visible layer) +EditObjectActuator.time -> time: int Duration the new Object lives or the track takes +EditObjectActuator.track_object -> track_object: pointer Track to this Object +EffectSequence.color_balance -> color_balance: pointer, (read-only) +EffectSequence.crop -> crop: pointer, (read-only) +EffectSequence.multiply_colors -> multiply_colors: float +EffectSequence.proxy -> proxy: pointer, (read-only) +EffectSequence.strobe -> strobe: float Only display every nth frame +EffectSequence.transform -> transform: pointer, (read-only) +EffectorWeights.all -> all: float All effector's weight +EffectorWeights.boid -> boid: float Boid effector weight +EffectorWeights.charge -> charge: float Charge effector weight +EffectorWeights.curveguide -> curveguide: float Curve guide effector weight +EffectorWeights.drag -> drag: float Drag effector weight +EffectorWeights.force -> force: float Force effector weight +EffectorWeights.gravity -> gravity: float Global gravity weight +EffectorWeights.group -> group: pointer Limit effectors to this Group +EffectorWeights.harmonic -> harmonic: float Harmonic effector weight +EffectorWeights.lennardjones -> lennardjones: float Lennard-Jones effector weight +EffectorWeights.magnetic -> magnetic: float Magnetic effector weight +EffectorWeights.texture -> texture: float Texture effector weight +EffectorWeights.turbulence -> turbulence: float Turbulence effector weight +EffectorWeights.vortex -> vortex: float Vortex effector weight +EffectorWeights.wind -> wind: float Wind effector weight +EnumProperty.default -> default: enum, (read-only) Default value for this enum +EnumProperty.items -> items: collection, (read-only) Possible values for the property +EnumPropertyItem.description -> description: string, (read-only) Description of the item's purpose +EnumPropertyItem.identifier -> identifier: string, (read-only) Unique name used in the code and scripting +EnumPropertyItem.name -> name: string, (read-only) Human readable name +EnumPropertyItem.value -> value: int, (read-only) Value of the item +EnvironmentMap.clip_end -> clip_end: float Objects further than this are not visible to map +EnvironmentMap.clip_start -> clip_start: float Objects nearer than this are not visible to map +EnvironmentMap.depth -> depth: int Number of times a map will be rendered recursively (mirror effects.) +EnvironmentMap.mapping -> mapping: enum +EnvironmentMap.resolution -> resolution: int Pixel resolution of the rendered environment map +EnvironmentMap.source -> source: enum +EnvironmentMap.viewpoint_object -> viewpoint_object: pointer Object to use as the environment map's viewpoint location +EnvironmentMap.zoom -> zoom: float +EnvironmentMapTexture.environment_map -> environment_map: pointer, (read-only) Gets the environment map associated with this texture +EnvironmentMapTexture.filter -> filter: enum Texture filter to use for sampling image +EnvironmentMapTexture.filter_eccentricity -> filter_eccentricity: int Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower +EnvironmentMapTexture.filter_probes -> filter_probes: int Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower +EnvironmentMapTexture.filter_size -> filter_size: float Multiplies the filter size used by MIP Map and Interpolation +EnvironmentMapTexture.image -> image: pointer Source image file to read the environment map from +EnvironmentMapTexture.image_user -> image_user: pointer, (read-only) Parameters defining which layer, pass and frame of the image is displayed +Event.ascii -> ascii: string, (read-only) Single ASCII character for this event +Event.mouse_prev_x -> mouse_prev_x: int, (read-only) The window relative vertical location of the mouse +Event.mouse_prev_y -> mouse_prev_y: int, (read-only) The window relative horizontal location of the mouse +Event.mouse_region_x -> mouse_region_x: int, (read-only) The region relative vertical location of the mouse +Event.mouse_region_y -> mouse_region_y: int, (read-only) The region relative horizontal location of the mouse +Event.mouse_x -> mouse_x: int, (read-only) The window relative vertical location of the mouse +Event.mouse_y -> mouse_y: int, (read-only) The window relative horizontal location of the mouse +Event.type -> type: enum, (read-only) +Event.value -> value: enum, (read-only) The type of event, only applies to some +ExplodeModifier.protect -> protect: float Clean vertex group edges +ExplodeModifier.vertex_group -> vertex_group: string +ExpressionController.expression -> expression: string +FCurve.array_index -> array_index: int Index to the specific property affected by F-Curve if applicable +FCurve.color -> color: float Color of the F-Curve in the Graph Editor +FCurve.color_mode -> color_mode: enum Method used to determine color of F-Curve in Graph Editor +FCurve.data_path -> data_path: string RNA Path to property affected by F-Curve +FCurve.driver -> driver: pointer, (read-only) Channel Driver (only set for Driver F-Curves) +FCurve.extrapolation -> extrapolation: enum +FCurve.group -> group: pointer Action Group that this F-Curve belongs to +FCurve.keyframe_points -> keyframe_points: collection, (read-only) User-editable keyframes +FCurve.modifiers -> modifiers: collection, (read-only) Modifiers affecting the shape of the F-Curve +FCurve.sampled_points -> sampled_points: collection, (read-only) Sampled animation data +FCurveModifiers.active -> active: pointer Active F-Curve Modifier +FCurveSample.co -> co: float Point coordinates +FModifier.type -> type: enum, (read-only) F-Curve Modifier Type +FModifierCycles.after_cycles -> after_cycles: float Maximum number of cycles to allow after last keyframe. (0 = infinite) +FModifierCycles.after_mode -> after_mode: enum Cycling mode to use after last keyframe +FModifierCycles.before_cycles -> before_cycles: float Maximum number of cycles to allow before first keyframe. (0 = infinite) +FModifierCycles.before_mode -> before_mode: enum Cycling mode to use before first keyframe +FModifierEnvelope.control_points -> control_points: collection, (read-only) Control points defining the shape of the envelope +FModifierEnvelope.default_maximum -> default_maximum: float Upper distance from Reference Value for 1:1 default influence +FModifierEnvelope.default_minimum -> default_minimum: float Lower distance from Reference Value for 1:1 default influence +FModifierEnvelope.reference_value -> reference_value: float Value that envelope's influence is centered around / based on +FModifierEnvelopeControlPoint.frame -> frame: float Frame this control-point occurs on +FModifierEnvelopeControlPoint.maximum -> maximum: float Upper bound of envelope at this control-point +FModifierEnvelopeControlPoint.minimum -> minimum: float Lower bound of envelope at this control-point +FModifierFunctionGenerator.amplitude -> amplitude: float Scale factor determining the maximum/minimum values +FModifierFunctionGenerator.function_type -> function_type: enum Type of built-in function to use +FModifierFunctionGenerator.phase_multiplier -> phase_multiplier: float Scale factor determining the 'speed' of the function +FModifierFunctionGenerator.phase_offset -> phase_offset: float Constant factor to offset time by for function +FModifierFunctionGenerator.value_offset -> value_offset: float Constant factor to offset values by +FModifierGenerator.coefficients -> coefficients: float Coefficients for 'x' (starting from lowest power of x^0) +FModifierGenerator.mode -> mode: enum Type of generator to use +FModifierGenerator.poly_order -> poly_order: int The highest power of 'x' for this polynomial. (number of coefficients - 1) +FModifierLimits.maximum_x -> maximum_x: float Highest X value to allow +FModifierLimits.maximum_y -> maximum_y: float Highest Y value to allow +FModifierLimits.minimum_x -> minimum_x: float Lowest X value to allow +FModifierLimits.minimum_y -> minimum_y: float Lowest Y value to allow +FModifierNoise.depth -> depth: int Amount of fine level detail present in the noise +FModifierNoise.modification -> modification: enum Method of modifying the existing F-Curve +FModifierNoise.phase -> phase: float A random seed for the noise effect +FModifierNoise.size -> size: float Scaling (in time) of the noise +FModifierNoise.strength -> strength: float Amplitude of the noise - the amount that it modifies the underlying curve +FModifierStepped.frame_end -> frame_end: float Frame that modifier's influence ends (if applicable) +FModifierStepped.frame_start -> frame_start: float Frame that modifier's influence starts (if applicable) +FModifierStepped.offset -> offset: float Reference number of frames before frames get held. Use to get hold for '1-3' vs '5-7' holding patterns +FModifierStepped.step_size -> step_size: float Number of frames to hold each value +FcurveActuator.frame_end -> frame_end: int +FcurveActuator.frame_property -> frame_property: string Assign the action's current frame number to this property +FcurveActuator.frame_start -> frame_start: int +FcurveActuator.play_type -> play_type: enum Specify the way you want to play the animation +FcurveActuator.property -> property: string Use this property to define the F-Curve position +FieldSettings.falloff_power -> falloff_power: float Falloff power (real gravitational falloff = 2) +FieldSettings.falloff_type -> falloff_type: enum Fall-off shape +FieldSettings.flow -> flow: float Convert effector force into air flow velocity +FieldSettings.guide_clump_amount -> guide_clump_amount: float Amount of clumping +FieldSettings.guide_clump_shape -> guide_clump_shape: float Shape of clumping +FieldSettings.guide_free -> guide_free: float Guide-free time from particle life's end +FieldSettings.guide_kink_amplitude -> guide_kink_amplitude: float The amplitude of the offset +FieldSettings.guide_kink_axis -> guide_kink_axis: enum Which axis to use for offset +FieldSettings.guide_kink_frequency -> guide_kink_frequency: float The frequency of the offset (1/total length) +FieldSettings.guide_kink_shape -> guide_kink_shape: float Adjust the offset to the beginning/end +FieldSettings.guide_kink_type -> guide_kink_type: enum Type of periodic offset on the curve +FieldSettings.guide_minimum -> guide_minimum: float The distance from which particles are affected fully +FieldSettings.harmonic_damping -> harmonic_damping: float Damping of the harmonic force +FieldSettings.inflow -> inflow: float Inwards component of the vortex force +FieldSettings.linear_drag -> linear_drag: float Drag component proportional to velocity +FieldSettings.maximum_distance -> maximum_distance: float Maximum distance for the field to work +FieldSettings.minimum_distance -> minimum_distance: float Minimum distance for the field's fall-off +FieldSettings.noise -> noise: float Noise of the force +FieldSettings.quadratic_drag -> quadratic_drag: float Drag component proportional to the square of velocity +FieldSettings.radial_falloff -> radial_falloff: float Radial falloff power (real gravitational falloff = 2) +FieldSettings.radial_maximum -> radial_maximum: float Maximum radial distance for the field to work +FieldSettings.radial_minimum -> radial_minimum: float Minimum radial distance for the field's fall-off +FieldSettings.rest_length -> rest_length: float Rest length of the harmonic force +FieldSettings.seed -> seed: int Seed of the noise +FieldSettings.shape -> shape: enum Which direction is used to calculate the effector force +FieldSettings.size -> size: float Size of the noise +FieldSettings.strength -> strength: float Strength of force field +FieldSettings.texture -> texture: pointer Texture to use as force +FieldSettings.texture_mode -> texture_mode: enum How the texture effect is calculated (RGB & Curl need a RGB texture else Gradient will be used instead) +FieldSettings.texture_nabla -> texture_nabla: float Defines size of derivative offset used for calculating gradient and curl +FieldSettings.type -> type: enum Type of field +FieldSettings.z_direction -> z_direction: enum Effect in full or only positive/negative Z direction +FileSelectParams.directory -> directory: string Directory displayed in the file browser +FileSelectParams.display -> display: enum Display mode for the file list +FileSelectParams.file -> file: string Active file in the file browser +FileSelectParams.sort -> sort: enum +FileSelectParams.title -> title: string, (read-only) Title for the file browser +Filter2DActuator.filter_pass -> filter_pass: int Set filter order +Filter2DActuator.glsl_shader -> glsl_shader: pointer +Filter2DActuator.mode -> mode: enum +Filter2DActuator.motion_blur_value -> motion_blur_value: float Set motion blur value +FloatProperty.array_length -> array_length: int, (read-only) Maximum length of the array, 0 means unlimited +FloatProperty.default -> default: float, (read-only) Default value for this number +FloatProperty.default_array -> default_array: float, (read-only) Default value for this array +FloatProperty.hard_max -> hard_max: float, (read-only) Maximum value used by buttons +FloatProperty.hard_min -> hard_min: float, (read-only) Minimum value used by buttons +FloatProperty.precision -> precision: int, (read-only) Number of digits after the dot used by buttons +FloatProperty.soft_max -> soft_max: float, (read-only) Maximum value used by buttons +FloatProperty.soft_min -> soft_min: float, (read-only) Minimum value used by buttons +FloatProperty.step -> step: float, (read-only) Step size used by number buttons, for floats 1/100th of the step size +FloorConstraint.floor_location -> floor_location: enum Location of target that object will not pass through +FloorConstraint.offset -> offset: float Offset of floor from object origin +FloorConstraint.subtarget -> subtarget: string +FloorConstraint.target -> target: pointer Target Object +FluidFluidSettings.initial_velocity -> initial_velocity: float Initial velocity of fluid +FluidFluidSettings.volume_initialization -> volume_initialization: enum Volume initialization type +FluidSettings.type -> type: enum Type of participation in the fluid simulation +FluidSimulationModifier.settings -> settings: pointer, (read-only) Settings for how this object is used in the fluid simulation +FollowPathConstraint.forward -> forward: enum Axis that points forward along the path +FollowPathConstraint.offset -> offset: int Offset from the position corresponding to the time frame +FollowPathConstraint.offset_factor -> offset_factor: float Percentage value defining target position along length of bone +FollowPathConstraint.target -> target: pointer Target Object +FollowPathConstraint.up -> up: enum Axis that points upward +Function.description -> description: string, (read-only) Description of the Function's purpose +Function.identifier -> identifier: string, (read-only) Unique name used in the code and scripting +Function.parameters -> parameters: collection, (read-only) Parameters for the function +GPencilFrame.frame_number -> frame_number: int The frame on which this sketch appears +GPencilFrame.strokes -> strokes: collection, (read-only) Freehand curves defining the sketch on this frame +GPencilLayer.active_frame -> active_frame: pointer, (read-only) Frame currently being displayed for this layer +GPencilLayer.color -> color: float Color for all strokes in this layer +GPencilLayer.frames -> frames: collection, (read-only) Sketches for this layer on different frames +GPencilLayer.info -> info: string Layer name +GPencilLayer.line_thickness -> line_thickness: int Thickness of strokes (in pixels) +GPencilLayer.max_ghost_range -> max_ghost_range: int Maximum number of frames on either side of the active frame to show (0 = show the 'first' available sketch on either side) +GPencilLayer.opacity -> opacity: float Layer Opacity +GPencilStroke.points -> points: collection, (read-only) Stroke data points +GPencilStrokePoint.co -> co: float +GPencilStrokePoint.pressure -> pressure: float Pressure of tablet at point when drawing it +GameActuator.filename -> filename: string Load this blend file, use the "//" prefix for a path relative to the current blend file +GameActuator.mode -> mode: enum +GameFloatProperty.value -> value: float Property value +GameIntProperty.value -> value: int Property value +GameObjectSettings.actuators -> actuators: collection, (read-only) Game engine actuators to act on events +GameObjectSettings.collision_bounds -> collision_bounds: enum Selects the collision type +GameObjectSettings.collision_margin -> collision_margin: float Extra margin around object for collision detection, small amount required for stability +GameObjectSettings.controllers -> controllers: collection, (read-only) Game engine controllers to process events, connecting sensor to actuators +GameObjectSettings.damping -> damping: float General movement damping +GameObjectSettings.form_factor -> form_factor: float Form factor scales the inertia tensor +GameObjectSettings.friction_coefficients -> friction_coefficients: float Relative friction coefficient in the in the X, Y and Z directions, when anisotropic friction is enabled +GameObjectSettings.mass -> mass: float Mass of the object +GameObjectSettings.maximum_velocity -> maximum_velocity: float Clamp velocity to this maximum speed +GameObjectSettings.minimum_velocity -> minimum_velocity: float Clamp velocity to this minimum speed (except when totally still) +GameObjectSettings.physics_type -> physics_type: enum Selects the type of physical representation +GameObjectSettings.properties -> properties: collection, (read-only) Game engine properties +GameObjectSettings.radius -> radius: float Radius of bounding sphere and material physics +GameObjectSettings.rotation_damping -> rotation_damping: float General rotation damping +GameObjectSettings.sensors -> sensors: collection, (read-only) Game engine sensor to detect events +GameObjectSettings.soft_body -> soft_body: pointer, (read-only) Settings for Bullet soft body simulation +GameProperty.name -> name: string Available as GameObject attributes in the game engine's python API +GameProperty.type -> type: enum +GameSoftBodySettings.cluster_iterations -> cluster_iterations: int Specify the number of cluster iterations +GameSoftBodySettings.dynamic_friction -> dynamic_friction: float Dynamic Friction +GameSoftBodySettings.linstiff -> linstiff: float Linear stiffness of the soft body links +GameSoftBodySettings.margin -> margin: float Collision margin for soft body. Small value makes the algorithm unstable +GameSoftBodySettings.position_iterations -> position_iterations: int Position solver iterations +GameSoftBodySettings.threshold -> threshold: float Shape matching threshold +GameSoftBodySettings.welding -> welding: float Welding threshold: distance between nearby vertices to be considered equal => set to 0.0 to disable welding test and speed up scene loading (ok if the mesh has no duplicates) +GameStringProperty.value -> value: string Property value +GameTimerProperty.value -> value: float Property value +GlowSequence.blur_distance -> blur_distance: float Radius of glow effect +GlowSequence.boost_factor -> boost_factor: float Brightness multiplier +GlowSequence.clamp -> clamp: float rightness limit of intensity +GlowSequence.quality -> quality: int Accuracy of the blur effect +GlowSequence.threshold -> threshold: float Minimum intensity to trigger a glow +GreasePencil.draw_mode -> draw_mode: enum +GreasePencil.layers -> layers: collection, (read-only) +Group.dupli_offset -> dupli_offset: float Offset from the origin to use when instancing as DupliGroup +Group.objects -> objects: collection, (read-only) A collection of this groups objects +Header.bl_idname -> bl_idname: string +Header.bl_space_type -> bl_space_type: enum +Header.layout -> layout: pointer, (read-only) +Histogram.mode -> mode: enum Channels to display when drawing the histogram +HookModifier.falloff -> falloff: float If not zero, the distance from the hook where influence ends +HookModifier.force -> force: float Relative force of the hook +HookModifier.object -> object: pointer Parent Object for hook, also recalculates and clears offset +HookModifier.subtarget -> subtarget: string Name of Parent Bone for hook (if applicable), also recalculates and clears offset +HookModifier.vertex_group -> vertex_group: string Vertex group name +ID.library -> library: pointer, (read-only) Library file the datablock is linked from +ID.name -> name: string Unique datablock ID name +ID.users -> users: int, (read-only) Number of times this datablock is referenced +IDProperty.collection -> collection: collection, (read-only) +IDProperty.double -> double: float +IDProperty.double_array -> double_array: float +IDProperty.float -> float: float +IDProperty.float_array -> float_array: float +IDProperty.group -> group: pointer, (read-only) +IDProperty.int -> int: int +IDProperty.int_array -> int_array: int +IDProperty.string -> string: string +IDPropertyGroup.name -> name: string Unique name used in the code and scripting +IKParam.ik_solver -> ik_solver: enum, (read-only) IK solver for which these parameters are defined, 0 for Legacy, 1 for iTaSC +Image.animation_end -> animation_end: int End frame of an animated texture +Image.animation_speed -> animation_speed: int Speed of the animation in frames per second +Image.animation_start -> animation_start: int Start frame of an animated texture +Image.bindcode -> bindcode: int, (read-only) OpenGL bindcode +Image.depth -> depth: int, (read-only) Image bit depth +Image.display_aspect -> display_aspect: float Display Aspect for this image, does not affect rendering +Image.field_order -> field_order: enum Order of video fields. Select which lines are displayed first +Image.file_format -> file_format: enum Format used for re-saving this file +Image.filepath -> filepath: string Image/Movie file name +Image.filepath_raw -> filepath_raw: string Image/Movie file name (without data refreshing) +Image.generated_height -> generated_height: int Generated image height +Image.generated_type -> generated_type: enum Generated image type +Image.generated_width -> generated_width: int Generated image width +Image.mapping -> mapping: enum Mapping type to use for this image in the game engine +Image.packed_file -> packed_file: pointer, (read-only) +Image.size -> size: int, (read-only) Width and height in pixels, zero when image data cant be loaded +Image.source -> source: enum Where the image comes from +Image.tiles_x -> tiles_x: int Degree of repetition in the X direction +Image.tiles_y -> tiles_y: int Degree of repetition in the Y direction +Image.type -> type: enum, (read-only) How to generate the image +ImagePaint.normal_angle -> normal_angle: int Paint most on faces pointing towards the view according to this angle +ImagePaint.screen_grab_size -> screen_grab_size: int Size to capture the image for re-projecting +ImagePaint.seam_bleed -> seam_bleed: int Extend paint beyond the faces UVs to reduce seams (in pixels, slower) +ImageSequence.animation_end_offset -> animation_end_offset: int Animation end offset (trim end) +ImageSequence.animation_start_offset -> animation_start_offset: int Animation start offset (trim start) +ImageSequence.color_balance -> color_balance: pointer, (read-only) +ImageSequence.crop -> crop: pointer, (read-only) +ImageSequence.directory -> directory: string +ImageSequence.elements -> elements: collection, (read-only) +ImageSequence.multiply_colors -> multiply_colors: float +ImageSequence.proxy -> proxy: pointer, (read-only) +ImageSequence.strobe -> strobe: float Only display every nth frame +ImageSequence.transform -> transform: pointer, (read-only) +ImageTexture.checker_distance -> checker_distance: float Sets distance between checker tiles +ImageTexture.crop_max_x -> crop_max_x: float Sets maximum X value to crop the image +ImageTexture.crop_max_y -> crop_max_y: float Sets maximum Y value to crop the image +ImageTexture.crop_min_x -> crop_min_x: float Sets minimum X value to crop the image +ImageTexture.crop_min_y -> crop_min_y: float Sets minimum Y value to crop the image +ImageTexture.extension -> extension: enum Sets how the image is extrapolated past its original bounds +ImageTexture.filter -> filter: enum Texture filter to use for sampling image +ImageTexture.filter_eccentricity -> filter_eccentricity: int Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower +ImageTexture.filter_probes -> filter_probes: int Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower +ImageTexture.filter_size -> filter_size: float Multiplies the filter size used by MIP Map and Interpolation +ImageTexture.image -> image: pointer +ImageTexture.image_user -> image_user: pointer, (read-only) Parameters defining which layer, pass and frame of the image is displayed +ImageTexture.normal_space -> normal_space: enum Sets space of normal map image +ImageTexture.repeat_x -> repeat_x: int Sets a repetition multiplier in the X direction +ImageTexture.repeat_y -> repeat_y: int Sets a repetition multiplier in the Y direction +ImageUser.fields_per_frame -> fields_per_frame: int The number of fields per rendered frame (2 fields is 1 image) +ImageUser.frame_start -> frame_start: int Sets the global starting frame of the movie +ImageUser.frames -> frames: int Sets the number of images of a movie to use +ImageUser.multilayer_layer -> multilayer_layer: int, (read-only) Layer in multilayer image +ImageUser.multilayer_pass -> multilayer_pass: int, (read-only) Pass in multilayer image +ImageUser.offset -> offset: int Offsets the number of the frame to use in the animation +InflowFluidSettings.inflow_velocity -> inflow_velocity: float Initial velocity of fluid +InflowFluidSettings.volume_initialization -> volume_initialization: enum Volume initialization type +IntProperty.array_length -> array_length: int, (read-only) Maximum length of the array, 0 means unlimited +IntProperty.default -> default: int, (read-only) Default value for this number +IntProperty.default_array -> default_array: int, (read-only) Default value for this array +IntProperty.hard_max -> hard_max: int, (read-only) Maximum value used by buttons +IntProperty.hard_min -> hard_min: int, (read-only) Minimum value used by buttons +IntProperty.soft_max -> soft_max: int, (read-only) Maximum value used by buttons +IntProperty.soft_min -> soft_min: int, (read-only) Minimum value used by buttons +IntProperty.step -> step: int, (read-only) Step size used by number buttons, for floats 1/100th of the step size +Itasc.dampeps -> dampeps: float Singular value under which damping is progressively applied. Higher values=more stability, less reactivity. Default=0.1 +Itasc.dampmax -> dampmax: float Maximum damping coefficient when singular value is nearly 0. Higher values=more stability, less reactivity. Default=0.5 +Itasc.feedback -> feedback: float Feedback coefficient for error correction. Average response time=1/feedback. Default=20 +Itasc.max_step -> max_step: float Higher bound for timestep in second in case of automatic substeps +Itasc.max_velocity -> max_velocity: float Maximum joint velocity in rad/s. Default=50 +Itasc.min_step -> min_step: float Lower bound for timestep in second in case of automatic substeps +Itasc.mode -> mode: enum +Itasc.num_iter -> num_iter: int Maximum number of iterations for convergence in case of reiteration +Itasc.num_step -> num_step: int Divides the frame interval into this many steps +Itasc.precision -> precision: float Precision of convergence in case of reiteration +Itasc.reiteration -> reiteration: enum Defines if the solver is allowed to reiterate (converges until precision is met) on none, first or all frames +Itasc.solver -> solver: enum Solving method selection: Automatic damping or manual damping +JoystickSensor.axis_direction -> axis_direction: enum The direction of the axis +JoystickSensor.axis_number -> axis_number: int Specify which axis pair to use, 1 is usually the main direction input +JoystickSensor.axis_threshold -> axis_threshold: int Specify the precision of the axis +JoystickSensor.button_number -> button_number: int Specify which button to use +JoystickSensor.event_type -> event_type: enum The type of event this joystick sensor is triggered on +JoystickSensor.hat_direction -> hat_direction: enum Specify hat direction +JoystickSensor.hat_number -> hat_number: int Specify which hat to use +JoystickSensor.joystick_index -> joystick_index: int Specify which joystick to use +JoystickSensor.single_axis_number -> single_axis_number: int Specify a single axis (verticle/horizontal/other) to detect +Key.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Key.keys -> keys: collection, (read-only) Shape keys +Key.reference_key -> reference_key: pointer, (read-only) +Key.slurph -> slurph: int Creates a delay in amount of frames in applying keypositions, first vertex goes first +Key.user -> user: pointer, (read-only) Datablock using these shape keys +KeyConfig.keymaps -> keymaps: collection, (read-only) Key maps configured as part of this configuration +KeyConfig.name -> name: string Name of the key configuration +KeyMap.items -> items: collection, (read-only) Items in the keymap, linking an operator to an input event +KeyMap.name -> name: string, (read-only) Name of the key map +KeyMap.region_type -> region_type: enum, (read-only) Optional region type keymap is associated with +KeyMap.space_type -> space_type: enum, (read-only) Optional space type keymap is associated with +KeyMapItem.id -> id: int, (read-only) ID of the item +KeyMapItem.idname -> idname: string Identifier of operator to call on input event +KeyMapItem.key_modifier -> key_modifier: enum Regular key pressed as a modifier +KeyMapItem.map_type -> map_type: enum Type of event mapping +KeyMapItem.name -> name: string, (read-only) Name of operator to call on input event +KeyMapItem.properties -> properties: pointer, (read-only) Properties to set when the operator is called +KeyMapItem.propvalue -> propvalue: enum The value this event translates to in a modal keymap +KeyMapItem.type -> type: enum Type of event +KeyMapItem.value -> value: enum +KeyboardSensor.key -> key: enum +KeyboardSensor.log -> log: string Property that receive the keystrokes in case a string is logged +KeyboardSensor.modifier_key -> modifier_key: enum Modifier key code +KeyboardSensor.second_modifier_key -> second_modifier_key: enum Modifier key code +KeyboardSensor.target -> target: string Property that indicates whether to log keystrokes as a string +Keyframe.co -> co: float Coordinates of the control point +Keyframe.handle1 -> handle1: float Coordinates of the first handle +Keyframe.handle1_type -> handle1_type: enum Handle types +Keyframe.handle2 -> handle2: float Coordinates of the second handle +Keyframe.handle2_type -> handle2_type: enum Handle types +Keyframe.interpolation -> interpolation: enum Interpolation method to use for segment of the curve from this Keyframe until the next Keyframe +Keyframe.type -> type: enum The type of keyframe +KeyingSet.active_path -> active_path: pointer Active Keying Set used to insert/delete keyframes +KeyingSet.active_path_index -> active_path_index: int Current Keying Set index +KeyingSet.name -> name: string +KeyingSet.paths -> paths: collection, (read-only) Keying Set Paths to define settings that get keyframed together +KeyingSet.type_info -> type_info: pointer, (read-only) Callback function defines for built-in Keying Sets +KeyingSetInfo.bl_idname -> bl_idname: string +KeyingSetInfo.bl_label -> bl_label: string +KeyingSetPath.array_index -> array_index: int Index to the specific setting if applicable +KeyingSetPath.data_path -> data_path: string Path to property setting +KeyingSetPath.group -> group: string Name of Action Group to assign setting(s) for this path to +KeyingSetPath.grouping -> grouping: enum Method used to define which Group-name to use +KeyingSetPath.id -> id: pointer ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only) +KeyingSetPath.id_type -> id_type: enum Type of ID-block that can be used +KinematicConstraint.axis_reference -> axis_reference: enum Constraint axis Lock options relative to Bone or Target reference +KinematicConstraint.chain_length -> chain_length: int How many bones are included in the IK effect - 0 uses all bones +KinematicConstraint.distance -> distance: float Radius of limiting sphere +KinematicConstraint.ik_type -> ik_type: enum +KinematicConstraint.iterations -> iterations: int Maximum number of solving iterations +KinematicConstraint.limit_mode -> limit_mode: enum Distances in relation to sphere of influence to allow +KinematicConstraint.orient_weight -> orient_weight: float For Tree-IK: Weight of orientation control for this target +KinematicConstraint.pole_angle -> pole_angle: float Pole rotation offset +KinematicConstraint.pole_subtarget -> pole_subtarget: string +KinematicConstraint.pole_target -> pole_target: pointer Object for pole rotation +KinematicConstraint.subtarget -> subtarget: string +KinematicConstraint.target -> target: pointer Target Object +KinematicConstraint.weight -> weight: float For Tree-IK: Weight of position control for this target +Lamp.active_texture -> active_texture: pointer Active texture slot being displayed +Lamp.active_texture_index -> active_texture_index: int Index of active texture slot +Lamp.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Lamp.color -> color: float Light color +Lamp.distance -> distance: float Falloff distance - the light is at half the original intensity at this point +Lamp.energy -> energy: float Amount of light that the lamp emits +Lamp.texture_slots -> texture_slots: collection, (read-only) Texture slots defining the mapping and influence of textures +Lamp.type -> type: enum Type of Lamp +LampSkySettings.atmosphere_distance_factor -> atmosphere_distance_factor: float Multiplier to convert blender units to physical distance +LampSkySettings.atmosphere_extinction -> atmosphere_extinction: float Extinction scattering contribution factor +LampSkySettings.atmosphere_inscattering -> atmosphere_inscattering: float Scatter contribution factor +LampSkySettings.atmosphere_turbidity -> atmosphere_turbidity: float Sky turbidity +LampSkySettings.backscattered_light -> backscattered_light: float Backscattered light +LampSkySettings.horizon_brightness -> horizon_brightness: float Horizon brightness +LampSkySettings.sky_blend -> sky_blend: float Blend factor with sky +LampSkySettings.sky_blend_type -> sky_blend_type: enum Blend mode for combining sun sky with world sky +LampSkySettings.sky_color_space -> sky_color_space: enum Color space to use for internal XYZ->RGB color conversion +LampSkySettings.sky_exposure -> sky_exposure: float Strength of sky shading exponential exposure correction +LampSkySettings.spread -> spread: float Horizon Spread +LampSkySettings.sun_brightness -> sun_brightness: float Sun brightness +LampSkySettings.sun_intensity -> sun_intensity: float Sun intensity +LampSkySettings.sun_size -> sun_size: float Sun size +LampTextureSlot.color_factor -> color_factor: float Amount texture affects color values +LampTextureSlot.object -> object: pointer Object to use for mapping with Object texture coordinates +LampTextureSlot.shadow_factor -> shadow_factor: float Amount texture affects shadow +LampTextureSlot.texture_coordinates -> texture_coordinates: enum +Lattice.interpolation_type_u -> interpolation_type_u: enum +Lattice.interpolation_type_v -> interpolation_type_v: enum +Lattice.interpolation_type_w -> interpolation_type_w: enum +Lattice.points -> points: collection, (read-only) Points of the lattice +Lattice.points_u -> points_u: int Points in U direction +Lattice.points_v -> points_v: int Points in V direction +Lattice.points_w -> points_w: int Points in W direction +Lattice.shape_keys -> shape_keys: pointer, (read-only) +Lattice.vertex_group -> vertex_group: string Vertex group to apply the influence of the lattice +LatticeModifier.object -> object: pointer Lattice object to deform with +LatticeModifier.vertex_group -> vertex_group: string Vertex group name +LatticePoint.co -> co: float, (read-only) +LatticePoint.deformed_co -> deformed_co: float +LatticePoint.groups -> groups: collection, (read-only) Weights for the vertex groups this point is member of +Library.filepath -> filepath: string Path to the library .blend file +Library.parent -> parent: pointer, (read-only) +LimitDistanceConstraint.distance -> distance: float Radius of limiting sphere +LimitDistanceConstraint.limit_mode -> limit_mode: enum Distances in relation to sphere of influence to allow +LimitDistanceConstraint.subtarget -> subtarget: string +LimitDistanceConstraint.target -> target: pointer Target Object +LimitLocationConstraint.maximum_x -> maximum_x: float Highest X value to allow +LimitLocationConstraint.maximum_y -> maximum_y: float Highest Y value to allow +LimitLocationConstraint.maximum_z -> maximum_z: float Highest Z value to allow +LimitLocationConstraint.minimum_x -> minimum_x: float Lowest X value to allow +LimitLocationConstraint.minimum_y -> minimum_y: float Lowest Y value to allow +LimitLocationConstraint.minimum_z -> minimum_z: float Lowest Z value to allow +LimitRotationConstraint.maximum_x -> maximum_x: float Highest X value to allow +LimitRotationConstraint.maximum_y -> maximum_y: float Highest Y value to allow +LimitRotationConstraint.maximum_z -> maximum_z: float Highest Z value to allow +LimitRotationConstraint.minimum_x -> minimum_x: float Lowest X value to allow +LimitRotationConstraint.minimum_y -> minimum_y: float Lowest Y value to allow +LimitRotationConstraint.minimum_z -> minimum_z: float Lowest Z value to allow +LimitScaleConstraint.maximum_x -> maximum_x: float Highest X value to allow +LimitScaleConstraint.maximum_y -> maximum_y: float Highest Y value to allow +LimitScaleConstraint.maximum_z -> maximum_z: float Highest Z value to allow +LimitScaleConstraint.minimum_x -> minimum_x: float Lowest X value to allow +LimitScaleConstraint.minimum_y -> minimum_y: float Lowest Y value to allow +LimitScaleConstraint.minimum_z -> minimum_z: float Lowest Z value to allow +LockedTrackConstraint.locked -> locked: enum Axis that points upward +LockedTrackConstraint.subtarget -> subtarget: string +LockedTrackConstraint.target -> target: pointer Target Object +LockedTrackConstraint.track -> track: enum Axis that points to the target object +Macro.bl_description -> bl_description: string +Macro.bl_idname -> bl_idname: string +Macro.bl_label -> bl_label: string +Macro.bl_options -> bl_options: enum Options for this operator type +Macro.name -> name: string, (read-only) +Macro.properties -> properties: pointer, (read-only) +MagicTexture.noise_depth -> noise_depth: int Sets the depth of the cloud calculation +MagicTexture.turbulence -> turbulence: float Sets the turbulence of the bandnoise and ringnoise types +Main.actions -> actions: collection, (read-only) Action datablocks. +Main.armatures -> armatures: collection, (read-only) Armature datablocks. +Main.brushes -> brushes: collection, (read-only) Brush datablocks. +Main.cameras -> cameras: collection, (read-only) Camera datablocks. +Main.curves -> curves: collection, (read-only) Curve datablocks. +Main.filepath -> filepath: string, (read-only) Path to the .blend file +Main.fonts -> fonts: collection, (read-only) Vector font datablocks. +Main.gpencil -> gpencil: collection, (read-only) Grease Pencil datablocks. +Main.groups -> groups: collection, (read-only) Group datablocks. +Main.images -> images: collection, (read-only) Image datablocks. +Main.lamps -> lamps: collection, (read-only) Lamp datablocks. +Main.lattices -> lattices: collection, (read-only) Lattice datablocks. +Main.libraries -> libraries: collection, (read-only) Library datablocks. +Main.materials -> materials: collection, (read-only) Material datablocks. +Main.meshes -> meshes: collection, (read-only) Mesh datablocks. +Main.metaballs -> metaballs: collection, (read-only) Metaball datablocks. +Main.node_groups -> node_groups: collection, (read-only) Node group datablocks. +Main.objects -> objects: collection, (read-only) Object datablocks. +Main.particles -> particles: collection, (read-only) Particle datablocks. +Main.scenes -> scenes: collection, (read-only) Scene datablocks. +Main.screens -> screens: collection, (read-only) Screen datablocks. +Main.scripts -> scripts: collection, (read-only) Script datablocks (DEPRECATED). +Main.sounds -> sounds: collection, (read-only) Sound datablocks. +Main.texts -> texts: collection, (read-only) Text datablocks. +Main.textures -> textures: collection, (read-only) Texture datablocks. +Main.window_managers -> window_managers: collection, (read-only) Window manager datablocks. +Main.worlds -> worlds: collection, (read-only) World datablocks. +MaintainVolumeConstraint.axis -> axis: enum The free scaling axis of the object +MaintainVolumeConstraint.volume -> volume: float Volume of the bone at rest +MarbleTexture.nabla -> nabla: float Size of derivative offset used for calculating normal +MarbleTexture.noise_basis -> noise_basis: enum Sets the noise basis used for turbulence +MarbleTexture.noise_depth -> noise_depth: int Sets the depth of the cloud calculation +MarbleTexture.noise_size -> noise_size: float Sets scaling for noise input +MarbleTexture.noise_type -> noise_type: enum +MarbleTexture.noisebasis2 -> noisebasis2: enum +MarbleTexture.stype -> stype: enum +MarbleTexture.turbulence -> turbulence: float Sets the turbulence of the bandnoise and ringnoise types +MaskModifier.armature -> armature: pointer Armature to use as source of bones to mask +MaskModifier.mode -> mode: enum +MaskModifier.vertex_group -> vertex_group: string Vertex group name +Material.active_node_material -> active_node_material: pointer Active node material +Material.active_texture -> active_texture: pointer Active texture slot being displayed +Material.active_texture_index -> active_texture_index: int Index of active texture slot +Material.alpha -> alpha: float Alpha transparency of the material +Material.ambient -> ambient: float Amount of global ambient color the material receives +Material.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Material.darkness -> darkness: float Minnaert darkness +Material.diffuse_color -> diffuse_color: float +Material.diffuse_fresnel -> diffuse_fresnel: float Power of Fresnel +Material.diffuse_fresnel_factor -> diffuse_fresnel_factor: float Blending factor of Fresnel +Material.diffuse_intensity -> diffuse_intensity: float Amount of diffuse reflection +Material.diffuse_ramp -> diffuse_ramp: pointer, (read-only) Color ramp used to affect diffuse shading +Material.diffuse_ramp_blend -> diffuse_ramp_blend: enum +Material.diffuse_ramp_factor -> diffuse_ramp_factor: float Blending factor (also uses alpha in Colorband) +Material.diffuse_ramp_input -> diffuse_ramp_input: enum +Material.diffuse_shader -> diffuse_shader: enum +Material.diffuse_toon_size -> diffuse_toon_size: float Size of diffuse toon area +Material.diffuse_toon_smooth -> diffuse_toon_smooth: float Smoothness of diffuse toon area +Material.emit -> emit: float Amount of light to emit +Material.halo -> halo: pointer, (read-only) Halo settings for the material +Material.light_group -> light_group: pointer Limit lighting to lamps in this Group +Material.mirror_color -> mirror_color: float Mirror color of the material +Material.node_tree -> node_tree: pointer, (read-only) Node tree for node based materials +Material.physics -> physics: pointer, (read-only) Game physics settings +Material.preview_render_type -> preview_render_type: enum Type of preview render +Material.raytrace_mirror -> raytrace_mirror: pointer, (read-only) Raytraced reflection settings for the material +Material.raytrace_transparency -> raytrace_transparency: pointer, (read-only) Raytraced transparency settings for the material +Material.roughness -> roughness: float Oren-Nayar Roughness +Material.shadow_buffer_bias -> shadow_buffer_bias: float Factor to multiply shadow buffer bias with (0 is ignore.) +Material.shadow_casting_alpha -> shadow_casting_alpha: float Shadow casting alpha, in use for Irregular and Deep shadow buffer +Material.shadow_ray_bias -> shadow_ray_bias: float Shadow raytracing bias to prevent terminator problems on shadow boundary +Material.specular_alpha -> specular_alpha: float Alpha transparency for specular areas +Material.specular_color -> specular_color: float Specular color of the material +Material.specular_hardness -> specular_hardness: int +Material.specular_intensity -> specular_intensity: float +Material.specular_ior -> specular_ior: float +Material.specular_ramp -> specular_ramp: pointer, (read-only) Color ramp used to affect specular shading +Material.specular_ramp_blend -> specular_ramp_blend: enum +Material.specular_ramp_factor -> specular_ramp_factor: float Blending factor (also uses alpha in Colorband) +Material.specular_ramp_input -> specular_ramp_input: enum +Material.specular_shader -> specular_shader: enum +Material.specular_slope -> specular_slope: float The standard deviation of surface slope +Material.specular_toon_size -> specular_toon_size: float Size of specular toon area +Material.specular_toon_smooth -> specular_toon_smooth: float Smoothness of specular toon area +Material.strand -> strand: pointer, (read-only) Strand settings for the material +Material.subsurface_scattering -> subsurface_scattering: pointer, (read-only) Subsurface scattering settings for the material +Material.texture_slots -> texture_slots: collection, (read-only) Texture slots defining the mapping and influence of textures +Material.translucency -> translucency: float Amount of diffuse shading on the back side +Material.transparency_method -> transparency_method: enum Method to use for rendering transparency +Material.type -> type: enum Material type defining how the object is rendered +Material.volume -> volume: pointer, (read-only) Volume settings for the material +Material.z_offset -> z_offset: float Gives faces an artificial offset in the Z buffer for Z transparency +MaterialHalo.add -> add: float Sets the strength of the add effect +MaterialHalo.flare_boost -> flare_boost: float Gives the flare extra strength +MaterialHalo.flare_seed -> flare_seed: int Specifies an offset in the flare seed table +MaterialHalo.flare_size -> flare_size: float Sets the factor by which the flare is larger than the halo +MaterialHalo.flare_subsize -> flare_subsize: float Sets the dimension of the subflares, dots and circles +MaterialHalo.flares_sub -> flares_sub: int Sets the number of subflares +MaterialHalo.hardness -> hardness: int Sets the hardness of the halo +MaterialHalo.line_number -> line_number: int Sets the number of star shaped lines rendered over the halo +MaterialHalo.rings -> rings: int Sets the number of rings rendered over the halo +MaterialHalo.seed -> seed: int Randomizes ring dimension and line location +MaterialHalo.size -> size: float Sets the dimension of the halo +MaterialHalo.star_tips -> star_tips: int Sets the number of points on the star shaped halo +MaterialPhysics.damp -> damp: float Damping of the spring force, when inside the physics distance area +MaterialPhysics.distance -> distance: float Distance of the physics area +MaterialPhysics.elasticity -> elasticity: float Elasticity of collisions +MaterialPhysics.force -> force: float Upward spring force, when inside the physics distance area +MaterialPhysics.friction -> friction: float Coulomb friction coefficient, when inside the physics distance area +MaterialRaytraceMirror.depth -> depth: int Maximum allowed number of light inter-reflections +MaterialRaytraceMirror.distance -> distance: float Maximum distance of reflected rays. Reflections further than this range fade to sky color or material color +MaterialRaytraceMirror.fade_to -> fade_to: enum The color that rays with no intersection within the Max Distance take. Material color can be best for indoor scenes, sky color for outdoor +MaterialRaytraceMirror.fresnel -> fresnel: float Power of Fresnel for mirror reflection +MaterialRaytraceMirror.fresnel_factor -> fresnel_factor: float Blending factor for Fresnel +MaterialRaytraceMirror.gloss_anisotropic -> gloss_anisotropic: float The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent +MaterialRaytraceMirror.gloss_factor -> gloss_factor: float The shininess of the reflection. Values < 1.0 give diffuse, blurry reflections +MaterialRaytraceMirror.gloss_samples -> gloss_samples: int Number of cone samples averaged for blurry reflections +MaterialRaytraceMirror.gloss_threshold -> gloss_threshold: float Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped +MaterialRaytraceMirror.reflect_factor -> reflect_factor: float Sets the amount mirror reflection for raytrace +MaterialRaytraceTransparency.depth -> depth: int Maximum allowed number of light inter-refractions +MaterialRaytraceTransparency.falloff -> falloff: float Falloff power for transmissivity filter effect (1.0 is linear) +MaterialRaytraceTransparency.filter -> filter: float Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption) +MaterialRaytraceTransparency.fresnel -> fresnel: float Power of Fresnel for transparency (Ray or ZTransp) +MaterialRaytraceTransparency.fresnel_factor -> fresnel_factor: float Blending factor for Fresnel +MaterialRaytraceTransparency.gloss_factor -> gloss_factor: float The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions +MaterialRaytraceTransparency.gloss_samples -> gloss_samples: int Number of cone samples averaged for blurry refractions +MaterialRaytraceTransparency.gloss_threshold -> gloss_threshold: float Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped +MaterialRaytraceTransparency.ior -> ior: float Sets angular index of refraction for raytraced refraction +MaterialRaytraceTransparency.limit -> limit: float Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled) +MaterialSlot.link -> link: enum Link material to object or the object's data +MaterialSlot.material -> material: pointer Material datablock used by this material slot +MaterialSlot.name -> name: string, (read-only) Material slot name +MaterialStrand.blend_distance -> blend_distance: float Worldspace distance over which to blend in the surface normal +MaterialStrand.min_size -> min_size: float Minimum size of strands in pixels +MaterialStrand.root_size -> root_size: float Start size of strands in pixels or Blender units +MaterialStrand.shape -> shape: float Positive values make strands rounder, negative makes strands spiky +MaterialStrand.tip_size -> tip_size: float End size of strands in pixels or Blender units +MaterialStrand.uv_layer -> uv_layer: string Name of UV layer to override +MaterialStrand.width_fade -> width_fade: float Transparency along the width of the strand +MaterialSubsurfaceScattering.back -> back: float Back scattering weight +MaterialSubsurfaceScattering.color -> color: float Scattering color +MaterialSubsurfaceScattering.color_factor -> color_factor: float Blend factor for SSS colors +MaterialSubsurfaceScattering.error_tolerance -> error_tolerance: float Error tolerance (low values are slower and higher quality) +MaterialSubsurfaceScattering.front -> front: float Front scattering weight +MaterialSubsurfaceScattering.ior -> ior: float Index of refraction (higher values are denser) +MaterialSubsurfaceScattering.radius -> radius: float Mean red/green/blue scattering path length +MaterialSubsurfaceScattering.scale -> scale: float Object scale factor +MaterialSubsurfaceScattering.texture_factor -> texture_factor: float Texture scatting blend factor +MaterialTextureSlot.alpha_factor -> alpha_factor: float Amount texture affects alpha +MaterialTextureSlot.ambient_factor -> ambient_factor: float Amount texture affects ambient +MaterialTextureSlot.colordiff_factor -> colordiff_factor: float Amount texture affects diffuse color +MaterialTextureSlot.coloremission_factor -> coloremission_factor: float Amount texture affects emission color +MaterialTextureSlot.colorreflection_factor -> colorreflection_factor: float Amount texture affects color of out-scattered light +MaterialTextureSlot.colorspec_factor -> colorspec_factor: float Amount texture affects specular color +MaterialTextureSlot.colortransmission_factor -> colortransmission_factor: float Amount texture affects result color after light has been scattered/absorbed +MaterialTextureSlot.density_factor -> density_factor: float Amount texture affects density +MaterialTextureSlot.diffuse_factor -> diffuse_factor: float Amount texture affects diffuse reflectivity +MaterialTextureSlot.displacement_factor -> displacement_factor: float Amount texture displaces the surface +MaterialTextureSlot.emission_factor -> emission_factor: float Amount texture affects emission +MaterialTextureSlot.emit_factor -> emit_factor: float Amount texture affects emission +MaterialTextureSlot.hardness_factor -> hardness_factor: float Amount texture affects hardness +MaterialTextureSlot.mapping -> mapping: enum +MaterialTextureSlot.mirror_factor -> mirror_factor: float Amount texture affects mirror color +MaterialTextureSlot.normal_factor -> normal_factor: float Amount texture affects normal values +MaterialTextureSlot.normal_map_space -> normal_map_space: enum +MaterialTextureSlot.object -> object: pointer Object to use for mapping with Object texture coordinates +MaterialTextureSlot.raymir_factor -> raymir_factor: float Amount texture affects ray mirror +MaterialTextureSlot.reflection_factor -> reflection_factor: float Amount texture affects brightness of out-scattered light +MaterialTextureSlot.scattering_factor -> scattering_factor: float Amount texture affects scattering +MaterialTextureSlot.specular_factor -> specular_factor: float Amount texture affects specular reflectivity +MaterialTextureSlot.texture_coordinates -> texture_coordinates: enum +MaterialTextureSlot.translucency_factor -> translucency_factor: float Amount texture affects translucency +MaterialTextureSlot.uv_layer -> uv_layer: string UV layer to use for mapping with UV texture coordinates +MaterialTextureSlot.warp_factor -> warp_factor: float Amount texture affects texture coordinates of next channels +MaterialTextureSlot.x_mapping -> x_mapping: enum +MaterialTextureSlot.y_mapping -> y_mapping: enum +MaterialTextureSlot.z_mapping -> z_mapping: enum +MaterialVolume.asymmetry -> asymmetry: float Back scattering (-1.0) to Forward scattering (1.0) and the range in between +MaterialVolume.cache_resolution -> cache_resolution: int Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory +MaterialVolume.density -> density: float The base density of the volume +MaterialVolume.density_scale -> density_scale: float Multiplier for the material's density +MaterialVolume.depth_cutoff -> depth_cutoff: float Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy +MaterialVolume.emission -> emission: float Amount of light that gets emitted by the volume +MaterialVolume.emission_color -> emission_color: float +MaterialVolume.lighting_mode -> lighting_mode: enum Method of shading, attenuating, and scattering light through the volume +MaterialVolume.ms_diffusion -> ms_diffusion: float Diffusion factor, the strength of the blurring effect +MaterialVolume.ms_intensity -> ms_intensity: float Multiplier for multiple scattered light energy +MaterialVolume.ms_spread -> ms_spread: float Proportional distance over which the light is diffused +MaterialVolume.reflection -> reflection: float Multiplier to make out-scattered light brighter or darker (non-physically correct) +MaterialVolume.reflection_color -> reflection_color: float Colour of light scattered out of the volume (does not affect transmission) +MaterialVolume.scattering -> scattering: float Amount of light that gets scattered out by the volume - the more out-scattering, the shallower the light will penetrate +MaterialVolume.step_calculation -> step_calculation: enum Method of calculating the steps through the volume +MaterialVolume.step_size -> step_size: float Distance between subsequent volume depth samples +MaterialVolume.transmission_color -> transmission_color: float Result color of the volume, after other light has been scattered/absorbed +Menu.bl_idname -> bl_idname: string +Menu.bl_label -> bl_label: string +Menu.layout -> layout: pointer, (read-only) +Mesh.active_uv_texture -> active_uv_texture: pointer Active UV texture +Mesh.active_uv_texture_index -> active_uv_texture_index: int Active UV texture index +Mesh.active_vertex_color -> active_vertex_color: pointer Active vertex color layer +Mesh.active_vertex_color_index -> active_vertex_color_index: int Active vertex color index +Mesh.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Mesh.autosmooth_angle -> autosmooth_angle: int Defines maximum angle between face normals that 'Auto Smooth' will operate on +Mesh.edges -> edges: collection, (read-only) Edges of the mesh +Mesh.faces -> faces: collection, (read-only) Faces of the mesh +Mesh.float_layers -> float_layers: collection, (read-only) +Mesh.int_layers -> int_layers: collection, (read-only) +Mesh.materials -> materials: collection, (read-only) +Mesh.shape_keys -> shape_keys: pointer, (read-only) +Mesh.sticky -> sticky: collection, (read-only) Sticky texture coordinates +Mesh.string_layers -> string_layers: collection, (read-only) +Mesh.texco_mesh -> texco_mesh: pointer Derive texture coordinates from another mesh +Mesh.texspace_loc -> texspace_loc: float Texture space location +Mesh.texspace_size -> texspace_size: float Texture space size +Mesh.texture_mesh -> texture_mesh: pointer Use another mesh for texture indices (vertex indices must be aligned) +Mesh.total_edge_sel -> total_edge_sel: int, (read-only) Selected edge count in editmode +Mesh.total_face_sel -> total_face_sel: int, (read-only) Selected face count in editmode +Mesh.total_vert_sel -> total_vert_sel: int, (read-only) Selected vertex count in editmode +Mesh.uv_texture_clone -> uv_texture_clone: pointer UV texture to be used as cloning source +Mesh.uv_texture_clone_index -> uv_texture_clone_index: int Clone UV texture index +Mesh.uv_texture_stencil -> uv_texture_stencil: pointer UV texture to mask the painted area +Mesh.uv_texture_stencil_index -> uv_texture_stencil_index: int Mask UV texture index +Mesh.uv_textures -> uv_textures: collection, (read-only) +Mesh.vertex_colors -> vertex_colors: collection, (read-only) +Mesh.verts -> verts: collection, (read-only) Vertices of the mesh +MeshColor.color1 -> color1: float +MeshColor.color2 -> color2: float +MeshColor.color3 -> color3: float +MeshColor.color4 -> color4: float +MeshColorLayer.data -> data: collection, (read-only) +MeshColorLayer.name -> name: string +MeshDeformModifier.object -> object: pointer Mesh object to deform with +MeshDeformModifier.precision -> precision: int The grid size for binding +MeshDeformModifier.vertex_group -> vertex_group: string Vertex group name +MeshEdge.bevel_weight -> bevel_weight: float Weight used by the Bevel modifier +MeshEdge.crease -> crease: float Weight used by the Subsurf modifier for creasing +MeshEdge.index -> index: int, (read-only) Index number of the vertex +MeshEdge.verts -> verts: int Vertex indices +MeshFace.area -> area: float, (read-only) read only area of the face +MeshFace.index -> index: int, (read-only) Index number of the vertex +MeshFace.material_index -> material_index: int +MeshFace.normal -> normal: float, (read-only) local space unit length normal vector for this face +MeshFace.verts -> verts: int Vertex indices +MeshFace.verts_raw -> verts_raw: int Fixed size vertex indices array +MeshFaces.active -> active: int The active face for this mesh +MeshFaces.active_tface -> active_tface: pointer, (read-only) Active Texture Face +MeshFloatProperty.value -> value: float +MeshFloatPropertyLayer.data -> data: collection, (read-only) +MeshFloatPropertyLayer.name -> name: string +MeshIntProperty.value -> value: int +MeshIntPropertyLayer.data -> data: collection, (read-only) +MeshIntPropertyLayer.name -> name: string +MeshSticky.co -> co: float Sticky texture coordinate location +MeshStringProperty.value -> value: string +MeshStringPropertyLayer.data -> data: collection, (read-only) +MeshStringPropertyLayer.name -> name: string +MeshTextureFace.image -> image: pointer +MeshTextureFace.transp -> transp: enum Transparency blending mode +MeshTextureFace.uv -> uv: float +MeshTextureFace.uv1 -> uv1: float +MeshTextureFace.uv2 -> uv2: float +MeshTextureFace.uv3 -> uv3: float +MeshTextureFace.uv4 -> uv4: float +MeshTextureFace.uv_raw -> uv_raw: float Fixed size UV coordinates array +MeshTextureFaceLayer.data -> data: collection, (read-only) +MeshTextureFaceLayer.name -> name: string +MeshVertex.bevel_weight -> bevel_weight: float Weight used by the Bevel modifier 'Only Vertices' option +MeshVertex.co -> co: float +MeshVertex.groups -> groups: collection, (read-only) Weights for the vertex groups this vertex is member of +MeshVertex.index -> index: int, (read-only) Index number of the vertex +MeshVertex.normal -> normal: float Vertex Normal +MessageActuator.body_message -> body_message: string Optional message body Text +MessageActuator.body_property -> body_property: string The message body will be set by the Property Value +MessageActuator.body_type -> body_type: enum Toggle message type: either Text or a PropertyName +MessageActuator.subject -> subject: string Optional message subject. This is what can be filtered on +MessageActuator.to_property -> to_property: string Optional send message to objects with this name only, or empty to broadcast +MessageSensor.subject -> subject: string Optional subject filter: only accept messages with this subject, or empty for all +MetaBall.active_element -> active_element: pointer, (read-only) Last selected element +MetaBall.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +MetaBall.elements -> elements: collection, (read-only) Meta elements +MetaBall.flag -> flag: enum Metaball edit update behavior +MetaBall.materials -> materials: collection, (read-only) +MetaBall.render_size -> render_size: float Polygonization resolution in rendering +MetaBall.texspace_loc -> texspace_loc: float Texture space location +MetaBall.texspace_size -> texspace_size: float Texture space size +MetaBall.threshold -> threshold: float Influence of meta elements +MetaBall.wire_size -> wire_size: float Polygonization resolution in the 3D viewport +MetaElement.location -> location: float +MetaElement.radius -> radius: float +MetaElement.rotation -> rotation: float +MetaElement.size_x -> size_x: float Size of element, use of components depends on element type +MetaElement.size_y -> size_y: float Size of element, use of components depends on element type +MetaElement.size_z -> size_z: float Size of element, use of components depends on element type +MetaElement.stiffness -> stiffness: float Stiffness defines how much of the element to fill +MetaElement.type -> type: enum Metaball types +MetaSequence.animation_end_offset -> animation_end_offset: int Animation end offset (trim end) +MetaSequence.animation_start_offset -> animation_start_offset: int Animation start offset (trim start) +MetaSequence.color_balance -> color_balance: pointer, (read-only) +MetaSequence.crop -> crop: pointer, (read-only) +MetaSequence.multiply_colors -> multiply_colors: float +MetaSequence.proxy -> proxy: pointer, (read-only) +MetaSequence.sequences -> sequences: collection, (read-only) +MetaSequence.strobe -> strobe: float Only display every nth frame +MetaSequence.transform -> transform: pointer, (read-only) +MirrorModifier.merge_limit -> merge_limit: float Distance from axis within which mirrored vertices are merged +MirrorModifier.mirror_object -> mirror_object: pointer Object to use as mirror +Modifier.name -> name: string Modifier name +Modifier.type -> type: enum, (read-only) +MotionPath.frame_end -> frame_end: int, (read-only) End frame of the stored range +MotionPath.frame_start -> frame_start: int, (read-only) Starting frame of the stored range +MotionPath.length -> length: int, (read-only) Number of frames cached +MotionPath.points -> points: collection, (read-only) Cached positions per frame +MotionPathVert.co -> co: float +MouseSensor.mouse_event -> mouse_event: enum Specify the type of event this mouse sensor should trigger on +MovieSequence.animation_end_offset -> animation_end_offset: int Animation end offset (trim end) +MovieSequence.animation_start_offset -> animation_start_offset: int Animation start offset (trim start) +MovieSequence.color_balance -> color_balance: pointer, (read-only) +MovieSequence.crop -> crop: pointer, (read-only) +MovieSequence.filepath -> filepath: string +MovieSequence.mpeg_preseek -> mpeg_preseek: int For MPEG movies, preseek this many frames +MovieSequence.multiply_colors -> multiply_colors: float +MovieSequence.proxy -> proxy: pointer, (read-only) +MovieSequence.strobe -> strobe: float Only display every nth frame +MovieSequence.transform -> transform: pointer, (read-only) +MulticamSequence.animation_end_offset -> animation_end_offset: int Animation end offset (trim end) +MulticamSequence.animation_start_offset -> animation_start_offset: int Animation start offset (trim start) +MulticamSequence.color_balance -> color_balance: pointer, (read-only) +MulticamSequence.crop -> crop: pointer, (read-only) +MulticamSequence.multicam_source -> multicam_source: int +MulticamSequence.multiply_colors -> multiply_colors: float +MulticamSequence.proxy -> proxy: pointer, (read-only) +MulticamSequence.strobe -> strobe: float Only display every nth frame +MulticamSequence.transform -> transform: pointer, (read-only) +MultiresModifier.filepath -> filepath: string Path to external displacements file +MultiresModifier.levels -> levels: int Number of subdivisions to use in the viewport +MultiresModifier.render_levels -> render_levels: int +MultiresModifier.sculpt_levels -> sculpt_levels: int Number of subdivisions to use in sculpt mode +MultiresModifier.subdivision_type -> subdivision_type: enum Selects type of subdivision algorithm +MultiresModifier.total_levels -> total_levels: int, (read-only) Number of subdivisions for which displacements are stored +MusgraveTexture.gain -> gain: float The gain multiplier +MusgraveTexture.highest_dimension -> highest_dimension: float Highest fractal dimension +MusgraveTexture.lacunarity -> lacunarity: float Gap between successive frequencies +MusgraveTexture.musgrave_type -> musgrave_type: enum +MusgraveTexture.nabla -> nabla: float Size of derivative offset used for calculating normal +MusgraveTexture.noise_basis -> noise_basis: enum Sets the noise basis used for turbulence +MusgraveTexture.noise_intensity -> noise_intensity: float +MusgraveTexture.noise_size -> noise_size: float Sets scaling for noise input +MusgraveTexture.octaves -> octaves: float Number of frequencies used +MusgraveTexture.offset -> offset: float The fractal offset +NearSensor.distance -> distance: float Trigger distance +NearSensor.property -> property: string Only look for objects with this property +NearSensor.reset_distance -> reset_distance: float +NetRenderJob.name -> name: string +NetRenderSettings.active_blacklisted_slave_index -> active_blacklisted_slave_index: int +NetRenderSettings.active_job_index -> active_job_index: int +NetRenderSettings.active_slave_index -> active_slave_index: int +NetRenderSettings.chunks -> chunks: int Number of frame to dispatch to each slave in one chunk +NetRenderSettings.job_category -> job_category: string Category of the job +NetRenderSettings.job_id -> job_id: string id of the last sent render job +NetRenderSettings.job_name -> job_name: string Name of the job +NetRenderSettings.jobs -> jobs: collection, (read-only) +NetRenderSettings.mode -> mode: enum Mode of operation of this instance +NetRenderSettings.path -> path: string Path for temporary files +NetRenderSettings.priority -> priority: int Priority of the job +NetRenderSettings.server_address -> server_address: string IP or name of the master render server +NetRenderSettings.server_port -> server_port: int port of the master render server +NetRenderSettings.slaves -> slaves: collection, (read-only) +NetRenderSettings.slaves_blacklist -> slaves_blacklist: collection, (read-only) +NetRenderSlave.name -> name: string +NlaStrip.action -> action: pointer Action referenced by this strip +NlaStrip.action_frame_end -> action_frame_end: float +NlaStrip.action_frame_start -> action_frame_start: float +NlaStrip.blend_in -> blend_in: float Number of frames at start of strip to fade in influence +NlaStrip.blend_out -> blend_out: float +NlaStrip.blending -> blending: enum Method used for combining strip's result with accumulated result +NlaStrip.extrapolation -> extrapolation: enum Action to take for gaps past the strip extents +NlaStrip.fcurves -> fcurves: collection, (read-only) F-Curves for controlling the strip's influence and timing +NlaStrip.frame_end -> frame_end: float +NlaStrip.frame_start -> frame_start: float +NlaStrip.influence -> influence: float Amount the strip contributes to the current result +NlaStrip.modifiers -> modifiers: collection, (read-only) Modifiers affecting all the F-Curves in the referenced Action +NlaStrip.name -> name: string +NlaStrip.repeat -> repeat: float Number of times to repeat the action range +NlaStrip.scale -> scale: float Scaling factor for action +NlaStrip.strip_time -> strip_time: float Frame of referenced Action to evaluate +NlaStrip.strips -> strips: collection, (read-only) NLA Strips that this strip acts as a container for (if it is of type Meta) +NlaStrip.type -> type: enum, (read-only) Type of NLA Strip +NlaTrack.name -> name: string +NlaTrack.strips -> strips: collection, (read-only) NLA Strips on this NLA-track +Node.inputs -> inputs: collection, (read-only) +Node.location -> location: float +Node.name -> name: string Node name +Node.outputs -> outputs: collection, (read-only) +NodeGroup.nodetree -> nodetree: pointer +NodeTree.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +NodeTree.grease_pencil -> grease_pencil: pointer Grease Pencil datablock +NodeTree.nodes -> nodes: collection, (read-only) +Object.active_material -> active_material: pointer Active material being displayed +Object.active_material_index -> active_material_index: int Index of active material slot +Object.active_particle_system -> active_particle_system: pointer, (read-only) Active particle system being displayed +Object.active_particle_system_index -> active_particle_system_index: int Index of active particle system slot +Object.active_shape_key -> active_shape_key: pointer, (read-only) Current shape key +Object.active_shape_key_index -> active_shape_key_index: int Current shape key index +Object.active_vertex_group -> active_vertex_group: pointer, (read-only) Vertex groups of the object +Object.active_vertex_group_index -> active_vertex_group_index: int Active index in vertex group array +Object.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Object.animation_visualisation -> animation_visualisation: pointer, (read-only) Animation data for this datablock +Object.bound_box -> bound_box: float, (read-only) Objects bound box in object-space coordinates +Object.collision -> collision: pointer, (read-only) Settings for using the objects as a collider in physics simulation +Object.color -> color: float Object color and alpha, used when faces have the ObColor mode enabled +Object.constraints -> constraints: collection, (read-only) Constraints affecting the transformation of the object +Object.data -> data: pointer Object data +Object.delta_location -> delta_location: float Extra translation added to the location of the object +Object.delta_rotation_euler -> delta_rotation_euler: float Extra rotation added to the rotation of the object (when using Euler rotations) +Object.delta_rotation_quaternion -> delta_rotation_quaternion: float Extra rotation added to the rotation of the object (when using Quaternion rotations) +Object.delta_scale -> delta_scale: float Extra scaling added to the scale of the object +Object.dimensions -> dimensions: float Absolute bounding box dimensions of the object +Object.draw_bounds_type -> draw_bounds_type: enum Object boundary display type +Object.dupli_faces_scale -> dupli_faces_scale: float Scale the DupliFace objects +Object.dupli_frames_end -> dupli_frames_end: int End frame for DupliFrames +Object.dupli_frames_off -> dupli_frames_off: int Recurring frames to exclude from the Dupliframes +Object.dupli_frames_on -> dupli_frames_on: int Number of frames to use between DupOff frames +Object.dupli_frames_start -> dupli_frames_start: int Start frame for DupliFrames +Object.dupli_group -> dupli_group: pointer Instance an existing group +Object.dupli_list -> dupli_list: collection, (read-only) Object duplis +Object.dupli_type -> dupli_type: enum If not None, object duplication method to use +Object.empty_draw_size -> empty_draw_size: float Size of display for empties in the viewport +Object.empty_draw_type -> empty_draw_type: enum Viewport display style for empties +Object.field -> field: pointer, (read-only) Settings for using the objects as a field in physics simulation +Object.game -> game: pointer, (read-only) Game engine related settings for the object +Object.grease_pencil -> grease_pencil: pointer Grease Pencil datablock +Object.location -> location: float Location of the object +Object.material_slots -> material_slots: collection, (read-only) Material slots in the object +Object.matrix_local -> matrix_local: float Parent relative transformation matrix +Object.matrix_world -> matrix_world: float Worldspace transformation matrix +Object.max_draw_type -> max_draw_type: enum Maximum draw type to display object with in viewport +Object.mode -> mode: enum, (read-only) Object interaction mode +Object.modifiers -> modifiers: collection, (read-only) Modifiers affecting the geometric data of the object +Object.motion_path -> motion_path: pointer, (read-only) Motion Path for this element +Object.parent -> parent: pointer Parent Object +Object.parent_bone -> parent_bone: string Name of parent bone in case of a bone parenting relation +Object.parent_type -> parent_type: enum Type of parent relation +Object.parent_vertices -> parent_vertices: int, (read-only) Indices of vertices in cases of a vertex parenting relation +Object.particle_systems -> particle_systems: collection, (read-only) Particle systems emitted from the object +Object.pass_index -> pass_index: int Index # for the IndexOB render pass +Object.pose -> pose: pointer, (read-only) Current pose for armatures +Object.pose_library -> pose_library: pointer, (read-only) Action used as a pose library for armatures +Object.proxy -> proxy: pointer, (read-only) Library object this proxy object controls +Object.proxy_group -> proxy_group: pointer, (read-only) Library group duplicator object this proxy object controls +Object.rotation_axis_angle -> rotation_axis_angle: float Angle of Rotation for Axis-Angle rotation representation +Object.rotation_euler -> rotation_euler: float Rotation in Eulers +Object.rotation_mode -> rotation_mode: enum +Object.rotation_quaternion -> rotation_quaternion: float Rotation in Quaternions +Object.scale -> scale: float Scaling of the object +Object.soft_body -> soft_body: pointer, (read-only) Settings for soft body simulation +Object.time_offset -> time_offset: float Animation offset in frames for F-Curve and dupligroup instances +Object.track_axis -> track_axis: enum Axis that points in 'forward' direction +Object.type -> type: enum, (read-only) Type of Object +Object.up_axis -> up_axis: enum Axis that points in the upward direction +Object.vertex_groups -> vertex_groups: collection, (read-only) Vertex groups of the object +ObjectActuator.angular_velocity -> angular_velocity: float Sets the angular velocity +ObjectActuator.damping -> damping: int Number of frames to reach the target velocity +ObjectActuator.derivate_coefficient -> derivate_coefficient: float Not required, high values can cause instability +ObjectActuator.force -> force: float Sets the force +ObjectActuator.force_max_x -> force_max_x: float Set the upper limit for force +ObjectActuator.force_max_y -> force_max_y: float Set the upper limit for force +ObjectActuator.force_max_z -> force_max_z: float Set the upper limit for force +ObjectActuator.force_min_x -> force_min_x: float Set the lower limit for force +ObjectActuator.force_min_y -> force_min_y: float Set the lower limit for force +ObjectActuator.force_min_z -> force_min_z: float Set the lower limit for force +ObjectActuator.integral_coefficient -> integral_coefficient: float Low value (0.01) for slow response, high value (0.5) for fast response +ObjectActuator.linear_velocity -> linear_velocity: float Sets the linear velocity (in Servo mode it sets the target relative linear velocity, it will be achieved by automatic application of force. Null velocity is a valid target) +ObjectActuator.loc -> loc: float Sets the location +ObjectActuator.mode -> mode: enum Specify the motion system +ObjectActuator.proportional_coefficient -> proportional_coefficient: float Typical value is 60x integral coefficient +ObjectActuator.reference_object -> reference_object: pointer Reference object for velocity calculation, leave empty for world reference +ObjectActuator.rot -> rot: float Sets the rotation +ObjectActuator.torque -> torque: float Sets the torque +ObjectBase.object -> object: pointer, (read-only) Object this base links to +ObjectConstraints.active -> active: pointer Active Object constraint +ObstacleFluidSettings.impact_factor -> impact_factor: float This is an unphysical value for moving objects - it controls the impact an obstacle has on the fluid, =0 behaves a bit like outflow (deleting fluid), =1 is default, while >1 results in high forces. Can be used to tweak total mass +ObstacleFluidSettings.partial_slip_factor -> partial_slip_factor: float Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip +ObstacleFluidSettings.slip_type -> slip_type: enum +ObstacleFluidSettings.volume_initialization -> volume_initialization: enum Volume initialization type +Operator.bl_description -> bl_description: string +Operator.bl_idname -> bl_idname: string +Operator.bl_label -> bl_label: string +Operator.bl_options -> bl_options: enum Options for this operator type +Operator.layout -> layout: pointer, (read-only) +Operator.name -> name: string, (read-only) +Operator.properties -> properties: pointer, (read-only) +OperatorFileListElement.name -> name: string the name of a file or directory within a file list +OperatorMousePath.loc -> loc: float Mouse location +OperatorMousePath.time -> time: float Time of mouse location +OperatorStrokeElement.location -> location: float +OperatorStrokeElement.mouse -> mouse: float +OperatorStrokeElement.pressure -> pressure: float Tablet pressure +OperatorStrokeElement.time -> time: float +OperatorTypeMacro.properties -> properties: pointer, (read-only) +OutflowFluidSettings.volume_initialization -> volume_initialization: enum Volume initialization type +PackedFile.size -> size: int, (read-only) Size of packed file in bytes +Paint.active_brush_index -> active_brush_index: int +Paint.active_brush_name -> active_brush_name: string +Paint.brush -> brush: pointer Active paint brush +Paint.brushes -> brushes: collection, (read-only) Brushes selected for this paint mode +Panel.bl_context -> bl_context: string +Panel.bl_idname -> bl_idname: string +Panel.bl_label -> bl_label: string +Panel.bl_region_type -> bl_region_type: enum +Panel.bl_space_type -> bl_space_type: enum +Panel.layout -> layout: pointer, (read-only) +Panel.text -> text: string +ParentActuator.mode -> mode: enum +ParentActuator.object -> object: pointer Set this object as parent +Particle.alive_state -> alive_state: enum +Particle.angular_velocity -> angular_velocity: float +Particle.birthtime -> birthtime: float +Particle.die_time -> die_time: float +Particle.hair -> hair: collection, (read-only) +Particle.keys -> keys: collection, (read-only) +Particle.lifetime -> lifetime: float +Particle.location -> location: float +Particle.prev_angular_velocity -> prev_angular_velocity: float +Particle.prev_location -> prev_location: float +Particle.prev_rotation -> prev_rotation: float +Particle.prev_velocity -> prev_velocity: float +Particle.rotation -> rotation: float +Particle.size -> size: float +Particle.velocity -> velocity: float +ParticleBrush.count -> count: int Particle count +ParticleBrush.curve -> curve: pointer, (read-only) +ParticleBrush.length_mode -> length_mode: enum +ParticleBrush.puff_mode -> puff_mode: enum +ParticleBrush.size -> size: int Brush size +ParticleBrush.steps -> steps: int Brush steps +ParticleBrush.strength -> strength: float Brush strength +ParticleDupliWeight.count -> count: int The number of times this object is repeated with respect to other objects +ParticleDupliWeight.name -> name: string, (read-only) Particle dupliobject name +ParticleEdit.add_keys -> add_keys: int How many keys to make new particles with +ParticleEdit.brush -> brush: pointer, (read-only) +ParticleEdit.draw_step -> draw_step: int How many steps to draw the path with +ParticleEdit.emitter_distance -> emitter_distance: float Distance to keep particles away from the emitter +ParticleEdit.fade_frames -> fade_frames: int How many frames to fade +ParticleEdit.object -> object: pointer, (read-only) The edited object +ParticleEdit.selection_mode -> selection_mode: enum Particle select and display mode +ParticleEdit.tool -> tool: enum +ParticleEdit.type -> type: enum +ParticleFluidSettings.alpha_influence -> alpha_influence: float Amount of particle alpha change, inverse of size influence: 0=off (all same alpha), 1=full. (large particles get lower alphas, smaller ones higher values) +ParticleFluidSettings.particle_influence -> particle_influence: float Amount of particle size scaling: 0=off (all same size), 1=full (range 0.2-2.0), >1=stronger +ParticleFluidSettings.path -> path: string Directory (and/or filename prefix) to store and load particles from +ParticleHairKey.location -> location: float Location of the hair key in object space +ParticleHairKey.location_hairspace -> location_hairspace: float Location of the hair key in its internal coordinate system, relative to the emitting face +ParticleHairKey.time -> time: float Relative time of key over hair length +ParticleHairKey.weight -> weight: float Weight for cloth simulation +ParticleInstanceModifier.axis -> axis: enum Pole axis for rotation +ParticleInstanceModifier.object -> object: pointer Object that has the particle system +ParticleInstanceModifier.particle_system_number -> particle_system_number: int +ParticleInstanceModifier.position -> position: float Position along path +ParticleInstanceModifier.random_position -> random_position: float Randomize position along path +ParticleKey.angular_velocity -> angular_velocity: float Key angular velocity +ParticleKey.location -> location: float Key location +ParticleKey.rotation -> rotation: float Key rotation quaterion +ParticleKey.time -> time: float Time of key over the simulation +ParticleKey.velocity -> velocity: float Key velocity +ParticleSettings.active_dupliweight -> active_dupliweight: pointer, (read-only) +ParticleSettings.active_dupliweight_index -> active_dupliweight_index: int +ParticleSettings.adaptive_angle -> adaptive_angle: int How many degrees path has to curve to make another render segment +ParticleSettings.adaptive_pix -> adaptive_pix: int How many pixels path has to cover to make another render segment +ParticleSettings.amount -> amount: int Total number of particles +ParticleSettings.angular_velocity_factor -> angular_velocity_factor: float Angular velocity amount +ParticleSettings.angular_velocity_mode -> angular_velocity_mode: enum Particle angular velocity mode +ParticleSettings.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +ParticleSettings.billboard_align -> billboard_align: enum In respect to what the billboards are aligned +ParticleSettings.billboard_animation -> billboard_animation: enum How to animate billboard textures +ParticleSettings.billboard_object -> billboard_object: pointer Billboards face this object (default is active camera) +ParticleSettings.billboard_offset -> billboard_offset: float +ParticleSettings.billboard_random_tilt -> billboard_random_tilt: float Random tilt of the billboards +ParticleSettings.billboard_split_offset -> billboard_split_offset: enum How to offset billboard textures +ParticleSettings.billboard_tilt -> billboard_tilt: float Tilt of the billboards +ParticleSettings.billboard_uv_split -> billboard_uv_split: int Amount of rows/columns to split UV coordinates for billboards +ParticleSettings.boids -> boids: pointer, (read-only) +ParticleSettings.branch_threshold -> branch_threshold: float Threshold of branching +ParticleSettings.brownian_factor -> brownian_factor: float Specify the amount of Brownian motion +ParticleSettings.child_length -> child_length: float Length of child paths +ParticleSettings.child_length_thres -> child_length_thres: float Amount of particles left untouched by child path length +ParticleSettings.child_nbr -> child_nbr: int Amount of children/parent +ParticleSettings.child_radius -> child_radius: float Radius of children around parent +ParticleSettings.child_random_size -> child_random_size: float Random variation to the size of the child particles +ParticleSettings.child_roundness -> child_roundness: float Roundness of children around parent +ParticleSettings.child_size -> child_size: float A multiplier for the child particle size +ParticleSettings.child_type -> child_type: enum Create child particles +ParticleSettings.clump_factor -> clump_factor: float Amount of clumping +ParticleSettings.clumppow -> clumppow: float Shape of clumping +ParticleSettings.damp_factor -> damp_factor: float Specify the amount of damping +ParticleSettings.display -> display: int Percentage of particles to display in 3D view +ParticleSettings.distribution -> distribution: enum How to distribute particles on selected element +ParticleSettings.drag_factor -> drag_factor: float Specify the amount of air-drag +ParticleSettings.draw_as -> draw_as: enum How particles are drawn in viewport +ParticleSettings.draw_size -> draw_size: int Size of particles on viewport in pixels (0=default) +ParticleSettings.draw_step -> draw_step: int How many steps paths are drawn with (power of 2) +ParticleSettings.dupli_group -> dupli_group: pointer Show Objects in this Group in place of particles +ParticleSettings.dupli_object -> dupli_object: pointer Show this Object in place of particles +ParticleSettings.dupliweights -> dupliweights: collection, (read-only) Weights for all of the objects in the dupli group +ParticleSettings.effect_hair -> effect_hair: float Hair stiffness for effectors +ParticleSettings.effector_weights -> effector_weights: pointer, (read-only) +ParticleSettings.emit_from -> emit_from: enum Where to emit particles from +ParticleSettings.fluid -> fluid: pointer, (read-only) +ParticleSettings.force_field_1 -> force_field_1: pointer, (read-only) +ParticleSettings.force_field_2 -> force_field_2: pointer, (read-only) +ParticleSettings.frame_end -> frame_end: float Frame # to stop emitting particles +ParticleSettings.frame_start -> frame_start: float Frame # to start emitting particles +ParticleSettings.grid_resolution -> grid_resolution: int The resolution of the particle grid +ParticleSettings.hair_step -> hair_step: int Number of hair segments +ParticleSettings.integrator -> integrator: enum Select physics integrator type +ParticleSettings.jitter_factor -> jitter_factor: float Amount of jitter applied to the sampling +ParticleSettings.keyed_loops -> keyed_loops: int Number of times the keys are looped +ParticleSettings.keys_step -> keys_step: int +ParticleSettings.kink -> kink: enum Type of periodic offset on the path +ParticleSettings.kink_amplitude -> kink_amplitude: float The amplitude of the offset +ParticleSettings.kink_axis -> kink_axis: enum Which axis to use for offset +ParticleSettings.kink_frequency -> kink_frequency: float The frequency of the offset (1/total length) +ParticleSettings.kink_shape -> kink_shape: float Adjust the offset to the beginning/end +ParticleSettings.lifetime -> lifetime: float Specify the life span of the particles +ParticleSettings.line_length_head -> line_length_head: float Length of the line's head +ParticleSettings.line_length_tail -> line_length_tail: float Length of the line's tail +ParticleSettings.mass -> mass: float Specify the mass of the particles +ParticleSettings.material -> material: int Specify material used for the particles +ParticleSettings.normal_factor -> normal_factor: float Let the surface normal give the particle a starting speed +ParticleSettings.object_aligned_factor -> object_aligned_factor: float Let the emitter object orientation give the particle a starting speed +ParticleSettings.object_factor -> object_factor: float Let the object give the particle a starting speed +ParticleSettings.particle_factor -> particle_factor: float Let the target particle give the particle a starting speed +ParticleSettings.particle_size -> particle_size: float The size of the particles +ParticleSettings.path_end -> path_end: float End time of drawn path +ParticleSettings.path_start -> path_start: float Starting time of drawn path +ParticleSettings.phase_factor -> phase_factor: float Initial rotation phase +ParticleSettings.physics_type -> physics_type: enum Particle physics type +ParticleSettings.random_factor -> random_factor: float Give the starting speed a random variation +ParticleSettings.random_length -> random_length: float Give path length a random variation +ParticleSettings.random_lifetime -> random_lifetime: float Give the particle life a random variation +ParticleSettings.random_phase_factor -> random_phase_factor: float Randomize rotation phase +ParticleSettings.random_rotation_factor -> random_rotation_factor: float Randomize rotation +ParticleSettings.random_size -> random_size: float Give the particle size a random variation +ParticleSettings.react_event -> react_event: enum The event of target particles to react on +ParticleSettings.reaction_shape -> reaction_shape: float Power of reaction strength dependence on distance to target +ParticleSettings.reactor_factor -> reactor_factor: float Let the vector away from the target particles location give the particle a starting speed +ParticleSettings.ren_as -> ren_as: enum How particles are rendered +ParticleSettings.render_step -> render_step: int How many steps paths are rendered with (power of 2) +ParticleSettings.rendered_child_nbr -> rendered_child_nbr: int Amount of children/parent for rendering +ParticleSettings.rotate_from -> rotate_from: enum +ParticleSettings.rotation_mode -> rotation_mode: enum Particles initial rotation +ParticleSettings.rough1 -> rough1: float Amount of location dependent rough +ParticleSettings.rough1_size -> rough1_size: float Size of location dependent rough +ParticleSettings.rough2 -> rough2: float Amount of random rough +ParticleSettings.rough2_size -> rough2_size: float Size of random rough +ParticleSettings.rough2_thres -> rough2_thres: float Amount of particles left untouched by random rough +ParticleSettings.rough_end_shape -> rough_end_shape: float Shape of end point rough +ParticleSettings.rough_endpoint -> rough_endpoint: float Amount of end point rough +ParticleSettings.simplify_rate -> simplify_rate: float Speed of simplification +ParticleSettings.simplify_refsize -> simplify_refsize: int Reference size in pixels, after which simplification begins +ParticleSettings.simplify_transition -> simplify_transition: float Transition period for fading out strands +ParticleSettings.simplify_viewport -> simplify_viewport: float Speed of Simplification +ParticleSettings.subframes -> subframes: int Subframes to simulate for improved stability and finer granularity simulations +ParticleSettings.tangent_factor -> tangent_factor: float Let the surface tangent give the particle a starting speed +ParticleSettings.tangent_phase -> tangent_phase: float Rotate the surface tangent +ParticleSettings.time_tweak -> time_tweak: float A multiplier for physics timestep (1.0 means one frame = 1/25 seconds) +ParticleSettings.trail_count -> trail_count: int Number of trail particles +ParticleSettings.type -> type: enum +ParticleSettings.userjit -> userjit: int Emission locations / face (0 = automatic) +ParticleSettings.virtual_parents -> virtual_parents: float Relative amount of virtual parents +ParticleSystem.active_particle_target -> active_particle_target: pointer, (read-only) +ParticleSystem.active_particle_target_index -> active_particle_target_index: int +ParticleSystem.billboard_normal_uv -> billboard_normal_uv: string UV Layer to control billboard normals +ParticleSystem.billboard_split_uv -> billboard_split_uv: string UV Layer to control billboard splitting +ParticleSystem.billboard_time_index_uv -> billboard_time_index_uv: string UV Layer to control billboard time index (X-Y) +ParticleSystem.child_particles -> child_particles: collection, (read-only) Child particles generated by the particle system +ParticleSystem.cloth -> cloth: pointer, (read-only) Cloth dynamics for hair +ParticleSystem.name -> name: string Particle system name +ParticleSystem.parent -> parent: pointer Use this object's coordinate system instead of global coordinate system +ParticleSystem.particles -> particles: collection, (read-only) Particles generated by the particle system +ParticleSystem.point_cache -> point_cache: pointer, (read-only) +ParticleSystem.reactor_target_object -> reactor_target_object: pointer For reactor systems, the object that has the target particle system (empty if same object) +ParticleSystem.reactor_target_particle_system -> reactor_target_particle_system: int For reactor systems, index of particle system on the target object +ParticleSystem.seed -> seed: int Offset in the random number table, to get a different randomized result +ParticleSystem.settings -> settings: pointer Particle system settings +ParticleSystem.targets -> targets: collection, (read-only) Target particle systems +ParticleSystem.vertex_group_clump -> vertex_group_clump: string Vertex group to control clump +ParticleSystem.vertex_group_density -> vertex_group_density: string Vertex group to control density +ParticleSystem.vertex_group_field -> vertex_group_field: string Vertex group to control field +ParticleSystem.vertex_group_kink -> vertex_group_kink: string Vertex group to control kink +ParticleSystem.vertex_group_length -> vertex_group_length: string Vertex group to control length +ParticleSystem.vertex_group_rotation -> vertex_group_rotation: string Vertex group to control rotation +ParticleSystem.vertex_group_roughness1 -> vertex_group_roughness1: string Vertex group to control roughness 1 +ParticleSystem.vertex_group_roughness2 -> vertex_group_roughness2: string Vertex group to control roughness 2 +ParticleSystem.vertex_group_roughness_end -> vertex_group_roughness_end: string Vertex group to control roughness end +ParticleSystem.vertex_group_size -> vertex_group_size: string Vertex group to control size +ParticleSystem.vertex_group_tangent -> vertex_group_tangent: string Vertex group to control tangent +ParticleSystem.vertex_group_velocity -> vertex_group_velocity: string Vertex group to control velocity +ParticleSystemModifier.particle_system -> particle_system: pointer, (read-only) Particle System that this modifier controls +ParticleTarget.duration -> duration: float +ParticleTarget.mode -> mode: enum +ParticleTarget.name -> name: string, (read-only) Particle target name +ParticleTarget.object -> object: pointer The object that has the target particle system (empty if same object) +ParticleTarget.system -> system: int The index of particle system on the target object +ParticleTarget.time -> time: float +PivotConstraint.enabled_rotation_range -> enabled_rotation_range: enum Rotation range on which pivoting should occur +PivotConstraint.head_tail -> head_tail: float Target along length of bone: Head=0, Tail=1 +PivotConstraint.offset -> offset: float Offset of pivot from target (when set), or from owner's location (when Fixed Position is off), or the absolute pivot point +PivotConstraint.subtarget -> subtarget: string +PivotConstraint.target -> target: pointer Target Object, defining the position of the pivot when defined +PluginSequence.filename -> filename: string, (read-only) +PointCache.active_point_cache_index -> active_point_cache_index: int +PointCache.filepath -> filepath: string Cache file path +PointCache.frame_end -> frame_end: int Frame on which the simulation stops +PointCache.frame_start -> frame_start: int Frame on which the simulation starts +PointCache.index -> index: int Index number of cache files +PointCache.info -> info: string, (read-only) Info on current cache status +PointCache.name -> name: string Cache name +PointCache.point_cache_list -> point_cache_list: collection, (read-only) Point cache list +PointCache.step -> step: int Number of frames between cached frames +PointDensity.color_ramp -> color_ramp: pointer, (read-only) +PointDensity.color_source -> color_source: enum Data to derive color results from +PointDensity.falloff -> falloff: enum Method of attenuating density by distance from the point +PointDensity.falloff_softness -> falloff_softness: float Softness of the 'soft' falloff option +PointDensity.noise_basis -> noise_basis: enum Noise formula used for turbulence +PointDensity.object -> object: pointer Object to take point data from +PointDensity.particle_cache -> particle_cache: enum Co-ordinate system to cache particles in +PointDensity.particle_system -> particle_system: pointer Particle System to render as points +PointDensity.point_source -> point_source: enum Point data to use as renderable point density +PointDensity.radius -> radius: float Radius from the shaded sample to look for points within +PointDensity.speed_scale -> speed_scale: float Multiplier to bring particle speed within an acceptable range +PointDensity.turbulence_depth -> turbulence_depth: int Level of detail in the added turbulent noise +PointDensity.turbulence_influence -> turbulence_influence: enum Method for driving added turbulent noise +PointDensity.turbulence_size -> turbulence_size: float Scale of the added turbulent noise +PointDensity.turbulence_strength -> turbulence_strength: float +PointDensity.vertices_cache -> vertices_cache: enum Co-ordinate system to cache vertices in +PointDensityTexture.pointdensity -> pointdensity: pointer, (read-only) The point density settings associated with this texture +PointLamp.falloff_curve -> falloff_curve: pointer, (read-only) Custom Lamp Falloff Curve +PointLamp.falloff_type -> falloff_type: enum Intensity Decay with distance +PointLamp.linear_attenuation -> linear_attenuation: float Linear distance attenuation +PointLamp.quadratic_attenuation -> quadratic_attenuation: float Quadratic distance attenuation +PointLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold: float Threshold for Adaptive Sampling (Raytraced shadows) +PointLamp.shadow_color -> shadow_color: float Color of shadows cast by the lamp +PointLamp.shadow_method -> shadow_method: enum Method to compute lamp shadow with +PointLamp.shadow_ray_samples -> shadow_ray_samples: int Amount of samples taken extra (samples x samples) +PointLamp.shadow_ray_sampling_method -> shadow_ray_sampling_method: enum Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower +PointLamp.shadow_soft_size -> shadow_soft_size: float Light size for ray shadow sampling (Raytraced shadows) +PointerProperty.fixed_type -> fixed_type: pointer, (read-only) Fixed pointer type, empty if variable type +Pose.active_bone_group -> active_bone_group: pointer Active bone group for this pose +Pose.active_bone_group_index -> active_bone_group_index: int Active index in bone groups array +Pose.animation_visualisation -> animation_visualisation: pointer, (read-only) Animation data for this datablock +Pose.bone_groups -> bone_groups: collection, (read-only) Groups of the bones +Pose.bones -> bones: collection, (read-only) Individual pose bones for the armature +Pose.ik_param -> ik_param: pointer, (read-only) Parameters for IK solver +Pose.ik_solver -> ik_solver: enum Selection of IK solver for IK chain, current choice is 0 for Legacy, 1 for iTaSC +PoseBone.bone -> bone: pointer, (read-only) Bone associated with this PoseBone +PoseBone.bone_group -> bone_group: pointer Bone Group this pose channel belongs to +PoseBone.bone_group_index -> bone_group_index: int Bone Group this pose channel belongs to (0=no group) +PoseBone.child -> child: pointer, (read-only) Child of this pose bone +PoseBone.constraints -> constraints: collection, (read-only) Constraints that act on this PoseChannel +PoseBone.custom_shape -> custom_shape: pointer Object that defines custom draw type for this bone +PoseBone.custom_shape_transform -> custom_shape_transform: pointer Bone that defines the display transform of this custom shape +PoseBone.head -> head: float, (read-only) Location of head of the channel's bone +PoseBone.ik_lin_weight -> ik_lin_weight: float Weight of scale constraint for IK +PoseBone.ik_max_x -> ik_max_x: float Maximum angles for IK Limit +PoseBone.ik_max_y -> ik_max_y: float Maximum angles for IK Limit +PoseBone.ik_max_z -> ik_max_z: float Maximum angles for IK Limit +PoseBone.ik_min_x -> ik_min_x: float Minimum angles for IK Limit +PoseBone.ik_min_y -> ik_min_y: float Minimum angles for IK Limit +PoseBone.ik_min_z -> ik_min_z: float Minimum angles for IK Limit +PoseBone.ik_rot_weight -> ik_rot_weight: float Weight of rotation constraint for IK +PoseBone.ik_stiffness_x -> ik_stiffness_x: float IK stiffness around the X axis +PoseBone.ik_stiffness_y -> ik_stiffness_y: float IK stiffness around the Y axis +PoseBone.ik_stiffness_z -> ik_stiffness_z: float IK stiffness around the Z axis +PoseBone.ik_stretch -> ik_stretch: float Allow scaling of the bone for IK +PoseBone.location -> location: float +PoseBone.matrix -> matrix: float, (read-only) Final 4x4 matrix for this channel +PoseBone.matrix_channel -> matrix_channel: float, (read-only) 4x4 matrix, before constraints +PoseBone.matrix_local -> matrix_local: float Matrix representing the parent relative location, scale and rotation. Provides an alternative access to these properties. +PoseBone.motion_path -> motion_path: pointer, (read-only) Motion Path for this element +PoseBone.name -> name: string +PoseBone.parent -> parent: pointer, (read-only) Parent of this pose bone +PoseBone.rotation_axis_angle -> rotation_axis_angle: float Angle of Rotation for Axis-Angle rotation representation +PoseBone.rotation_euler -> rotation_euler: float Rotation in Eulers +PoseBone.rotation_mode -> rotation_mode: enum +PoseBone.rotation_quaternion -> rotation_quaternion: float Rotation in Quaternions +PoseBone.scale -> scale: float +PoseBone.tail -> tail: float, (read-only) Location of tail of the channel's bone +PoseBoneConstraints.active -> active: pointer Active PoseChannel constraint +PoseTemplate.name -> name: string +PoseTemplateSettings.active_template_index -> active_template_index: int +PoseTemplateSettings.templates -> templates: collection, (read-only) +Property.description -> description: string, (read-only) Description of the property for tooltips +Property.identifier -> identifier: string, (read-only) Unique name used in the code and scripting +Property.name -> name: string, (read-only) Human readable name +Property.srna -> srna: pointer, (read-only) Struct definition used for properties assigned to this item +Property.subtype -> subtype: enum, (read-only) Semantic interpretation of the property +Property.type -> type: enum, (read-only) Data type of the property +Property.unit -> unit: enum, (read-only) Type of units for this property +PropertyActuator.mode -> mode: enum +PropertyActuator.object -> object: pointer Copy from this Object +PropertyActuator.object_property -> object_property: string Copy this property +PropertyActuator.property -> property: string The name of the property +PropertyActuator.value -> value: string The value to use, use "" around strings +PropertySensor.evaluation_type -> evaluation_type: enum Type of property evaluation +PropertySensor.max_value -> max_value: string Specify maximum value in Interval type +PropertySensor.min_value -> min_value: string Specify minimum value in Interval type +PropertySensor.property -> property: string +PropertySensor.value -> value: string Check for this value in types in Equal or Not Equal types +PythonConstraint.number_of_targets -> number_of_targets: int Usually only 1-3 are needed +PythonConstraint.targets -> targets: collection, (read-only) Target Objects +PythonConstraint.text -> text: pointer The text object that contains the Python script +PythonController.mode -> mode: enum Python script type (textblock or module - faster) +PythonController.module -> module: string Module name and function to run e.g. "someModule.main". Internal texts and external python files can be used +PythonController.text -> text: pointer Text datablock with the python script +RGBANodeSocket.default_value -> default_value: float Default value of the socket when no link is attached +RGBANodeSocket.name -> name: string, (read-only) Socket name +RadarSensor.angle -> angle: float Opening angle of the radar cone +RadarSensor.axis -> axis: enum Specify along which axis the radar cone is cast +RadarSensor.distance -> distance: float Depth of the radar cone +RadarSensor.property -> property: string Only look for Objects with this property +RandomActuator.chance -> chance: float Pick a number between 0 and 1. Success if you stay below this value +RandomActuator.distribution -> distribution: enum Choose the type of distribution +RandomActuator.float_max -> float_max: float Choose a number from a range. Upper boundary of the range +RandomActuator.float_mean -> float_mean: float A normal distribution. Mean of the distribution +RandomActuator.float_min -> float_min: float Choose a number from a range. Lower boundary of the range +RandomActuator.float_value -> float_value: float Always return this number +RandomActuator.half_life_time -> half_life_time: float Negative exponential dropoff +RandomActuator.int_max -> int_max: int Choose a number from a range. Upper boundary of the range +RandomActuator.int_mean -> int_mean: float Expected mean value of the distribution +RandomActuator.int_min -> int_min: int Choose a number from a range. Lower boundary of the range +RandomActuator.int_value -> int_value: int Always return this number +RandomActuator.property -> property: string Assign the random value to this property +RandomActuator.seed -> seed: int Initial seed of the random generator. Use Python for more freedom (choose 0 for not random) +RandomActuator.standard_derivation -> standard_derivation: float A normal distribution. Standard deviation of the distribution +RandomSensor.seed -> seed: int Initial seed of the generator. (Choose 0 for not random) +RaySensor.axis -> axis: enum Specify along which axis the ray is cast +RaySensor.material -> material: string Only look for Objects with this material +RaySensor.property -> property: string Only look for Objects with this property +RaySensor.range -> range: float Sense objects no farther than this distance +RaySensor.ray_type -> ray_type: enum Toggle collision on material or property +Region.height -> height: int, (read-only) Region height +Region.id -> id: int, (read-only) Unique ID for this region +Region.type -> type: enum, (read-only) Type of this region +Region.width -> width: int, (read-only) Region width +RegionView3D.perspective_matrix -> perspective_matrix: float, (read-only) Current perspective matrix of the 3D region +RegionView3D.view_distance -> view_distance: float Distance to the view location +RegionView3D.view_location -> view_location: float View pivot location +RegionView3D.view_matrix -> view_matrix: float, (read-only) Current view matrix of the 3D region +RegionView3D.view_perspective -> view_perspective: enum View Perspective +RegionView3D.view_rotation -> view_rotation: float Rotation in quaternions (keep normalized) +RenderEngine.bl_idname -> bl_idname: string +RenderEngine.bl_label -> bl_label: string +RenderLayer.light_override -> light_override: pointer, (read-only) Group to override all other lights in this render layer +RenderLayer.material_override -> material_override: pointer, (read-only) Material to override all other materials in this render layer +RenderLayer.name -> name: string, (read-only) Render layer name +RenderLayer.passes -> passes: collection, (read-only) +RenderLayer.rect -> rect: float +RenderPass.channel_id -> channel_id: string, (read-only) +RenderPass.channels -> channels: int, (read-only) +RenderPass.name -> name: string, (read-only) +RenderPass.rect -> rect: float +RenderPass.type -> type: enum, (read-only) +RenderResult.layers -> layers: collection, (read-only) +RenderResult.resolution_x -> resolution_x: int, (read-only) +RenderResult.resolution_y -> resolution_y: int, (read-only) +RenderSettings.active_layer_index -> active_layer_index: int Active index in render layer array +RenderSettings.alpha_mode -> alpha_mode: enum Representation of alpha information in the RGBA pixels +RenderSettings.antialiasing_samples -> antialiasing_samples: enum Amount of anti-aliasing samples per pixel +RenderSettings.bake_aa_mode -> bake_aa_mode: enum +RenderSettings.bake_bias -> bake_bias: float Bias towards faces further away from the object (in blender units) +RenderSettings.bake_distance -> bake_distance: float Maximum distance from active object to other object (in blender units +RenderSettings.bake_margin -> bake_margin: int Amount of pixels to extend the baked result with, as post process filter +RenderSettings.bake_normal_space -> bake_normal_space: enum Choose normal space for baking +RenderSettings.bake_quad_split -> bake_quad_split: enum Choose the method used to split a quad into 2 triangles for baking +RenderSettings.bake_type -> bake_type: enum Choose shading information to bake into the image +RenderSettings.border_max_x -> border_max_x: float Sets maximum X value for the render border +RenderSettings.border_max_y -> border_max_y: float Sets maximum Y value for the render border +RenderSettings.border_min_x -> border_min_x: float Sets minimum X value to for the render border +RenderSettings.border_min_y -> border_min_y: float Sets minimum Y value for the render border +RenderSettings.cineon_black -> cineon_black: int Log conversion reference blackpoint +RenderSettings.cineon_gamma -> cineon_gamma: float Log conversion gamma +RenderSettings.cineon_white -> cineon_white: int Log conversion reference whitepoint +RenderSettings.color_mode -> color_mode: enum Choose BW for saving greyscale images, RGB for saving red, green and blue channels, AND RGBA for saving red, green, blue + alpha channels +RenderSettings.display_mode -> display_mode: enum Select where rendered images will be displayed +RenderSettings.dither_intensity -> dither_intensity: float Amount of dithering noise added to the rendered image to break up banding +RenderSettings.edge_color -> edge_color: float +RenderSettings.edge_threshold -> edge_threshold: int Threshold for drawing outlines on geometry edges +RenderSettings.engine -> engine: enum Engine to use for rendering +RenderSettings.field_order -> field_order: enum Order of video fields. Select which lines get rendered first, to create smooth motion for TV output +RenderSettings.file_extension -> file_extension: string, (read-only) The file extension used for saving renders +RenderSettings.file_format -> file_format: enum File format to save the rendered images as +RenderSettings.file_quality -> file_quality: int Quality of JPEG images, AVI Jpeg and SGI movies +RenderSettings.filter_size -> filter_size: float Pixel width over which the reconstruction filter combines samples +RenderSettings.fps -> fps: int Framerate, expressed in frames per second +RenderSettings.fps_base -> fps_base: float Framerate base +RenderSettings.layers -> layers: collection, (read-only) +RenderSettings.motion_blur_samples -> motion_blur_samples: int Number of scene samples to take with motion blur +RenderSettings.motion_blur_shutter -> motion_blur_shutter: float Time taken in frames between shutter open and close +RenderSettings.octree_resolution -> octree_resolution: enum Resolution of raytrace accelerator. Use higher resolutions for larger scenes +RenderSettings.output_path -> output_path: string Directory/name to save animations, # characters defines the position and length of frame numbers +RenderSettings.parts_x -> parts_x: int Number of horizontal tiles to use while rendering +RenderSettings.parts_y -> parts_y: int Number of vertical tiles to use while rendering +RenderSettings.pixel_aspect_x -> pixel_aspect_x: float Horizontal aspect ratio - for anamorphic or non-square pixel output +RenderSettings.pixel_aspect_y -> pixel_aspect_y: float Vertical aspect ratio - for anamorphic or non-square pixel output +RenderSettings.pixel_filter -> pixel_filter: enum Reconstruction filter used for combining anti-aliasing samples +RenderSettings.raytrace_structure -> raytrace_structure: enum Type of raytrace accelerator structure +RenderSettings.resolution_percentage -> resolution_percentage: int Percentage scale for render resolution +RenderSettings.resolution_x -> resolution_x: int Number of horizontal pixels in the rendered image +RenderSettings.resolution_y -> resolution_y: int Number of vertical pixels in the rendered image +RenderSettings.sequencer_gl_preview -> sequencer_gl_preview: enum Method to draw in the sequencer view +RenderSettings.sequencer_gl_render -> sequencer_gl_render: enum Method to draw in the sequencer view +RenderSettings.simplify_ao_sss -> simplify_ao_sss: float Global approximate AA and SSS quality factor +RenderSettings.simplify_child_particles -> simplify_child_particles: float Global child particles percentage +RenderSettings.simplify_shadow_samples -> simplify_shadow_samples: int Global maximum shadow samples +RenderSettings.simplify_subdivision -> simplify_subdivision: int Global maximum subdivision level +RenderSettings.stamp_background -> stamp_background: float Color to use behind stamp text +RenderSettings.stamp_font_size -> stamp_font_size: int Size of the font used when rendering stamp text +RenderSettings.stamp_foreground -> stamp_foreground: float Color to use for stamp text +RenderSettings.stamp_note_text -> stamp_note_text: string Custom text to appear in the stamp note +RenderSettings.threads -> threads: int Number of CPU threads to use simultaneously while rendering (for multi-core/CPU systems) +RenderSettings.threads_mode -> threads_mode: enum Determine the amount of render threads used +RigidBodyJointConstraint.axis_x -> axis_x: float Rotate pivot on X axis in degrees +RigidBodyJointConstraint.axis_y -> axis_y: float Rotate pivot on Y axis in degrees +RigidBodyJointConstraint.axis_z -> axis_z: float Rotate pivot on Z axis in degrees +RigidBodyJointConstraint.child -> child: pointer Child object +RigidBodyJointConstraint.pivot_type -> pivot_type: enum +RigidBodyJointConstraint.pivot_x -> pivot_x: float Offset pivot on X +RigidBodyJointConstraint.pivot_y -> pivot_y: float Offset pivot on Y +RigidBodyJointConstraint.pivot_z -> pivot_z: float Offset pivot on Z +RigidBodyJointConstraint.target -> target: pointer Target Object +SPHFluidSettings.buoyancy -> buoyancy: float +SPHFluidSettings.fluid_radius -> fluid_radius: float Fluid interaction Radius +SPHFluidSettings.rest_density -> rest_density: float Density +SPHFluidSettings.rest_length -> rest_length: float The Spring Rest Length (factor of interaction radius) +SPHFluidSettings.spring_k -> spring_k: float Spring force constant +SPHFluidSettings.stiffness_k -> stiffness_k: float Constant K - Stiffness +SPHFluidSettings.stiffness_knear -> stiffness_knear: float Repulsion factor: stiffness_knear +SPHFluidSettings.viscosity_beta -> viscosity_beta: float Square viscosity factor +SPHFluidSettings.viscosity_omega -> viscosity_omega: float Linear viscosity +Scene.active_keying_set -> active_keying_set: pointer Active Keying Set used to insert/delete keyframes +Scene.active_keying_set_index -> active_keying_set_index: int Current Keying Set index (negative for 'builtin' and positive for 'absolute') +Scene.all_keying_sets -> all_keying_sets: collection, (read-only) All Keying Sets available for use (builtins and Absolute Keying Sets for this Scene) +Scene.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Scene.bases -> bases: collection, (read-only) +Scene.camera -> camera: pointer Active camera used for rendering the scene +Scene.cursor_location -> cursor_location: float 3D cursor location +Scene.distance_model -> distance_model: enum Distance model for distance attenuation calculation +Scene.doppler_factor -> doppler_factor: float Pitch factor for Doppler effect calculation +Scene.frame_current -> frame_current: int +Scene.frame_end -> frame_end: int Final frame of the playback/rendering range +Scene.frame_start -> frame_start: int First frame of the playback/rendering range +Scene.frame_step -> frame_step: int Number of frames to skip forward while rendering/playing back each frame +Scene.game_data -> game_data: pointer, (read-only) +Scene.gravity -> gravity: float Constant acceleration in a given direction +Scene.grease_pencil -> grease_pencil: pointer Grease Pencil datablock +Scene.keying_sets -> keying_sets: collection, (read-only) Absolute Keying Sets for this Scene +Scene.network_render -> network_render: pointer, (read-only) Network Render Settings +Scene.nodetree -> nodetree: pointer, (read-only) Compositing node tree +Scene.objects -> objects: collection, (read-only) +Scene.orientations -> orientations: collection, (read-only) +Scene.pose_templates -> pose_templates: pointer, (read-only) Pose Template Settings +Scene.pov_radio_adc_bailout -> pov_radio_adc_bailout: float The adc_bailout for radiosity rays. Use adc_bailout = 0.01 / brightest_ambient_object for good results +Scene.pov_radio_brightness -> pov_radio_brightness: float Amount objects are brightened before being returned upwards to the rest of the system +Scene.pov_radio_count -> pov_radio_count: int Number of rays that are sent out whenever a new radiosity value has to be calculated +Scene.pov_radio_error_bound -> pov_radio_error_bound: float One of the two main speed/quality tuning values, lower values are more accurate +Scene.pov_radio_gray_threshold -> pov_radio_gray_threshold: float One of the two main speed/quality tuning values, lower values are more accurate +Scene.pov_radio_low_error_factor -> pov_radio_low_error_factor: float If you calculate just enough samples, but no more, you will get an image which has slightly blotchy lighting +Scene.pov_radio_minimum_reuse -> pov_radio_minimum_reuse: float Fraction of the screen width which sets the minimum radius of reuse for each sample point (At values higher than 2% expect errors) +Scene.pov_radio_nearest_count -> pov_radio_nearest_count: int Number of old ambient values blended together to create a new interpolated value +Scene.pov_radio_recursion_limit -> pov_radio_recursion_limit: int how many recursion levels are used to calculate the diffuse inter-reflection +Scene.preview_range_frame_end -> preview_range_frame_end: int Alternative end frame for UI playback +Scene.preview_range_frame_start -> preview_range_frame_start: int Alternative start frame for UI playback +Scene.render -> render: pointer, (read-only) +Scene.sequence_editor -> sequence_editor: pointer, (read-only) +Scene.set -> set: pointer Background set scene +Scene.speed_of_sound -> speed_of_sound: float Speed of sound for Doppler effect calculation +Scene.stamp_note -> stamp_note: string User define note for the render stamping +Scene.sync_mode -> sync_mode: enum How to sync playback +Scene.timeline_markers -> timeline_markers: collection, (read-only) Markers used in all timelines for the current scene +Scene.tool_settings -> tool_settings: pointer, (read-only) +Scene.unit_settings -> unit_settings: pointer, (read-only) Unit editing settings +Scene.world -> world: pointer World used for rendering the scene +SceneActuator.camera -> camera: pointer Set this Camera. Leave empty to refer to self object +SceneActuator.mode -> mode: enum +SceneActuator.scene -> scene: pointer Set the Scene to be added/removed/paused/resumed +SceneBases.active -> active: pointer Active object base in the scene +SceneGameData.activity_culling_box_radius -> activity_culling_box_radius: float Radius of the activity bubble, in Manhattan length. Objects outside the box are activity-culled +SceneGameData.depth -> depth: int Displays bit depth of full screen display +SceneGameData.dome_angle -> dome_angle: int Field of View of the Dome - it only works in mode Fisheye and Truncated +SceneGameData.dome_buffer_resolution -> dome_buffer_resolution: float Buffer Resolution - decrease it to increase speed +SceneGameData.dome_mode -> dome_mode: enum Dome physical configurations +SceneGameData.dome_tesselation -> dome_tesselation: int Tessellation level - check the generated mesh in wireframe mode +SceneGameData.dome_text -> dome_text: pointer Custom Warp Mesh data file +SceneGameData.dome_tilt -> dome_tilt: int Camera rotation in horizontal axis +SceneGameData.eye_separation -> eye_separation: float Set the distance between the eyes - the camera focal length/30 should be fine +SceneGameData.fps -> fps: int The nominal number of game frames per second. Physics fixed timestep = 1/fps, independently of actual frame rate +SceneGameData.framing_color -> framing_color: float Set colour of the bars +SceneGameData.framing_type -> framing_type: enum Select the type of Framing you want +SceneGameData.frequency -> frequency: int Displays clock frequency of fullscreen display +SceneGameData.logic_step_max -> logic_step_max: int Sets the maximum number of logic frame per game frame if graphics slows down the game, higher value allows better synchronization with physics +SceneGameData.material_mode -> material_mode: enum Material mode to use for rendering +SceneGameData.occlusion_culling_resolution -> occlusion_culling_resolution: float The size of the occlusion buffer in pixel, use higher value for better precision (slower) +SceneGameData.physics_engine -> physics_engine: enum Physics engine used for physics simulation in the game engine +SceneGameData.physics_gravity -> physics_gravity: float Gravitational constant used for physics simulation in the game engine +SceneGameData.physics_step_max -> physics_step_max: int Sets the maximum number of physics step per game frame if graphics slows down the game, higher value allows physics to keep up with realtime +SceneGameData.physics_step_sub -> physics_step_sub: int Sets the number of simulation substep per physic timestep, higher value give better physics precision +SceneGameData.resolution_x -> resolution_x: int Number of horizontal pixels in the screen +SceneGameData.resolution_y -> resolution_y: int Number of vertical pixels in the screen +SceneGameData.stereo -> stereo: enum +SceneGameData.stereo_mode -> stereo_mode: enum Stereographic techniques +SceneObjects.active -> active: pointer Active object for this scene +SceneRenderLayer.light_override -> light_override: pointer Group to override all other lights in this render layer +SceneRenderLayer.material_override -> material_override: pointer Material to override all other materials in this render layer +SceneRenderLayer.name -> name: string Render layer name +SceneSequence.animation_end_offset -> animation_end_offset: int Animation end offset (trim end) +SceneSequence.animation_start_offset -> animation_start_offset: int Animation start offset (trim start) +SceneSequence.color_balance -> color_balance: pointer, (read-only) +SceneSequence.crop -> crop: pointer, (read-only) +SceneSequence.multiply_colors -> multiply_colors: float +SceneSequence.proxy -> proxy: pointer, (read-only) +SceneSequence.scene -> scene: pointer Scene that this sequence uses +SceneSequence.scene_camera -> scene_camera: pointer Override the scenes active camera +SceneSequence.strobe -> strobe: float Only display every nth frame +SceneSequence.transform -> transform: pointer, (read-only) +Scopes.accuracy -> accuracy: float Proportion of original image source pixel lines to sample +Scopes.histogram -> histogram: pointer, (read-only) Histogram for viewing image statistics +Scopes.vectorscope_alpha -> vectorscope_alpha: float Opacity of the points +Scopes.waveform_alpha -> waveform_alpha: float Opacity of the points +Scopes.waveform_mode -> waveform_mode: enum +Screen.areas -> areas: collection, (read-only) Areas the screen is subdivided into +Screen.scene -> scene: pointer Active scene to be edited in the screen +ScrewModifier.angle -> angle: float Angle of revolution +ScrewModifier.axis -> axis: enum Screw axis +ScrewModifier.iterations -> iterations: int Number of times to apply the screw operation +ScrewModifier.object -> object: pointer Object to define the screw axis +ScrewModifier.render_steps -> render_steps: int Number of steps in the revolution +ScrewModifier.screw_offset -> screw_offset: float Offset the revolution along its axis +ScrewModifier.steps -> steps: int Number of steps in the revolution +Sensor.frequency -> frequency: int Delay between repeated pulses(in logic tics, 0=no delay) +Sensor.name -> name: string Sensor name +Sensor.type -> type: enum +Sequence.blend_mode -> blend_mode: enum +Sequence.blend_opacity -> blend_opacity: float +Sequence.channel -> channel: int Y position of the sequence strip +Sequence.effect_fader -> effect_fader: float +Sequence.frame_final_end -> frame_final_end: int End frame displayed in the sequence editor after offsets are applied +Sequence.frame_final_length -> frame_final_length: int The length of the contents of this strip before the handles are applied +Sequence.frame_final_start -> frame_final_start: int Start frame displayed in the sequence editor after offsets are applied, setting this is equivalent to moving the handle, not the actual start frame +Sequence.frame_length -> frame_length: int, (read-only) The length of the contents of this strip before the handles are applied +Sequence.frame_offset_end -> frame_offset_end: int, (read-only) +Sequence.frame_offset_start -> frame_offset_start: int, (read-only) +Sequence.frame_start -> frame_start: int +Sequence.frame_still_end -> frame_still_end: int, (read-only) +Sequence.frame_still_start -> frame_still_start: int, (read-only) +Sequence.name -> name: string +Sequence.speed_fader -> speed_fader: float +Sequence.type -> type: enum, (read-only) +SequenceColorBalance.gain -> gain: float Color balance gain (highlights) +SequenceColorBalance.gamma -> gamma: float Color balance gamma (midtones) +SequenceColorBalance.lift -> lift: float Color balance lift (shadows) +SequenceCrop.bottom -> bottom: int +SequenceCrop.left -> left: int +SequenceCrop.right -> right: int +SequenceCrop.top -> top: int +SequenceEditor.active_strip -> active_strip: pointer +SequenceEditor.meta_stack -> meta_stack: collection, (read-only) Meta strip stack, last is currently edited meta strip +SequenceEditor.overlay_frame -> overlay_frame: int Sequencers active strip +SequenceEditor.sequences -> sequences: collection, (read-only) +SequenceEditor.sequences_all -> sequences_all: collection, (read-only) +SequenceElement.filename -> filename: string +SequenceProxy.directory -> directory: string Location to store the proxy files +SequenceProxy.filepath -> filepath: string Location of custom proxy file +SequenceTransform.offset_x -> offset_x: int +SequenceTransform.offset_y -> offset_y: int +ShaderNode.type -> type: enum, (read-only) +ShaderNodeExtendedMaterial.material -> material: pointer +ShaderNodeGeometry.color_layer -> color_layer: string +ShaderNodeGeometry.uv_layer -> uv_layer: string +ShaderNodeMapping.location -> location: float Location offset for the input coordinate +ShaderNodeMapping.maximum -> maximum: float Maximum value to clamp coordinate to +ShaderNodeMapping.minimum -> minimum: float Minimum value to clamp coordinate to +ShaderNodeMapping.rotation -> rotation: float Rotation offset for the input coordinate +ShaderNodeMapping.scale -> scale: float Scale adjustment for the input coordinate +ShaderNodeMaterial.material -> material: pointer +ShaderNodeMath.operation -> operation: enum +ShaderNodeMixRGB.blend_type -> blend_type: enum +ShaderNodeRGBCurve.mapping -> mapping: pointer, (read-only) +ShaderNodeTexture.node_output -> node_output: int For node-based textures, which output node to use +ShaderNodeTexture.texture -> texture: pointer +ShaderNodeValToRGB.color_ramp -> color_ramp: pointer, (read-only) +ShaderNodeVectorCurve.mapping -> mapping: pointer, (read-only) +ShaderNodeVectorMath.operation -> operation: enum +ShapeActionActuator.action -> action: pointer +ShapeActionActuator.blendin -> blendin: int Number of frames of motion blending +ShapeActionActuator.frame_end -> frame_end: int +ShapeActionActuator.frame_property -> frame_property: string Assign the action's current frame number to this property +ShapeActionActuator.frame_start -> frame_start: int +ShapeActionActuator.mode -> mode: enum Action playback type +ShapeActionActuator.priority -> priority: int Execution priority - lower numbers will override actions with higher numbers. With 2 or more actions at once, the overriding channels must be lower in the stack +ShapeActionActuator.property -> property: string Use this property to define the Action position +ShapeKey.data -> data: collection, (read-only) +ShapeKey.frame -> frame: float, (read-only) Frame for absolute keys +ShapeKey.interpolation -> interpolation: enum Interpolation type +ShapeKey.name -> name: string +ShapeKey.relative_key -> relative_key: pointer Shape used as a relative key +ShapeKey.slider_max -> slider_max: float Maximum for slider +ShapeKey.slider_min -> slider_min: float Minimum for slider +ShapeKey.value -> value: float Value of shape key at the current frame +ShapeKey.vertex_group -> vertex_group: string Vertex weight group, to blend with basis shape +ShapeKeyBezierPoint.co -> co: float +ShapeKeyBezierPoint.handle_1_co -> handle_1_co: float +ShapeKeyBezierPoint.handle_2_co -> handle_2_co: float +ShapeKeyCurvePoint.co -> co: float +ShapeKeyCurvePoint.tilt -> tilt: float +ShapeKeyPoint.co -> co: float +ShrinkwrapConstraint.distance -> distance: float Distance to Target +ShrinkwrapConstraint.shrinkwrap_type -> shrinkwrap_type: enum Selects type of shrinkwrap algorithm for target position +ShrinkwrapConstraint.target -> target: pointer Target Object +ShrinkwrapModifier.auxiliary_target -> auxiliary_target: pointer Additional mesh target to shrink to +ShrinkwrapModifier.mode -> mode: enum +ShrinkwrapModifier.offset -> offset: float Distance to keep from the target +ShrinkwrapModifier.subsurf_levels -> subsurf_levels: int Number of subdivisions that must be performed before extracting vertices' positions and normals +ShrinkwrapModifier.target -> target: pointer Mesh target to shrink to +ShrinkwrapModifier.vertex_group -> vertex_group: string Vertex group name +SimpleDeformModifier.factor -> factor: float +SimpleDeformModifier.limits -> limits: float Lower/Upper limits for deform +SimpleDeformModifier.mode -> mode: enum +SimpleDeformModifier.origin -> origin: pointer Origin of modifier space coordinates +SimpleDeformModifier.vertex_group -> vertex_group: string Vertex group name +SmokeDomainSettings.alpha -> alpha: float Higher value results in sinking smoke +SmokeDomainSettings.amplify -> amplify: int Enhance the resolution of smoke by this factor using noise +SmokeDomainSettings.beta -> beta: float Higher value results in faster rising smoke +SmokeDomainSettings.coll_group -> coll_group: pointer Limit collisions to this group +SmokeDomainSettings.dissolve_speed -> dissolve_speed: int Dissolve Speed +SmokeDomainSettings.eff_group -> eff_group: pointer Limit effectors to this group +SmokeDomainSettings.effector_weights -> effector_weights: pointer, (read-only) +SmokeDomainSettings.fluid_group -> fluid_group: pointer Limit fluid objects to this group +SmokeDomainSettings.maxres -> maxres: int Maximal resolution used in the fluid domain +SmokeDomainSettings.noise_type -> noise_type: enum Noise method which is used for creating the high resolution +SmokeDomainSettings.point_cache_high -> point_cache_high: pointer, (read-only) +SmokeDomainSettings.point_cache_low -> point_cache_low: pointer, (read-only) +SmokeDomainSettings.smoke_cache_comp -> smoke_cache_comp: enum Compression method to be used +SmokeDomainSettings.smoke_cache_high_comp -> smoke_cache_high_comp: enum Compression method to be used +SmokeDomainSettings.strength -> strength: float Strength of wavelet noise +SmokeFlowSettings.density -> density: float +SmokeFlowSettings.psys -> psys: pointer Particle systems emitted from the object +SmokeFlowSettings.temperature -> temperature: float Temperature difference to ambient temperature +SmokeModifier.coll_settings -> coll_settings: pointer, (read-only) +SmokeModifier.domain_settings -> domain_settings: pointer, (read-only) +SmokeModifier.flow_settings -> flow_settings: pointer, (read-only) +SmokeModifier.smoke_type -> smoke_type: enum +SmoothModifier.factor -> factor: float +SmoothModifier.repeat -> repeat: int +SmoothModifier.vertex_group -> vertex_group: string Vertex group name +SoftBodyModifier.point_cache -> point_cache: pointer, (read-only) +SoftBodyModifier.settings -> settings: pointer, (read-only) +SoftBodySettings.aero -> aero: float Make edges 'sail' +SoftBodySettings.aerodynamics_type -> aerodynamics_type: enum Method of calculating aerodynamic interaction +SoftBodySettings.ball_damp -> ball_damp: float Blending to inelastic collision +SoftBodySettings.ball_size -> ball_size: float Absolute ball size or factor if not manual adjusted +SoftBodySettings.ball_stiff -> ball_stiff: float Ball inflating pressure +SoftBodySettings.bending -> bending: float Bending Stiffness +SoftBodySettings.choke -> choke: int 'Viscosity' inside collision target +SoftBodySettings.collision_type -> collision_type: enum Choose Collision Type +SoftBodySettings.damp -> damp: float Edge spring friction +SoftBodySettings.effector_weights -> effector_weights: pointer, (read-only) +SoftBodySettings.error_limit -> error_limit: float The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed +SoftBodySettings.friction -> friction: float General media friction for point movements +SoftBodySettings.fuzzy -> fuzzy: int Fuzziness while on collision, high values make collsion handling faster but less stable +SoftBodySettings.goal_default -> goal_default: float Default Goal (vertex target position) value, when no Vertex Group used +SoftBodySettings.goal_friction -> goal_friction: float Goal (vertex target position) friction +SoftBodySettings.goal_max -> goal_max: float Goal maximum, vertex weights are scaled to match this range +SoftBodySettings.goal_min -> goal_min: float Goal minimum, vertex weights are scaled to match this range +SoftBodySettings.goal_spring -> goal_spring: float Goal (vertex target position) spring stiffness +SoftBodySettings.goal_vertex_group -> goal_vertex_group: string Control point weight values +SoftBodySettings.gravity -> gravity: float Apply gravitation to point movement +SoftBodySettings.lcom -> lcom: float Location of Center of mass +SoftBodySettings.lrot -> lrot: float Estimated rotation matrix +SoftBodySettings.lscale -> lscale: float Estimated scale matrix +SoftBodySettings.mass -> mass: float General Mass value +SoftBodySettings.mass_vertex_group -> mass_vertex_group: string Control point mass values +SoftBodySettings.maxstep -> maxstep: int Maximal # solver steps/frame +SoftBodySettings.minstep -> minstep: int Minimal # solver steps/frame +SoftBodySettings.plastic -> plastic: float Permanent deform +SoftBodySettings.pull -> pull: float Edge spring stiffness when longer than rest length +SoftBodySettings.push -> push: float Edge spring stiffness when shorter than rest length +SoftBodySettings.shear -> shear: float Shear Stiffness +SoftBodySettings.speed -> speed: float Tweak timing for physics to control frequency and speed +SoftBodySettings.spring_length -> spring_length: float Alter spring length to shrink/blow up (unit %) 0 to disable +SoftBodySettings.spring_vertex_group -> spring_vertex_group: string Control point spring strength values +SolidifyModifier.edge_crease_inner -> edge_crease_inner: float Assign a crease to inner edges +SolidifyModifier.edge_crease_outer -> edge_crease_outer: float Assign a crease to outer edges +SolidifyModifier.edge_crease_rim -> edge_crease_rim: float Assign a crease to the edges making up the rim +SolidifyModifier.offset -> offset: float +SolidifyModifier.thickness -> thickness: float Thickness of the shell +SolidifyModifier.vertex_group -> vertex_group: string Vertex group name +Sound.filepath -> filepath: string Sound sample file used by this Sound datablock +Sound.packed_file -> packed_file: pointer, (read-only) +SoundActuator.cone_inner_angle_3d -> cone_inner_angle_3d: float The angle of the inner cone +SoundActuator.cone_outer_angle_3d -> cone_outer_angle_3d: float The angle of the outer cone +SoundActuator.cone_outer_gain_3d -> cone_outer_gain_3d: float The gain outside the outer cone. The gain in the outer cone will be interpolated between this value and the normal gain in the inner cone +SoundActuator.max_distance_3d -> max_distance_3d: float The maximum distance at which you can hear the sound +SoundActuator.maximum_gain_3d -> maximum_gain_3d: float The maximum gain of the sound, no matter how near it is +SoundActuator.minimum_gain_3d -> minimum_gain_3d: float The minimum gain of the sound, no matter how far it is away +SoundActuator.mode -> mode: enum +SoundActuator.pitch -> pitch: float Sets the pitch of the sound +SoundActuator.reference_distance_3d -> reference_distance_3d: float The distance where the sound has a gain of 1.0 +SoundActuator.rolloff_factor_3d -> rolloff_factor_3d: float The influence factor on volume depending on distance +SoundActuator.sound -> sound: pointer +SoundActuator.volume -> volume: float Sets the initial volume of the sound +SoundSequence.animation_end_offset -> animation_end_offset: int Animation end offset (trim end) +SoundSequence.animation_start_offset -> animation_start_offset: int Animation start offset (trim start) +SoundSequence.attenuation -> attenuation: float Attenuation in dezibel +SoundSequence.filepath -> filepath: string +SoundSequence.sound -> sound: pointer, (read-only) Sound datablock used by this sequence +SoundSequence.volume -> volume: float Playback volume of the sound +Space.type -> type: enum, (read-only) Space data type +SpaceConsole.console_type -> console_type: enum Console type +SpaceConsole.font_size -> font_size: int Font size to use for displaying the text +SpaceConsole.history -> history: collection, (read-only) Command history +SpaceConsole.language -> language: string Command line prompt language +SpaceConsole.prompt -> prompt: string Command line prompt +SpaceConsole.scrollback -> scrollback: collection, (read-only) Command output +SpaceConsole.selection_end -> selection_end: int +SpaceConsole.selection_start -> selection_start: int +SpaceDopeSheetEditor.action -> action: pointer Action displayed and edited in this space +SpaceDopeSheetEditor.autosnap -> autosnap: enum Automatic time snapping settings for transformations +SpaceDopeSheetEditor.dopesheet -> dopesheet: pointer, (read-only) Settings for filtering animation data +SpaceDopeSheetEditor.mode -> mode: enum Editing context being displayed +SpaceFileBrowser.params -> params: pointer, (read-only) Parameters and Settings for the Filebrowser +SpaceGraphEditor.autosnap -> autosnap: enum Automatic time snapping settings for transformations +SpaceGraphEditor.cursor_value -> cursor_value: float Graph Editor 2D-Value cursor - Y-Value component +SpaceGraphEditor.dopesheet -> dopesheet: pointer, (read-only) Settings for filtering animation data +SpaceGraphEditor.mode -> mode: enum Editing context being displayed +SpaceGraphEditor.pivot_point -> pivot_point: enum Pivot center for rotation/scaling +SpaceImageEditor.curves -> curves: pointer, (read-only) Color curve mapping to use for displaying the image +SpaceImageEditor.draw_channels -> draw_channels: enum Channels of the image to draw +SpaceImageEditor.grease_pencil -> grease_pencil: pointer Grease pencil data for this space +SpaceImageEditor.image -> image: pointer Image displayed and edited in this space +SpaceImageEditor.image_user -> image_user: pointer, (read-only) Parameters defining which layer, pass and frame of the image is displayed +SpaceImageEditor.sample_histogram -> sample_histogram: pointer, (read-only) Sampled colors along line +SpaceImageEditor.scopes -> scopes: pointer, (read-only) Scopes to visualize image statistics. +SpaceImageEditor.uv_editor -> uv_editor: pointer, (read-only) UV editor settings +SpaceNLA.autosnap -> autosnap: enum Automatic time snapping settings for transformations +SpaceNLA.dopesheet -> dopesheet: pointer, (read-only) Settings for filtering animation data +SpaceNodeEditor.id -> id: pointer, (read-only) Datablock whose nodes are being edited +SpaceNodeEditor.id_from -> id_from: pointer, (read-only) Datablock from which the edited datablock is linked +SpaceNodeEditor.nodetree -> nodetree: pointer, (read-only) Node tree being displayed and edited +SpaceNodeEditor.texture_type -> texture_type: enum Type of data to take texture from +SpaceNodeEditor.tree_type -> tree_type: enum Node tree type to display and edit +SpaceOutliner.display_filter -> display_filter: string Live search filtering string +SpaceOutliner.display_mode -> display_mode: enum Type of information to display +SpaceProperties.align -> align: enum Arrangement of the panels +SpaceProperties.context -> context: enum Type of active data to display and edit +SpaceProperties.pin_id -> pin_id: pointer +SpaceSequenceEditor.display_channel -> display_channel: int The channel number shown in the image preview. 0 is the result of all strips combined +SpaceSequenceEditor.display_mode -> display_mode: enum The view mode to use for displaying sequencer output +SpaceSequenceEditor.draw_overexposed -> draw_overexposed: int Show overexposed areas with zebra stripes +SpaceSequenceEditor.grease_pencil -> grease_pencil: pointer, (read-only) Grease pencil data for this space +SpaceSequenceEditor.offset_x -> offset_x: float Offsets image horizontally from the view center +SpaceSequenceEditor.offset_y -> offset_y: float Offsets image horizontally from the view center +SpaceSequenceEditor.proxy_render_size -> proxy_render_size: enum Draw preview using full resolution or different proxy resolutions +SpaceSequenceEditor.view_type -> view_type: enum The type of the Sequencer view (sequencer, preview or both) +SpaceSequenceEditor.zoom -> zoom: float Display zoom level +SpaceTextEditor.find_text -> find_text: string Text to search for with the find tool +SpaceTextEditor.font_size -> font_size: int Font size to use for displaying the text +SpaceTextEditor.replace_text -> replace_text: string Text to replace selected text with using the replace tool +SpaceTextEditor.tab_width -> tab_width: int Number of spaces to display tabs with +SpaceTextEditor.text -> text: pointer Text displayed and edited in this space +SpaceUVEditor.cursor_location -> cursor_location: float 2D cursor location for this view +SpaceUVEditor.draw_stretch_type -> draw_stretch_type: enum Type of stretch to draw +SpaceUVEditor.edge_draw_type -> edge_draw_type: enum Draw type for drawing UV edges +SpaceUVEditor.pivot -> pivot: enum Rotation/Scaling Pivot +SpaceUVEditor.sticky_selection_mode -> sticky_selection_mode: enum Automatically select also UVs sharing the same vertex as the ones being selected +SpaceUserPreferences.filter -> filter: string Search term for filtering in the UI +SpaceView3D.background_images -> background_images: collection, (read-only) List of background images +SpaceView3D.camera -> camera: pointer Active camera used in this view (when unlocked from the scene's active camera) +SpaceView3D.clip_end -> clip_end: float 3D View far clipping distance +SpaceView3D.clip_start -> clip_start: float 3D View near clipping distance +SpaceView3D.current_orientation -> current_orientation: pointer, (read-only) Current Transformation orientation +SpaceView3D.cursor_location -> cursor_location: float 3D cursor location for this view (dependent on local view setting) +SpaceView3D.grid_lines -> grid_lines: int The number of grid lines to display in perspective view +SpaceView3D.grid_spacing -> grid_spacing: float The distance between 3D View grid lines +SpaceView3D.grid_subdivisions -> grid_subdivisions: int The number of subdivisions between grid lines +SpaceView3D.lens -> lens: float Lens angle (mm) in perspective view +SpaceView3D.local_view -> local_view: pointer, (read-only) Display an isolated sub-set of objects, apart from the scene visibility +SpaceView3D.lock_bone -> lock_bone: string 3D View center is locked to this bone's position +SpaceView3D.lock_object -> lock_object: pointer 3D View center is locked to this object's position +SpaceView3D.pivot_point -> pivot_point: enum Pivot center for rotation/scaling +SpaceView3D.region_3d -> region_3d: pointer, (read-only) 3D region in this space, in case of quad view the camera region +SpaceView3D.region_quadview -> region_quadview: pointer, (read-only) 3D region that defines the quad view settings +SpaceView3D.transform_orientation -> transform_orientation: enum Transformation orientation +SpaceView3D.viewport_shading -> viewport_shading: enum Method to display/shade objects in the 3D View +SpeedControlSequence.global_speed -> global_speed: float +Spline.bezier_points -> bezier_points: collection, (read-only) Collection of points for bezier curves only +Spline.character_index -> character_index: int, (read-only) Location of this character in the text data (only for text curves) +Spline.material_index -> material_index: int +Spline.order_u -> order_u: int Nurbs order in the U direction (For splines and surfaces), Higher values let points influence a greater area +Spline.order_v -> order_v: int Nurbs order in the V direction (For surfaces only), Higher values let points influence a greater area +Spline.point_count_u -> point_count_u: int, (read-only) Total number points for the curve or surface in the U direction +Spline.point_count_v -> point_count_v: int, (read-only) Total number points for the surface on the V direction +Spline.points -> points: collection, (read-only) Collection of points that make up this poly or nurbs spline +Spline.radius_interpolation -> radius_interpolation: enum The type of radius interpolation for Bezier curves +Spline.resolution_u -> resolution_u: int Curve or Surface subdivisions per segment +Spline.resolution_v -> resolution_v: int Surface subdivisions per segment +Spline.tilt_interpolation -> tilt_interpolation: enum The type of tilt interpolation for 3D, Bezier curves +Spline.type -> type: enum The interpolation type for this curve element +SplineIKConstraint.chain_length -> chain_length: int How many bones are included in the chain +SplineIKConstraint.joint_bindings -> joint_bindings: float (EXPERIENCED USERS ONLY) The relative positions of the joints along the chain as percentages +SplineIKConstraint.target -> target: pointer Curve that controls this relationship +SplineIKConstraint.xz_scaling_mode -> xz_scaling_mode: enum Method used for determining the scaling of the X and Z axes of the bones +SplinePoint.co -> co: float Point coordinates +SplinePoint.radius -> radius: float, (read-only) Radius for bevelling +SplinePoint.tilt -> tilt: float Tilt in 3D View +SplinePoint.weight -> weight: float Nurbs weight +SplinePoint.weight_softbody -> weight_softbody: float Softbody goal weight +SpotLamp.compression_threshold -> compression_threshold: float Deep shadow map compression threshold +SpotLamp.falloff_curve -> falloff_curve: pointer, (read-only) Custom Lamp Falloff Curve +SpotLamp.falloff_type -> falloff_type: enum Intensity Decay with distance +SpotLamp.halo_intensity -> halo_intensity: float Brightness of the spotlight's halo cone (Buffer Shadows) +SpotLamp.halo_step -> halo_step: int Volumetric halo sampling frequency +SpotLamp.linear_attenuation -> linear_attenuation: float Linear distance attenuation +SpotLamp.quadratic_attenuation -> quadratic_attenuation: float Quadratic distance attenuation +SpotLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold: float Threshold for Adaptive Sampling (Raytraced shadows) +SpotLamp.shadow_buffer_bias -> shadow_buffer_bias: float Shadow buffer sampling bias +SpotLamp.shadow_buffer_clip_end -> shadow_buffer_clip_end: float Shadow map clip end beyond which objects will not generate shadows +SpotLamp.shadow_buffer_clip_start -> shadow_buffer_clip_start: float Shadow map clip start: objects closer will not generate shadows +SpotLamp.shadow_buffer_samples -> shadow_buffer_samples: int Number of shadow buffer samples +SpotLamp.shadow_buffer_size -> shadow_buffer_size: int Resolution of the shadow buffer, higher values give crisper shadows but use more memory +SpotLamp.shadow_buffer_soft -> shadow_buffer_soft: float Size of shadow buffer sampling area +SpotLamp.shadow_buffer_type -> shadow_buffer_type: enum Type of shadow buffer +SpotLamp.shadow_color -> shadow_color: float Color of shadows cast by the lamp +SpotLamp.shadow_filter_type -> shadow_filter_type: enum Type of shadow filter (Buffer Shadows) +SpotLamp.shadow_method -> shadow_method: enum Method to compute lamp shadow with +SpotLamp.shadow_ray_samples -> shadow_ray_samples: int Amount of samples taken extra (samples x samples) +SpotLamp.shadow_ray_sampling_method -> shadow_ray_sampling_method: enum Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower +SpotLamp.shadow_sample_buffers -> shadow_sample_buffers: enum Number of shadow buffers to render for better AA, this increases memory usage +SpotLamp.shadow_soft_size -> shadow_soft_size: float Light size for ray shadow sampling (Raytraced shadows) +SpotLamp.spot_blend -> spot_blend: float The softness of the spotlight edge +SpotLamp.spot_size -> spot_size: float Angle of the spotlight beam in degrees +StateActuator.operation -> operation: enum Select the bit operation on object state mask +StretchToConstraint.bulge -> bulge: float Factor between volume variation and stretching +StretchToConstraint.head_tail -> head_tail: float Target along length of bone: Head=0, Tail=1 +StretchToConstraint.keep_axis -> keep_axis: enum Axis to maintain during stretch +StretchToConstraint.original_length -> original_length: float Length at rest position +StretchToConstraint.subtarget -> subtarget: string +StretchToConstraint.target -> target: pointer Target Object +StretchToConstraint.volume -> volume: enum Maintain the object's volume as it stretches +StringProperty.default -> default: string, (read-only) string default value +StringProperty.max_length -> max_length: int, (read-only) Maximum length of the string, 0 means unlimited +Struct.base -> base: pointer, (read-only) Struct definition this is derived from +Struct.description -> description: string, (read-only) Description of the Struct's purpose +Struct.functions -> functions: collection, (read-only) +Struct.identifier -> identifier: string, (read-only) Unique name used in the code and scripting +Struct.name -> name: string, (read-only) Human readable name +Struct.name_property -> name_property: pointer, (read-only) Property that gives the name of the struct +Struct.nested -> nested: pointer, (read-only) Struct in which this struct is always nested, and to which it logically belongs +Struct.properties -> properties: collection, (read-only) Properties in the struct +StucciTexture.noise_basis -> noise_basis: enum Sets the noise basis used for turbulence +StucciTexture.noise_size -> noise_size: float Sets scaling for noise input +StucciTexture.noise_type -> noise_type: enum +StucciTexture.stype -> stype: enum +StucciTexture.turbulence -> turbulence: float Sets the turbulence of the bandnoise and ringnoise types +SubsurfModifier.levels -> levels: int Number of subdivisions to perform +SubsurfModifier.render_levels -> render_levels: int Number of subdivisions to perform when rendering +SubsurfModifier.subdivision_type -> subdivision_type: enum Selects type of subdivision algorithm +SunLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold: float Threshold for Adaptive Sampling (Raytraced shadows) +SunLamp.shadow_color -> shadow_color: float Color of shadows cast by the lamp +SunLamp.shadow_method -> shadow_method: enum Method to compute lamp shadow with +SunLamp.shadow_ray_samples -> shadow_ray_samples: int Amount of samples taken extra (samples x samples) +SunLamp.shadow_ray_sampling_method -> shadow_ray_sampling_method: enum Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower +SunLamp.shadow_soft_size -> shadow_soft_size: float Light size for ray shadow sampling (Raytraced shadows) +SunLamp.sky -> sky: pointer, (read-only) Sky related settings for sun lamps +TexMapping.location -> location: float +TexMapping.maximum -> maximum: float Maximum value for clipping +TexMapping.minimum -> minimum: float Minimum value for clipping +TexMapping.rotation -> rotation: float +TexMapping.scale -> scale: float +Text.current_character -> current_character: int, (read-only) Index of current character in current line, and also start index of character in selection if one exists +Text.current_line -> current_line: pointer, (read-only) Current line, and start line of selection if one exists +Text.filepath -> filepath: string Filename of the text file +Text.lines -> lines: collection, (read-only) Lines of text +Text.markers -> markers: collection, (read-only) Text markers highlighting part of the text +Text.selection_end_character -> selection_end_character: int, (read-only) Index of character after end of selection in the selection end line +Text.selection_end_line -> selection_end_line: pointer, (read-only) End line of selection +TextBox.height -> height: float +TextBox.width -> width: float +TextBox.x -> x: float +TextBox.y -> y: float +TextCurve.active_textbox -> active_textbox: int +TextCurve.body -> body: string contents of this text object +TextCurve.edit_format -> edit_format: pointer, (read-only) Editing settings character formatting +TextCurve.family -> family: string Use Blender Objects as font characters. Give font objects a common name followed by the character it represents, eg. familya, familyb etc, and turn on Verts Duplication +TextCurve.font -> font: pointer +TextCurve.line_dist -> line_dist: float +TextCurve.offset_x -> offset_x: float Horizontal offset from the object origin +TextCurve.offset_y -> offset_y: float Vertical offset from the object origin +TextCurve.shear -> shear: float Italic angle of the characters +TextCurve.spacemode -> spacemode: enum Text align from the object center +TextCurve.spacing -> spacing: float +TextCurve.text_on_curve -> text_on_curve: pointer Curve deforming text object +TextCurve.text_size -> text_size: float +TextCurve.textboxes -> textboxes: collection, (read-only) +TextCurve.ul_height -> ul_height: float +TextCurve.ul_position -> ul_position: float Vertical position of underline +TextCurve.word_spacing -> word_spacing: float +TextLine.line -> line: string Text in the line +TextMarker.color -> color: float Color to display the marker with +TextMarker.end -> end: int, (read-only) Start position of the marker in the line +TextMarker.group -> group: int, (read-only) +TextMarker.line -> line: int, (read-only) Line in which the marker is located +TextMarker.start -> start: int, (read-only) Start position of the marker in the line +Texture.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +Texture.brightness -> brightness: float +Texture.color_ramp -> color_ramp: pointer, (read-only) +Texture.contrast -> contrast: float +Texture.factor_blue -> factor_blue: float +Texture.factor_green -> factor_green: float +Texture.factor_red -> factor_red: float +Texture.node_tree -> node_tree: pointer, (read-only) Node tree for node-based textures +Texture.saturation -> saturation: float +Texture.type -> type: enum +TextureNode.type -> type: enum, (read-only) +TextureNodeBricks.offset -> offset: float +TextureNodeBricks.offset_frequency -> offset_frequency: int Offset every N rows +TextureNodeBricks.squash -> squash: float +TextureNodeBricks.squash_frequency -> squash_frequency: int Squash every N rows +TextureNodeCurveRGB.mapping -> mapping: pointer, (read-only) +TextureNodeCurveTime.curve -> curve: pointer, (read-only) +TextureNodeCurveTime.end -> end: int +TextureNodeCurveTime.start -> start: int +TextureNodeImage.image -> image: pointer +TextureNodeMath.operation -> operation: enum +TextureNodeMixRGB.blend_type -> blend_type: enum +TextureNodeOutput.output_name -> output_name: string +TextureNodeTexture.node_output -> node_output: int For node-based textures, which output node to use +TextureNodeTexture.texture -> texture: pointer +TextureNodeValToRGB.color_ramp -> color_ramp: pointer, (read-only) +TextureSlot.blend_type -> blend_type: enum +TextureSlot.color -> color: float The default color for textures that don't return RGB +TextureSlot.default_value -> default_value: float Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard +TextureSlot.name -> name: string, (read-only) Texture slot name +TextureSlot.offset -> offset: float Fine tunes texture mapping X, Y and Z locations +TextureSlot.output_node -> output_node: enum Which output node to use, for node-based textures +TextureSlot.size -> size: float Sets scaling for the texture's X, Y and Z sizes +TextureSlot.texture -> texture: pointer Texture datablock used by this texture slot +Theme.bone_color_sets -> bone_color_sets: collection, (read-only) +Theme.console -> console: pointer, (read-only) +Theme.dopesheet_editor -> dopesheet_editor: pointer, (read-only) +Theme.file_browser -> file_browser: pointer, (read-only) +Theme.graph_editor -> graph_editor: pointer, (read-only) +Theme.image_editor -> image_editor: pointer, (read-only) +Theme.info -> info: pointer, (read-only) +Theme.logic_editor -> logic_editor: pointer, (read-only) +Theme.name -> name: string Name of the theme +Theme.nla_editor -> nla_editor: pointer, (read-only) +Theme.node_editor -> node_editor: pointer, (read-only) +Theme.outliner -> outliner: pointer, (read-only) +Theme.properties -> properties: pointer, (read-only) +Theme.sequence_editor -> sequence_editor: pointer, (read-only) +Theme.text_editor -> text_editor: pointer, (read-only) +Theme.theme_area -> theme_area: enum +Theme.timeline -> timeline: pointer, (read-only) +Theme.user_interface -> user_interface: pointer, (read-only) +Theme.user_preferences -> user_preferences: pointer, (read-only) +Theme.view_3d -> view_3d: pointer, (read-only) +ThemeAudioWindow.back -> back: float +ThemeAudioWindow.button -> button: float +ThemeAudioWindow.button_text -> button_text: float +ThemeAudioWindow.button_text_hi -> button_text_hi: float +ThemeAudioWindow.button_title -> button_title: float +ThemeAudioWindow.frame_current -> frame_current: float +ThemeAudioWindow.grid -> grid: float +ThemeAudioWindow.header -> header: float +ThemeAudioWindow.header_text -> header_text: float +ThemeAudioWindow.header_text_hi -> header_text_hi: float +ThemeAudioWindow.text -> text: float +ThemeAudioWindow.text_hi -> text_hi: float +ThemeAudioWindow.title -> title: float +ThemeAudioWindow.window_sliders -> window_sliders: float +ThemeBoneColorSet.active -> active: float Color used for active bones +ThemeBoneColorSet.normal -> normal: float Color used for the surface of bones +ThemeBoneColorSet.selected -> selected: float Color used for selected bones +ThemeConsole.back -> back: float +ThemeConsole.button -> button: float +ThemeConsole.button_text -> button_text: float +ThemeConsole.button_text_hi -> button_text_hi: float +ThemeConsole.button_title -> button_title: float +ThemeConsole.cursor -> cursor: float +ThemeConsole.header -> header: float +ThemeConsole.header_text -> header_text: float +ThemeConsole.header_text_hi -> header_text_hi: float +ThemeConsole.line_error -> line_error: float +ThemeConsole.line_info -> line_info: float +ThemeConsole.line_input -> line_input: float +ThemeConsole.line_output -> line_output: float +ThemeConsole.text -> text: float +ThemeConsole.text_hi -> text_hi: float +ThemeConsole.title -> title: float +ThemeDopeSheet.active_channels_group -> active_channels_group: float +ThemeDopeSheet.back -> back: float +ThemeDopeSheet.button -> button: float +ThemeDopeSheet.button_text -> button_text: float +ThemeDopeSheet.button_text_hi -> button_text_hi: float +ThemeDopeSheet.button_title -> button_title: float +ThemeDopeSheet.channel_group -> channel_group: float +ThemeDopeSheet.channels -> channels: float +ThemeDopeSheet.channels_selected -> channels_selected: float +ThemeDopeSheet.dopesheet_channel -> dopesheet_channel: float +ThemeDopeSheet.dopesheet_subchannel -> dopesheet_subchannel: float +ThemeDopeSheet.frame_current -> frame_current: float +ThemeDopeSheet.grid -> grid: float +ThemeDopeSheet.header -> header: float +ThemeDopeSheet.header_text -> header_text: float +ThemeDopeSheet.header_text_hi -> header_text_hi: float +ThemeDopeSheet.list -> list: float +ThemeDopeSheet.list_text -> list_text: float +ThemeDopeSheet.list_text_hi -> list_text_hi: float +ThemeDopeSheet.list_title -> list_title: float +ThemeDopeSheet.long_key -> long_key: float +ThemeDopeSheet.long_key_selected -> long_key_selected: float +ThemeDopeSheet.text -> text: float +ThemeDopeSheet.text_hi -> text_hi: float +ThemeDopeSheet.title -> title: float +ThemeDopeSheet.value_sliders -> value_sliders: float +ThemeDopeSheet.view_sliders -> view_sliders: float +ThemeFileBrowser.active_file -> active_file: float +ThemeFileBrowser.active_file_text -> active_file_text: float +ThemeFileBrowser.back -> back: float +ThemeFileBrowser.button -> button: float +ThemeFileBrowser.button_text -> button_text: float +ThemeFileBrowser.button_text_hi -> button_text_hi: float +ThemeFileBrowser.button_title -> button_title: float +ThemeFileBrowser.header -> header: float +ThemeFileBrowser.header_text -> header_text: float +ThemeFileBrowser.header_text_hi -> header_text_hi: float +ThemeFileBrowser.list -> list: float +ThemeFileBrowser.list_text -> list_text: float +ThemeFileBrowser.list_text_hi -> list_text_hi: float +ThemeFileBrowser.list_title -> list_title: float +ThemeFileBrowser.scroll_handle -> scroll_handle: float +ThemeFileBrowser.scrollbar -> scrollbar: float +ThemeFileBrowser.selected_file -> selected_file: float +ThemeFileBrowser.text -> text: float +ThemeFileBrowser.text_hi -> text_hi: float +ThemeFileBrowser.tiles -> tiles: float +ThemeFileBrowser.title -> title: float +ThemeFontStyle.font_kerning_style -> font_kerning_style: enum Which style to use for font kerning +ThemeFontStyle.points -> points: int +ThemeFontStyle.shadow -> shadow: int Shadow size in pixels (0, 3 and 5 supported) +ThemeFontStyle.shadowalpha -> shadowalpha: float +ThemeFontStyle.shadowcolor -> shadowcolor: float Shadow color in grey value +ThemeFontStyle.shadx -> shadx: int Shadow offset in pixels +ThemeFontStyle.shady -> shady: int Shadow offset in pixels +ThemeGraphEditor.active_channels_group -> active_channels_group: float +ThemeGraphEditor.back -> back: float +ThemeGraphEditor.button -> button: float +ThemeGraphEditor.button_text -> button_text: float +ThemeGraphEditor.button_text_hi -> button_text_hi: float +ThemeGraphEditor.button_title -> button_title: float +ThemeGraphEditor.channel_group -> channel_group: float +ThemeGraphEditor.channels_region -> channels_region: float +ThemeGraphEditor.dopesheet_channel -> dopesheet_channel: float +ThemeGraphEditor.dopesheet_subchannel -> dopesheet_subchannel: float +ThemeGraphEditor.frame_current -> frame_current: float +ThemeGraphEditor.grid -> grid: float +ThemeGraphEditor.handle_align -> handle_align: float +ThemeGraphEditor.handle_auto -> handle_auto: float +ThemeGraphEditor.handle_free -> handle_free: float +ThemeGraphEditor.handle_sel_align -> handle_sel_align: float +ThemeGraphEditor.handle_sel_auto -> handle_sel_auto: float +ThemeGraphEditor.handle_sel_free -> handle_sel_free: float +ThemeGraphEditor.handle_sel_vect -> handle_sel_vect: float +ThemeGraphEditor.handle_vect -> handle_vect: float +ThemeGraphEditor.handle_vertex -> handle_vertex: float +ThemeGraphEditor.handle_vertex_select -> handle_vertex_select: float +ThemeGraphEditor.handle_vertex_size -> handle_vertex_size: int +ThemeGraphEditor.header -> header: float +ThemeGraphEditor.header_text -> header_text: float +ThemeGraphEditor.header_text_hi -> header_text_hi: float +ThemeGraphEditor.lastsel_point -> lastsel_point: float +ThemeGraphEditor.list -> list: float +ThemeGraphEditor.list_text -> list_text: float +ThemeGraphEditor.list_text_hi -> list_text_hi: float +ThemeGraphEditor.list_title -> list_title: float +ThemeGraphEditor.panel -> panel: float +ThemeGraphEditor.text -> text: float +ThemeGraphEditor.text_hi -> text_hi: float +ThemeGraphEditor.title -> title: float +ThemeGraphEditor.vertex -> vertex: float +ThemeGraphEditor.vertex_select -> vertex_select: float +ThemeGraphEditor.vertex_size -> vertex_size: int +ThemeGraphEditor.window_sliders -> window_sliders: float +ThemeImageEditor.back -> back: float +ThemeImageEditor.button -> button: float +ThemeImageEditor.button_text -> button_text: float +ThemeImageEditor.button_text_hi -> button_text_hi: float +ThemeImageEditor.button_title -> button_title: float +ThemeImageEditor.editmesh_active -> editmesh_active: float +ThemeImageEditor.face -> face: float +ThemeImageEditor.face_dot -> face_dot: float +ThemeImageEditor.face_select -> face_select: float +ThemeImageEditor.facedot_size -> facedot_size: int +ThemeImageEditor.header -> header: float +ThemeImageEditor.header_text -> header_text: float +ThemeImageEditor.header_text_hi -> header_text_hi: float +ThemeImageEditor.scope_back -> scope_back: float +ThemeImageEditor.text -> text: float +ThemeImageEditor.text_hi -> text_hi: float +ThemeImageEditor.title -> title: float +ThemeImageEditor.vertex -> vertex: float +ThemeImageEditor.vertex_select -> vertex_select: float +ThemeImageEditor.vertex_size -> vertex_size: int +ThemeInfo.back -> back: float +ThemeInfo.button -> button: float +ThemeInfo.button_text -> button_text: float +ThemeInfo.button_text_hi -> button_text_hi: float +ThemeInfo.button_title -> button_title: float +ThemeInfo.header -> header: float +ThemeInfo.header_text -> header_text: float +ThemeInfo.header_text_hi -> header_text_hi: float +ThemeInfo.text -> text: float +ThemeInfo.text_hi -> text_hi: float +ThemeInfo.title -> title: float +ThemeLogicEditor.back -> back: float +ThemeLogicEditor.button -> button: float +ThemeLogicEditor.button_text -> button_text: float +ThemeLogicEditor.button_text_hi -> button_text_hi: float +ThemeLogicEditor.button_title -> button_title: float +ThemeLogicEditor.header -> header: float +ThemeLogicEditor.header_text -> header_text: float +ThemeLogicEditor.header_text_hi -> header_text_hi: float +ThemeLogicEditor.panel -> panel: float +ThemeLogicEditor.text -> text: float +ThemeLogicEditor.text_hi -> text_hi: float +ThemeLogicEditor.title -> title: float +ThemeNLAEditor.back -> back: float +ThemeNLAEditor.bars -> bars: float +ThemeNLAEditor.bars_selected -> bars_selected: float +ThemeNLAEditor.button -> button: float +ThemeNLAEditor.button_text -> button_text: float +ThemeNLAEditor.button_text_hi -> button_text_hi: float +ThemeNLAEditor.button_title -> button_title: float +ThemeNLAEditor.frame_current -> frame_current: float +ThemeNLAEditor.grid -> grid: float +ThemeNLAEditor.header -> header: float +ThemeNLAEditor.header_text -> header_text: float +ThemeNLAEditor.header_text_hi -> header_text_hi: float +ThemeNLAEditor.list -> list: float +ThemeNLAEditor.list_text -> list_text: float +ThemeNLAEditor.list_text_hi -> list_text_hi: float +ThemeNLAEditor.list_title -> list_title: float +ThemeNLAEditor.strips -> strips: float +ThemeNLAEditor.strips_selected -> strips_selected: float +ThemeNLAEditor.text -> text: float +ThemeNLAEditor.text_hi -> text_hi: float +ThemeNLAEditor.title -> title: float +ThemeNLAEditor.view_sliders -> view_sliders: float +ThemeNodeEditor.back -> back: float +ThemeNodeEditor.button -> button: float +ThemeNodeEditor.button_text -> button_text: float +ThemeNodeEditor.button_text_hi -> button_text_hi: float +ThemeNodeEditor.button_title -> button_title: float +ThemeNodeEditor.converter_node -> converter_node: float +ThemeNodeEditor.group_node -> group_node: float +ThemeNodeEditor.header -> header: float +ThemeNodeEditor.header_text -> header_text: float +ThemeNodeEditor.header_text_hi -> header_text_hi: float +ThemeNodeEditor.in_out_node -> in_out_node: float +ThemeNodeEditor.list -> list: float +ThemeNodeEditor.list_text -> list_text: float +ThemeNodeEditor.list_text_hi -> list_text_hi: float +ThemeNodeEditor.list_title -> list_title: float +ThemeNodeEditor.node_backdrop -> node_backdrop: float +ThemeNodeEditor.operator_node -> operator_node: float +ThemeNodeEditor.selected_text -> selected_text: float +ThemeNodeEditor.text -> text: float +ThemeNodeEditor.text_hi -> text_hi: float +ThemeNodeEditor.title -> title: float +ThemeNodeEditor.wire_select -> wire_select: float +ThemeNodeEditor.wires -> wires: float +ThemeOutliner.back -> back: float +ThemeOutliner.button -> button: float +ThemeOutliner.button_text -> button_text: float +ThemeOutliner.button_text_hi -> button_text_hi: float +ThemeOutliner.button_title -> button_title: float +ThemeOutliner.header -> header: float +ThemeOutliner.header_text -> header_text: float +ThemeOutliner.header_text_hi -> header_text_hi: float +ThemeOutliner.text -> text: float +ThemeOutliner.text_hi -> text_hi: float +ThemeOutliner.title -> title: float +ThemeProperties.back -> back: float +ThemeProperties.button -> button: float +ThemeProperties.button_text -> button_text: float +ThemeProperties.button_text_hi -> button_text_hi: float +ThemeProperties.button_title -> button_title: float +ThemeProperties.header -> header: float +ThemeProperties.header_text -> header_text: float +ThemeProperties.header_text_hi -> header_text_hi: float +ThemeProperties.panel -> panel: float +ThemeProperties.text -> text: float +ThemeProperties.text_hi -> text_hi: float +ThemeProperties.title -> title: float +ThemeSequenceEditor.audio_strip -> audio_strip: float +ThemeSequenceEditor.back -> back: float +ThemeSequenceEditor.button -> button: float +ThemeSequenceEditor.button_text -> button_text: float +ThemeSequenceEditor.button_text_hi -> button_text_hi: float +ThemeSequenceEditor.button_title -> button_title: float +ThemeSequenceEditor.draw_action -> draw_action: float +ThemeSequenceEditor.effect_strip -> effect_strip: float +ThemeSequenceEditor.frame_current -> frame_current: float +ThemeSequenceEditor.grid -> grid: float +ThemeSequenceEditor.header -> header: float +ThemeSequenceEditor.header_text -> header_text: float +ThemeSequenceEditor.header_text_hi -> header_text_hi: float +ThemeSequenceEditor.image_strip -> image_strip: float +ThemeSequenceEditor.keyframe -> keyframe: float +ThemeSequenceEditor.meta_strip -> meta_strip: float +ThemeSequenceEditor.movie_strip -> movie_strip: float +ThemeSequenceEditor.plugin_strip -> plugin_strip: float +ThemeSequenceEditor.scene_strip -> scene_strip: float +ThemeSequenceEditor.text -> text: float +ThemeSequenceEditor.text_hi -> text_hi: float +ThemeSequenceEditor.title -> title: float +ThemeSequenceEditor.transition_strip -> transition_strip: float +ThemeSequenceEditor.window_sliders -> window_sliders: float +ThemeStyle.grouplabel -> grouplabel: pointer, (read-only) +ThemeStyle.paneltitle -> paneltitle: pointer, (read-only) +ThemeStyle.panelzoom -> panelzoom: float Default zoom level for panel areas +ThemeStyle.widget -> widget: pointer, (read-only) +ThemeStyle.widgetlabel -> widgetlabel: pointer, (read-only) +ThemeTextEditor.back -> back: float +ThemeTextEditor.button -> button: float +ThemeTextEditor.button_text -> button_text: float +ThemeTextEditor.button_text_hi -> button_text_hi: float +ThemeTextEditor.button_title -> button_title: float +ThemeTextEditor.cursor -> cursor: float +ThemeTextEditor.header -> header: float +ThemeTextEditor.header_text -> header_text: float +ThemeTextEditor.header_text_hi -> header_text_hi: float +ThemeTextEditor.line_numbers_background -> line_numbers_background: float +ThemeTextEditor.scroll_bar -> scroll_bar: float +ThemeTextEditor.selected_text -> selected_text: float +ThemeTextEditor.syntax_builtin -> syntax_builtin: float +ThemeTextEditor.syntax_comment -> syntax_comment: float +ThemeTextEditor.syntax_numbers -> syntax_numbers: float +ThemeTextEditor.syntax_special -> syntax_special: float +ThemeTextEditor.syntax_string -> syntax_string: float +ThemeTextEditor.text -> text: float +ThemeTextEditor.text_hi -> text_hi: float +ThemeTextEditor.title -> title: float +ThemeTimeline.back -> back: float +ThemeTimeline.button -> button: float +ThemeTimeline.button_text -> button_text: float +ThemeTimeline.button_text_hi -> button_text_hi: float +ThemeTimeline.button_title -> button_title: float +ThemeTimeline.frame_current -> frame_current: float +ThemeTimeline.grid -> grid: float +ThemeTimeline.header -> header: float +ThemeTimeline.header_text -> header_text: float +ThemeTimeline.header_text_hi -> header_text_hi: float +ThemeTimeline.text -> text: float +ThemeTimeline.text_hi -> text_hi: float +ThemeTimeline.title -> title: float +ThemeUserInterface.icon_file -> icon_file: string +ThemeUserInterface.wcol_box -> wcol_box: pointer, (read-only) +ThemeUserInterface.wcol_list_item -> wcol_list_item: pointer, (read-only) +ThemeUserInterface.wcol_menu -> wcol_menu: pointer, (read-only) +ThemeUserInterface.wcol_menu_back -> wcol_menu_back: pointer, (read-only) +ThemeUserInterface.wcol_menu_item -> wcol_menu_item: pointer, (read-only) +ThemeUserInterface.wcol_num -> wcol_num: pointer, (read-only) +ThemeUserInterface.wcol_numslider -> wcol_numslider: pointer, (read-only) +ThemeUserInterface.wcol_option -> wcol_option: pointer, (read-only) +ThemeUserInterface.wcol_progress -> wcol_progress: pointer, (read-only) +ThemeUserInterface.wcol_pulldown -> wcol_pulldown: pointer, (read-only) +ThemeUserInterface.wcol_radio -> wcol_radio: pointer, (read-only) +ThemeUserInterface.wcol_regular -> wcol_regular: pointer, (read-only) +ThemeUserInterface.wcol_scroll -> wcol_scroll: pointer, (read-only) +ThemeUserInterface.wcol_state -> wcol_state: pointer, (read-only) +ThemeUserInterface.wcol_text -> wcol_text: pointer, (read-only) +ThemeUserInterface.wcol_toggle -> wcol_toggle: pointer, (read-only) +ThemeUserInterface.wcol_tool -> wcol_tool: pointer, (read-only) +ThemeUserPreferences.back -> back: float +ThemeUserPreferences.button -> button: float +ThemeUserPreferences.button_text -> button_text: float +ThemeUserPreferences.button_text_hi -> button_text_hi: float +ThemeUserPreferences.button_title -> button_title: float +ThemeUserPreferences.header -> header: float +ThemeUserPreferences.header_text -> header_text: float +ThemeUserPreferences.header_text_hi -> header_text_hi: float +ThemeUserPreferences.text -> text: float +ThemeUserPreferences.text_hi -> text_hi: float +ThemeUserPreferences.title -> title: float +ThemeView3D.act_spline -> act_spline: float +ThemeView3D.back -> back: float +ThemeView3D.bone_pose -> bone_pose: float +ThemeView3D.bone_solid -> bone_solid: float +ThemeView3D.button -> button: float +ThemeView3D.button_text -> button_text: float +ThemeView3D.button_text_hi -> button_text_hi: float +ThemeView3D.button_title -> button_title: float +ThemeView3D.edge_crease -> edge_crease: float +ThemeView3D.edge_facesel -> edge_facesel: float +ThemeView3D.edge_seam -> edge_seam: float +ThemeView3D.edge_select -> edge_select: float +ThemeView3D.edge_sharp -> edge_sharp: float +ThemeView3D.editmesh_active -> editmesh_active: float +ThemeView3D.face -> face: float +ThemeView3D.face_dot -> face_dot: float +ThemeView3D.face_select -> face_select: float +ThemeView3D.facedot_size -> facedot_size: int +ThemeView3D.frame_current -> frame_current: float +ThemeView3D.grid -> grid: float +ThemeView3D.handle_align -> handle_align: float +ThemeView3D.handle_auto -> handle_auto: float +ThemeView3D.handle_free -> handle_free: float +ThemeView3D.handle_sel_align -> handle_sel_align: float +ThemeView3D.handle_sel_auto -> handle_sel_auto: float +ThemeView3D.handle_sel_free -> handle_sel_free: float +ThemeView3D.handle_sel_vect -> handle_sel_vect: float +ThemeView3D.handle_vect -> handle_vect: float +ThemeView3D.header -> header: float +ThemeView3D.header_text -> header_text: float +ThemeView3D.header_text_hi -> header_text_hi: float +ThemeView3D.lamp -> lamp: float +ThemeView3D.lastsel_point -> lastsel_point: float +ThemeView3D.normal -> normal: float +ThemeView3D.nurb_sel_uline -> nurb_sel_uline: float +ThemeView3D.nurb_sel_vline -> nurb_sel_vline: float +ThemeView3D.nurb_uline -> nurb_uline: float +ThemeView3D.nurb_vline -> nurb_vline: float +ThemeView3D.object_active -> object_active: float +ThemeView3D.object_grouped -> object_grouped: float +ThemeView3D.object_grouped_active -> object_grouped_active: float +ThemeView3D.object_selected -> object_selected: float +ThemeView3D.panel -> panel: float +ThemeView3D.text -> text: float +ThemeView3D.text_hi -> text_hi: float +ThemeView3D.title -> title: float +ThemeView3D.transform -> transform: float +ThemeView3D.vertex -> vertex: float +ThemeView3D.vertex_normal -> vertex_normal: float +ThemeView3D.vertex_select -> vertex_select: float +ThemeView3D.vertex_size -> vertex_size: int +ThemeView3D.wire -> wire: float +ThemeWidgetColors.inner -> inner: float +ThemeWidgetColors.inner_sel -> inner_sel: float +ThemeWidgetColors.item -> item: float +ThemeWidgetColors.outline -> outline: float +ThemeWidgetColors.shadedown -> shadedown: int +ThemeWidgetColors.shadetop -> shadetop: int +ThemeWidgetColors.text -> text: float +ThemeWidgetColors.text_sel -> text_sel: float +ThemeWidgetStateColors.blend -> blend: float +ThemeWidgetStateColors.inner_anim -> inner_anim: float +ThemeWidgetStateColors.inner_anim_sel -> inner_anim_sel: float +ThemeWidgetStateColors.inner_driven -> inner_driven: float +ThemeWidgetStateColors.inner_driven_sel -> inner_driven_sel: float +ThemeWidgetStateColors.inner_key -> inner_key: float +ThemeWidgetStateColors.inner_key_sel -> inner_key_sel: float +TimelineMarker.camera -> camera: pointer Camera this timeline sets to active +TimelineMarker.frame -> frame: int The frame on which the timeline marker appears +TimelineMarker.name -> name: string +ToolSettings.autokey_mode -> autokey_mode: enum Mode of automatic keyframe insertion for Objects and Bones +ToolSettings.edge_path_mode -> edge_path_mode: enum The edge flag to tag when selecting the shortest path +ToolSettings.etch_adaptive_limit -> etch_adaptive_limit: float Number of bones in the subdivided stroke +ToolSettings.etch_convert_mode -> etch_convert_mode: enum Method used to convert stroke to bones +ToolSettings.etch_length_limit -> etch_length_limit: float Number of bones in the subdivided stroke +ToolSettings.etch_number -> etch_number: string DOC BROKEN +ToolSettings.etch_roll_mode -> etch_roll_mode: enum Method used to adjust the roll of bones when retargeting +ToolSettings.etch_side -> etch_side: string DOC BROKEN +ToolSettings.etch_subdivision_number -> etch_subdivision_number: int Number of bones in the subdivided stroke +ToolSettings.etch_template -> etch_template: pointer Template armature that will be retargeted to the stroke +ToolSettings.image_paint -> image_paint: pointer, (read-only) +ToolSettings.normal_size -> normal_size: float Display size for normals in the 3D view +ToolSettings.particle_edit -> particle_edit: pointer, (read-only) +ToolSettings.proportional_editing -> proportional_editing: enum Proportional editing mode +ToolSettings.proportional_editing_falloff -> proportional_editing_falloff: enum Falloff type for proportional editing mode +ToolSettings.sculpt -> sculpt: pointer, (read-only) +ToolSettings.snap_element -> snap_element: enum Type of element to snap to +ToolSettings.snap_target -> snap_target: enum Which part to snap onto the target +ToolSettings.uv_selection_mode -> uv_selection_mode: enum UV selection and display mode +ToolSettings.vertex_group_weight -> vertex_group_weight: float Weight to assign in vertex groups +ToolSettings.vertex_paint -> vertex_paint: pointer, (read-only) +ToolSettings.weight_paint -> weight_paint: pointer, (read-only) +TouchSensor.material -> material: pointer Only look for objects with this material +TrackToConstraint.head_tail -> head_tail: float Target along length of bone: Head=0, Tail=1 +TrackToConstraint.subtarget -> subtarget: string +TrackToConstraint.target -> target: pointer Target Object +TrackToConstraint.track -> track: enum Axis that points to the target object +TrackToConstraint.up -> up: enum Axis that points upward +TransformConstraint.from_max_x -> from_max_x: float Top range of X axis source motion +TransformConstraint.from_max_y -> from_max_y: float Top range of Y axis source motion +TransformConstraint.from_max_z -> from_max_z: float Top range of Z axis source motion +TransformConstraint.from_min_x -> from_min_x: float Bottom range of X axis source motion +TransformConstraint.from_min_y -> from_min_y: float Bottom range of Y axis source motion +TransformConstraint.from_min_z -> from_min_z: float Bottom range of Z axis source motion +TransformConstraint.map_from -> map_from: enum The transformation type to use from the target +TransformConstraint.map_to -> map_to: enum The transformation type to affect of the constrained object +TransformConstraint.map_to_x_from -> map_to_x_from: enum The source axis constrained object's X axis uses +TransformConstraint.map_to_y_from -> map_to_y_from: enum The source axis constrained object's Y axis uses +TransformConstraint.map_to_z_from -> map_to_z_from: enum The source axis constrained object's Z axis uses +TransformConstraint.subtarget -> subtarget: string +TransformConstraint.target -> target: pointer Target Object +TransformConstraint.to_max_x -> to_max_x: float Top range of X axis destination motion +TransformConstraint.to_max_y -> to_max_y: float Top range of Y axis destination motion +TransformConstraint.to_max_z -> to_max_z: float Top range of Z axis destination motion +TransformConstraint.to_min_x -> to_min_x: float Bottom range of X axis destination motion +TransformConstraint.to_min_y -> to_min_y: float Bottom range of Y axis destination motion +TransformConstraint.to_min_z -> to_min_z: float Bottom range of Z axis destination motion +TransformOrientation.matrix -> matrix: float +TransformOrientation.name -> name: string +TransformSequence.interpolation -> interpolation: enum +TransformSequence.rotation_start -> rotation_start: float +TransformSequence.scale_start_x -> scale_start_x: float +TransformSequence.scale_start_y -> scale_start_y: float +TransformSequence.translate_start_x -> translate_start_x: float +TransformSequence.translate_start_y -> translate_start_y: float +TransformSequence.translation_unit -> translation_unit: enum +UILayout.alignment -> alignment: enum +UILayout.operator_context -> operator_context: enum +UILayout.scale_x -> scale_x: float +UILayout.scale_y -> scale_y: float +UVProjectModifier.aspect_x -> aspect_x: float +UVProjectModifier.aspect_y -> aspect_y: float +UVProjectModifier.image -> image: pointer +UVProjectModifier.num_projectors -> num_projectors: int Number of projectors to use +UVProjectModifier.projectors -> projectors: collection, (read-only) +UVProjectModifier.scale_x -> scale_x: float +UVProjectModifier.scale_y -> scale_y: float +UVProjectModifier.uv_layer -> uv_layer: string UV layer name +UVProjector.object -> object: pointer Object to use as projector transform +UnitSettings.rotation_units -> rotation_units: enum Unit to use for displaying/editing rotation values +UnitSettings.scale_length -> scale_length: float Scale to use when converting between blender units and dimensions +UnitSettings.system -> system: enum The unit system to use for button display +UserPreferences.active_section -> active_section: enum Active section of the user preferences shown in the user interface +UserPreferences.addons -> addons: collection, (read-only) +UserPreferences.edit -> edit: pointer, (read-only) Settings for interacting with Blender data +UserPreferences.filepaths -> filepaths: pointer, (read-only) Default paths for external files +UserPreferences.inputs -> inputs: pointer, (read-only) Settings for input devices +UserPreferences.system -> system: pointer, (read-only) Graphics driver and operating system settings +UserPreferences.themes -> themes: collection, (read-only) +UserPreferences.uistyles -> uistyles: collection, (read-only) +UserPreferences.view -> view: pointer, (read-only) Preferences related to viewing data +UserPreferencesEdit.auto_keying_mode -> auto_keying_mode: enum Mode of automatic keyframe insertion for Objects and Bones +UserPreferencesEdit.grease_pencil_eraser_radius -> grease_pencil_eraser_radius: int Radius of eraser 'brush' +UserPreferencesEdit.grease_pencil_euclidean_distance -> grease_pencil_euclidean_distance: int Distance moved by mouse when drawing stroke (in pixels) to include +UserPreferencesEdit.grease_pencil_manhattan_distance -> grease_pencil_manhattan_distance: int Pixels moved by mouse per axis when drawing stroke +UserPreferencesEdit.keyframe_new_handle_type -> keyframe_new_handle_type: enum +UserPreferencesEdit.keyframe_new_interpolation_type -> keyframe_new_interpolation_type: enum +UserPreferencesEdit.material_link -> material_link: enum Toggle whether the material is linked to object data or the object block +UserPreferencesEdit.object_align -> object_align: enum When adding objects from a 3D View menu, either align them to that view's direction or the world coordinates +UserPreferencesEdit.undo_memory_limit -> undo_memory_limit: int Maximum memory usage in megabytes (0 means unlimited) +UserPreferencesEdit.undo_steps -> undo_steps: int Number of undo steps available (smaller values conserve memory) +UserPreferencesFilePaths.animation_player -> animation_player: string Path to a custom animation/frame sequence player +UserPreferencesFilePaths.animation_player_preset -> animation_player_preset: enum Preset configs for external animation players +UserPreferencesFilePaths.auto_save_time -> auto_save_time: int The time (in minutes) to wait between automatic temporary saves +UserPreferencesFilePaths.fonts_directory -> fonts_directory: string The default directory to search for loading fonts +UserPreferencesFilePaths.image_editor -> image_editor: string Path to an image editor +UserPreferencesFilePaths.python_scripts_directory -> python_scripts_directory: string The default directory to search for Python scripts (resets python module search path: sys.path) +UserPreferencesFilePaths.recent_files -> recent_files: int Maximum number of recently opened files to remember +UserPreferencesFilePaths.render_output_directory -> render_output_directory: string The default directory for rendering output +UserPreferencesFilePaths.save_version -> save_version: int The number of old versions to maintain in the current directory, when manually saving +UserPreferencesFilePaths.sequence_plugin_directory -> sequence_plugin_directory: string The default directory to search for sequence plugins +UserPreferencesFilePaths.sounds_directory -> sounds_directory: string The default directory to search for sounds +UserPreferencesFilePaths.temporary_directory -> temporary_directory: string The directory for storing temporary save files +UserPreferencesFilePaths.texture_plugin_directory -> texture_plugin_directory: string The default directory to search for texture plugins +UserPreferencesFilePaths.textures_directory -> textures_directory: string The default directory to search for textures +UserPreferencesInput.double_click_time -> double_click_time: int The time (in ms) for a double click +UserPreferencesInput.edited_keymaps -> edited_keymaps: collection, (read-only) +UserPreferencesInput.ndof_pan_speed -> ndof_pan_speed: int The overall panning speed of an NDOF device, as percent of standard +UserPreferencesInput.ndof_rotate_speed -> ndof_rotate_speed: int The overall rotation speed of an NDOF device, as percent of standard +UserPreferencesInput.select_mouse -> select_mouse: enum The mouse button used for selection +UserPreferencesInput.view_rotation -> view_rotation: enum Rotation style in the viewport +UserPreferencesInput.zoom_axis -> zoom_axis: enum Axis of mouse movement to zoom in or out on +UserPreferencesInput.zoom_style -> zoom_style: enum Which style to use for viewport scaling +UserPreferencesSystem.audio_channels -> audio_channels: enum Sets the audio channel count +UserPreferencesSystem.audio_device -> audio_device: enum Sets the audio output device +UserPreferencesSystem.audio_mixing_buffer -> audio_mixing_buffer: enum Sets the number of samples used by the audio mixing buffer +UserPreferencesSystem.audio_sample_format -> audio_sample_format: enum Sets the audio sample format +UserPreferencesSystem.audio_sample_rate -> audio_sample_rate: enum Sets the audio sample rate +UserPreferencesSystem.clip_alpha -> clip_alpha: float Clip alpha below this threshold in the 3D textured view +UserPreferencesSystem.color_picker_type -> color_picker_type: enum Different styles of displaying the color picker widget +UserPreferencesSystem.dpi -> dpi: int Font size and resolution for display +UserPreferencesSystem.frame_server_port -> frame_server_port: int Frameserver Port for Frameserver Rendering +UserPreferencesSystem.gl_texture_limit -> gl_texture_limit: enum Limit the texture size to save graphics memory +UserPreferencesSystem.language -> language: enum Language use for translation +UserPreferencesSystem.memory_cache_limit -> memory_cache_limit: int Memory cache limit in sequencer (megabytes) +UserPreferencesSystem.prefetch_frames -> prefetch_frames: int Number of frames to render ahead during playback +UserPreferencesSystem.screencast_fps -> screencast_fps: int Frame rate for the screencast to be played back +UserPreferencesSystem.screencast_wait_time -> screencast_wait_time: int Time in milliseconds between each frame recorded for screencast +UserPreferencesSystem.scrollback -> scrollback: int Maximum number of lines to store for the console buffer +UserPreferencesSystem.solid_lights -> solid_lights: collection, (read-only) Lights user to display objects in solid draw mode +UserPreferencesSystem.texture_collection_rate -> texture_collection_rate: int Number of seconds between each run of the GL texture garbage collector +UserPreferencesSystem.texture_time_out -> texture_time_out: int Time since last access of a GL texture in seconds after which it is freed. (Set to 0 to keep textures allocated.) +UserPreferencesSystem.weight_color_range -> weight_color_range: pointer, (read-only) Color range used for weight visualization in weight painting mode +UserPreferencesSystem.window_draw_method -> window_draw_method: enum Drawing method used by the window manager +UserPreferencesView.manipulator_handle_size -> manipulator_handle_size: int Size of widget handles as percentage of widget radius +UserPreferencesView.manipulator_hotspot -> manipulator_hotspot: int Hotspot in pixels for clicking widget handles +UserPreferencesView.manipulator_size -> manipulator_size: int Diameter of widget, in 10 pixel units +UserPreferencesView.mini_axis_brightness -> mini_axis_brightness: int The brightness of the icon +UserPreferencesView.mini_axis_size -> mini_axis_size: int The axis icon's size +UserPreferencesView.object_origin_size -> object_origin_size: int Diameter in Pixels for Object/Lamp origin display +UserPreferencesView.open_left_mouse_delay -> open_left_mouse_delay: int Time in 1/10 seconds to hold the Left Mouse Button before opening the toolbox +UserPreferencesView.open_right_mouse_delay -> open_right_mouse_delay: int Time in 1/10 seconds to hold the Right Mouse Button before opening the toolbox +UserPreferencesView.open_sublevel_delay -> open_sublevel_delay: int Time delay in 1/10 seconds before automatically opening sub level menus +UserPreferencesView.open_toplevel_delay -> open_toplevel_delay: int Time delay in 1/10 seconds before automatically opening top level menus +UserPreferencesView.properties_width_check -> properties_width_check: int Dual Column layout will change to single column layout when the width of the area gets below this value (needs restart to take effect) +UserPreferencesView.rotation_angle -> rotation_angle: int The rotation step for numerical pad keys (2 4 6 8) +UserPreferencesView.smooth_view -> smooth_view: int The time to animate the view in milliseconds, zero to disable +UserPreferencesView.timecode_style -> timecode_style: enum Format of Time Codes displayed when not displaying timing in terms of frames +UserPreferencesView.view2d_grid_minimum_spacing -> view2d_grid_minimum_spacing: int Minimum number of pixels between each gridline in 2D Viewports +UserPreferencesView.wheel_scroll_lines -> wheel_scroll_lines: int The number of lines scrolled at a time with the mouse wheel +UserSolidLight.diffuse_color -> diffuse_color: float The diffuse color of the OpenGL light +UserSolidLight.direction -> direction: float The direction that the OpenGL light is shining +UserSolidLight.specular_color -> specular_color: float The color of the lights specular highlight +ValueNodeSocket.default_value -> default_value: float Default value of the socket when no link is attached +ValueNodeSocket.name -> name: string, (read-only) Socket name +VectorFont.filepath -> filepath: string, (read-only) +VectorFont.packed_file -> packed_file: pointer, (read-only) +VectorNodeSocket.default_value -> default_value: float Default value of the socket when no link is attached +VectorNodeSocket.name -> name: string, (read-only) Socket name +VertexGroup.index -> index: int, (read-only) Index number of the vertex group +VertexGroup.name -> name: string Vertex group name +VertexGroupElement.group -> group: int, (read-only) +VertexGroupElement.weight -> weight: float Vertex Weight +VoronoiTexture.coloring -> coloring: enum +VoronoiTexture.distance_metric -> distance_metric: enum +VoronoiTexture.minkovsky_exponent -> minkovsky_exponent: float Minkovsky exponent +VoronoiTexture.nabla -> nabla: float Size of derivative offset used for calculating normal +VoronoiTexture.noise_intensity -> noise_intensity: float +VoronoiTexture.noise_size -> noise_size: float Sets scaling for noise input +VoronoiTexture.weight_1 -> weight_1: float Voronoi feature weight 1 +VoronoiTexture.weight_2 -> weight_2: float Voronoi feature weight 2 +VoronoiTexture.weight_3 -> weight_3: float Voronoi feature weight 3 +VoronoiTexture.weight_4 -> weight_4: float Voronoi feature weight 4 +VoxelData.domain_object -> domain_object: pointer Object used as the smoke simulation domain +VoxelData.extension -> extension: enum Sets how the texture is extrapolated past its original bounds +VoxelData.file_format -> file_format: enum Format of the source data set to render +VoxelData.intensity -> intensity: float Multiplier for intensity values +VoxelData.interpolation -> interpolation: enum Method to interpolate/smooth values between voxel cells +VoxelData.resolution -> resolution: int Resolution of the voxel grid +VoxelData.smoke_data_type -> smoke_data_type: enum Simulation value to be used as a texture +VoxelData.source_path -> source_path: string The external source data file to use +VoxelData.still_frame_number -> still_frame_number: int The frame number to always use +VoxelDataTexture.image -> image: pointer +VoxelDataTexture.image_user -> image_user: pointer, (read-only) Parameters defining which layer, pass and frame of the image is displayed +VoxelDataTexture.voxeldata -> voxeldata: pointer, (read-only) The voxel data associated with this texture +WaveModifier.damping_time -> damping_time: float +WaveModifier.falloff_radius -> falloff_radius: float +WaveModifier.height -> height: float +WaveModifier.lifetime -> lifetime: float +WaveModifier.narrowness -> narrowness: float +WaveModifier.speed -> speed: float +WaveModifier.start_position_object -> start_position_object: pointer +WaveModifier.start_position_x -> start_position_x: float +WaveModifier.start_position_y -> start_position_y: float +WaveModifier.texture -> texture: pointer Texture for modulating the wave +WaveModifier.texture_coordinates -> texture_coordinates: enum Texture coordinates used for modulating input +WaveModifier.texture_coordinates_object -> texture_coordinates_object: pointer +WaveModifier.time_offset -> time_offset: float Either the starting frame (for positive speed) or ending frame (for negative speed.) +WaveModifier.uv_layer -> uv_layer: string UV layer name +WaveModifier.vertex_group -> vertex_group: string Vertex group name for modulating the wave +WaveModifier.width -> width: float +Window.screen -> screen: pointer Active screen showing in the window +WindowManager.active_keyconfig -> active_keyconfig: pointer +WindowManager.default_keyconfig -> default_keyconfig: pointer, (read-only) +WindowManager.keyconfigs -> keyconfigs: collection, (read-only) Registered key configurations +WindowManager.operators -> operators: collection, (read-only) Operator registry +WindowManager.windows -> windows: collection, (read-only) Open windows +WipeSequence.angle -> angle: float Edge angle +WipeSequence.blur_width -> blur_width: float Width of the blur edge, in percentage relative to the image size +WipeSequence.direction -> direction: enum Wipe direction +WipeSequence.transition_type -> transition_type: enum +WoodTexture.nabla -> nabla: float Size of derivative offset used for calculating normal +WoodTexture.noise_basis -> noise_basis: enum Sets the noise basis used for turbulence +WoodTexture.noise_size -> noise_size: float Sets scaling for noise input +WoodTexture.noise_type -> noise_type: enum +WoodTexture.noisebasis2 -> noisebasis2: enum +WoodTexture.stype -> stype: enum +WoodTexture.turbulence -> turbulence: float Sets the turbulence of the bandnoise and ringnoise types +World.active_texture -> active_texture: pointer Active texture slot being displayed +World.active_texture_index -> active_texture_index: int Index of active texture slot +World.ambient_color -> ambient_color: float +World.animation_data -> animation_data: pointer, (read-only) Animation data for this datablock +World.exposure -> exposure: float Amount of exponential color correction for light +World.horizon_color -> horizon_color: float Color at the horizon +World.lighting -> lighting: pointer, (read-only) World lighting settings +World.mist -> mist: pointer, (read-only) World mist settings +World.range -> range: float The color range that will be mapped to 0-1 +World.stars -> stars: pointer, (read-only) World stars settings +World.texture_slots -> texture_slots: collection, (read-only) Texture slots defining the mapping and influence of textures +World.zenith_color -> zenith_color: float Color at the zenith +WorldLighting.adapt_to_speed -> adapt_to_speed: float Use the speed vector pass to reduce AO samples in fast moving pixels. Higher values result in more aggressive sample reduction. Requires Vec pass enabled (for Raytrace Adaptive QMC) +WorldLighting.ao_blend_mode -> ao_blend_mode: enum Defines how AO mixes with material shading +WorldLighting.ao_factor -> ao_factor: float Factor for ambient occlusion blending +WorldLighting.bias -> bias: float Bias (in radians) to prevent smoothed faces from showing banding (for Raytrace Constant Jittered) +WorldLighting.correction -> correction: float Ad-hoc correction for over-occlusion due to the approximation (for Approximate) +WorldLighting.distance -> distance: float Length of rays, defines how far away other faces give occlusion effect +WorldLighting.environment_color -> environment_color: enum Defines where the color of the environment light comes from +WorldLighting.environment_energy -> environment_energy: float Defines the strength of environment light +WorldLighting.error_tolerance -> error_tolerance: float Low values are slower and higher quality (for Approximate) +WorldLighting.falloff_strength -> falloff_strength: float Distance attenuation factor, the higher, the 'shorter' the shadows +WorldLighting.gather_method -> gather_method: enum +WorldLighting.indirect_bounces -> indirect_bounces: int Number of indirect diffuse light bounces to use for approximate ambient occlusion +WorldLighting.indirect_factor -> indirect_factor: float Factor for how much surrounding objects contribute to light +WorldLighting.passes -> passes: int Number of preprocessing passes to reduce overocclusion (for approximate ambient occlusion) +WorldLighting.sample_method -> sample_method: enum Method for generating shadow samples (for Raytrace) +WorldLighting.samples -> samples: int Amount of ray samples. Higher values give smoother results and longer rendering times +WorldLighting.threshold -> threshold: float Samples below this threshold will be considered fully shadowed/unshadowed and skipped (for Raytrace Adaptive QMC) +WorldMistSettings.depth -> depth: float The distance over which the mist effect fades in +WorldMistSettings.falloff -> falloff: enum Type of transition used to fade mist +WorldMistSettings.height -> height: float Control how much mist density decreases with height +WorldMistSettings.intensity -> intensity: float Intensity of the mist effect +WorldMistSettings.start -> start: float Starting distance of the mist, measured from the camera +WorldStarsSettings.average_separation -> average_separation: float Average distance between any two stars +WorldStarsSettings.color_randomization -> color_randomization: float Randomize star colors +WorldStarsSettings.min_distance -> min_distance: float Minimum distance to the camera for stars +WorldStarsSettings.size -> size: float Average screen dimension of stars +WorldTextureSlot.blend_factor -> blend_factor: float Amount texture affects color progression of the background +WorldTextureSlot.horizon_factor -> horizon_factor: float Amount texture affects color of the horizon +WorldTextureSlot.object -> object: pointer Object to use for mapping with Object texture coordinates +WorldTextureSlot.texture_coordinates -> texture_coordinates: enum Texture coordinates used to map the texture onto the background +WorldTextureSlot.zenith_down_factor -> zenith_down_factor: float Amount texture affects color of the zenith below +WorldTextureSlot.zenith_up_factor -> zenith_up_factor: float Amount texture affects color of the zenith above |