rna refactoring update, order by class, attribute.
This commit is contained in:
Campbell Barton
@@ -1,4605 +1,4605 @@
|
||||
NOTE * CLASS.FROM -> TO: TYPE DESCRIPTION
|
||||
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 'NO DESCRIPTION'
|
||||
ActionActuator.blendin -> blendin: int 'Number of frames of motion blending'
|
||||
ActionActuator.continue_last_frame -> use_continue_last_frame: boolean 'Restore last frame when switching on/off, otherwise play from the start each time'
|
||||
ActionActuator.frame_end -> frame_end: int 'NO DESCRIPTION'
|
||||
ActionActuator.frame_property -> frame_property: string "Assign the action's current frame number to this property"
|
||||
ActionActuator.frame_start -> frame_start: int 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 -> max: float 'Maximum value for target channel range'
|
||||
ActionConstraint.minimum -> min: float 'Minimum value for target channel range'
|
||||
ActionConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
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.expanded -> show_expanded: boolean 'Action Group is expanded'
|
||||
ActionGroup.lock -> lock: boolean 'Action Group is locked'
|
||||
ActionGroup.name -> name: string 'NO DESCRIPTION'
|
||||
ActionGroup.select -> select: boolean 'Action Group is selected'
|
||||
Actuator.expanded -> show_expanded: boolean 'Set actuator expanded in the user interface'
|
||||
Actuator.name -> name: string 'NO DESCRIPTION'
|
||||
Actuator.pinned -> pinned: boolean 'Display when not linked to a visible states controller'
|
||||
Actuator.type -> type: enum 'NO DESCRIPTION'
|
||||
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_blend_type: 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_enabled -> use_nla: boolean 'NLA stack is evaluated when evaluating this block'
|
||||
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_skin_frames: 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.highlight_keyframes -> show_keyframe_highlight: boolean 'Emphasize position of keyframes on Motion Paths'
|
||||
AnimVizMotionPaths.search_all_action_keyframes -> show_keyframe_action_all: boolean 'For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)'
|
||||
AnimVizMotionPaths.show_frame_numbers -> show_frame_numbers: boolean 'Show frame numbers on Motion Paths'
|
||||
AnimVizMotionPaths.show_keyframe_numbers -> show_keyframe_numbers: boolean 'Show frame numbers of Keyframes on Motion Paths'
|
||||
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.only_selected -> show_only_selected: boolean 'For Pose-Mode drawing, only draw ghosts for selected bones'
|
||||
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.show_menus -> show_menus: boolean 'Show menus in the header'
|
||||
Area.spaces -> spaces: collection, '(read-only) Spaces contained in this area, the first space is active'
|
||||
Area.type -> type: enum 'Space type'
|
||||
AreaLamp.dither -> use_dither: boolean 'Use 2x2 dithering for sampling (Constant Jittered sampling)'
|
||||
AreaLamp.gamma -> gamma: float 'Light gamma correction value'
|
||||
AreaLamp.jitter -> use_jitter: boolean 'Use noise for sampling (Constant Jittered sampling)'
|
||||
AreaLamp.only_shadow -> use_only_shadow: boolean 'Causes light to cast shadows only without illuminating objects'
|
||||
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_layer -> use_shadow_layer: boolean 'Causes only objects on the same layer to cast shadows'
|
||||
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_sample_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'
|
||||
AreaLamp.umbra -> use_umbra: boolean 'Emphasize parts that are fully shadowed (Constant Jittered sampling)'
|
||||
Armature.animation_data -> animation_data: pointer, '(read-only) Animation data for this datablock'
|
||||
Armature.auto_ik -> use_auto_ik: boolean 'Add temporaral IK constraints while grabbing bones in Pose Mode'
|
||||
Armature.bones -> bones: collection, '(read-only)'
|
||||
Armature.deform_envelope -> use_deform_envelopes: boolean 'Enable Bone Envelopes when defining deform'
|
||||
Armature.deform_quaternion -> use_deform_preserve_volume: boolean 'Deform rotation interpolation with quaternions'
|
||||
Armature.deform_vertexgroups -> use_deform_vertex_groups: boolean 'Enable Vertex Groups when defining deform'
|
||||
Armature.delay_deform -> use_deform_delay: boolean "Don't deform children when manipulating bones in Pose Mode"
|
||||
Armature.draw_axes -> show_axes: boolean 'Draw bone axes'
|
||||
Armature.draw_custom_bone_shapes -> show_bone_custom_shapes: boolean 'Draw bones with their custom shapes'
|
||||
Armature.draw_group_colors -> show_group_colors: boolean 'Draw bone group colors'
|
||||
Armature.draw_names -> show_names: boolean 'Draw bone names'
|
||||
Armature.drawtype -> drawtype: enum 'NO DESCRIPTION'
|
||||
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_only_selected -> show_only_ghost_selected: boolean 'NO DESCRIPTION'
|
||||
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.layer -> layers: boolean 'Armature layer visibility'
|
||||
Armature.layer_protection -> layers_protected: boolean 'Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo'
|
||||
Armature.pose_position -> pose_position: enum 'Show armature in binding pose or final posed state'
|
||||
Armature.x_axis_mirror -> use_mirror_x: boolean 'Apply changes to matching bone on opposite side of X-Axis'
|
||||
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 'NO DESCRIPTION'
|
||||
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.invert -> invert_vertex_group: boolean 'Invert vertex group influence'
|
||||
ArmatureModifier.multi_modifier -> use_multi_modifier: boolean 'Use same input as previous modifier, and mix results using overall vgroup'
|
||||
ArmatureModifier.object -> object: pointer 'Armature object to deform with'
|
||||
ArmatureModifier.quaternion -> use_deform_preserve_volume: boolean 'Deform rotation interpolation with quaternions'
|
||||
ArmatureModifier.use_bone_envelopes -> use_bone_envelopes: boolean 'NO DESCRIPTION'
|
||||
ArmatureModifier.use_vertex_groups -> use_vertex_groups: boolean 'NO DESCRIPTION'
|
||||
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.add_offset_object -> use_object_offset: boolean "Add another object's transformation to the total offset"
|
||||
ArrayModifier.constant_offset -> use_constant_offset: boolean 'Add a constant offset'
|
||||
ArrayModifier.constant_offset_displacement -> constant_offset_displacement: float 'NO DESCRIPTION'
|
||||
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_adjacent_vertices -> use_merge_adjacent_vertices: boolean 'Merge vertices in adjacent duplicates'
|
||||
ArrayModifier.merge_distance -> merge_distance: float 'Limit below which to merge vertices'
|
||||
ArrayModifier.merge_end_vertices -> use_merge_end_vertices: boolean 'Merge vertices in first and last duplicates'
|
||||
ArrayModifier.offset_object -> offset_object: pointer 'NO DESCRIPTION'
|
||||
ArrayModifier.relative_offset -> use_relative_offset: boolean "Add an offset relative to the object's bounding box"
|
||||
ArrayModifier.relative_offset_displacement -> relative_offset_displacement: float 'NO DESCRIPTION'
|
||||
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.show_expanded -> show_expanded: boolean 'Show the expanded in the user interface'
|
||||
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 'NO DESCRIPTION'
|
||||
BevelModifier.only_vertices -> use_only_vertices: boolean 'Bevel verts/corners, not edges'
|
||||
BevelModifier.width -> width: float 'Bevel value/amount'
|
||||
BezierSplinePoint.co -> co: float 'Coordinates of the control point'
|
||||
BezierSplinePoint.handle1 -> handle_left: float 'Coordinates of the first handle'
|
||||
BezierSplinePoint.handle1_type -> handle_left_type: enum 'Handle types'
|
||||
BezierSplinePoint.handle2 -> handle_right: float 'Coordinates of the second handle'
|
||||
BezierSplinePoint.handle2_type -> handle_right_type: enum 'Handle types'
|
||||
BezierSplinePoint.hide -> hide: boolean 'Visibility status'
|
||||
BezierSplinePoint.radius -> radius: float, '(read-only) Radius for bevelling'
|
||||
BezierSplinePoint.select_control_point -> select_control_point: boolean 'Control point selection status'
|
||||
BezierSplinePoint.select_left_handle -> select_left_handle: boolean 'Handle 1 selection status'
|
||||
BezierSplinePoint.select_right_handle -> select_right_handle: boolean 'Handle 2 selection status'
|
||||
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.in_air -> use_in_air: boolean 'Use rule when boid is flying'
|
||||
BoidRule.name -> name: string 'Boid rule name'
|
||||
BoidRule.on_land -> use_on_land: boolean 'Use rule when boid is on land'
|
||||
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'
|
||||
BoidRuleAvoid.predict -> use_predict: boolean 'Predict target movement'
|
||||
BoidRuleAvoidCollision.boids -> use_avoid: boolean 'Avoid collision with other boids'
|
||||
BoidRuleAvoidCollision.deflectors -> use_avoid_collision: boolean 'Avoid collision with deflector objects'
|
||||
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.line -> use_line: boolean 'Follow leader in a line'
|
||||
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'
|
||||
BoidRuleGoal.predict -> use_predict: boolean 'Predict target movement'
|
||||
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 'NO DESCRIPTION'
|
||||
BoidSettings.aggression -> aggression: float 'Boid will fight this times stronger enemy'
|
||||
BoidSettings.air_max_acc -> air_acc_max: float 'Maximum acceleration in air (relative to maximum speed)'
|
||||
BoidSettings.air_max_ave -> air_ave_max: float 'Maximum angular velocity in air (relative to 180 degrees)'
|
||||
BoidSettings.air_max_speed -> air_speed_max: float 'Maximum speed in air'
|
||||
BoidSettings.air_min_speed -> air_speed_min: 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.allow_climb -> use_climb: boolean 'Allow boids to climb goal objects'
|
||||
BoidSettings.allow_flight -> use_flight: boolean 'Allow boids to move in air'
|
||||
BoidSettings.allow_land -> use_land: boolean 'Allow boids to move on land'
|
||||
BoidSettings.banking -> bank: 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_acc_max: float 'Maximum acceleration on land (relative to maximum speed)'
|
||||
BoidSettings.land_max_ave -> land_ave_max: float 'Maximum angular velocity on land (relative to 180 degrees)'
|
||||
BoidSettings.land_max_speed -> land_speed_max: 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 -> land_smooth: 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 'NO DESCRIPTION'
|
||||
BoidState.falloff -> falloff: float 'NO DESCRIPTION'
|
||||
BoidState.name -> name: string 'Boid state name'
|
||||
BoidState.rule_fuzziness -> rule_fuzzy: float 'NO DESCRIPTION'
|
||||
BoidState.rules -> rules: collection, '(read-only)'
|
||||
BoidState.ruleset_type -> ruleset_type: enum 'How the rules in the list are evaluated'
|
||||
BoidState.volume -> volume: float 'NO DESCRIPTION'
|
||||
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.connected -> use_connect: boolean, "(read-only) When bone has a parent, bone's head is struck to the parent's tail"
|
||||
Bone.cyclic_offset -> use_cyclic_offset: boolean "When bone doesn't have a parent, it receives cyclic offset effects"
|
||||
Bone.deform -> use_deform: boolean 'Bone does not deform any geometry'
|
||||
Bone.draw_wire -> show_wire: boolean 'Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes'
|
||||
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.hide -> hide: boolean 'Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)'
|
||||
Bone.hide_select -> hide_select: boolean 'Bone is able to be selected'
|
||||
Bone.hinge -> use_hinge: boolean 'Bone inherits rotation or scale from parent bone'
|
||||
Bone.inherit_scale -> use_inherit_scale: boolean 'Bone inherits scaling from parent bone'
|
||||
Bone.layer -> layers: boolean 'Layers bone exists in'
|
||||
Bone.local_location -> use_local_location: boolean 'Bone location is set in local space'
|
||||
Bone.matrix -> matrix: float '3x3 bone matrix'
|
||||
Bone.matrix_local -> matrix_local: float '4x4 bone matrix relative to armature'
|
||||
Bone.multiply_vertexgroup_with_envelope -> use_envelope_multiply: boolean 'When deforming bone, multiply effects of Vertex Group weights with Envelope influence'
|
||||
Bone.name -> name: string 'NO DESCRIPTION'
|
||||
Bone.parent -> parent: pointer, '(read-only) Parent bone (in same Armature)'
|
||||
Bone.select -> select: boolean 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
BooleanModifier.object -> object: pointer 'Mesh object to use for Boolean operation'
|
||||
BooleanModifier.operation -> operation: enum 'NO DESCRIPTION'
|
||||
BooleanProperty.array_length -> array_length: int, '(read-only) Maximum length of the array, 0 means unlimited'
|
||||
BooleanProperty.default -> default: boolean, '(read-only) Default value for this number'
|
||||
BooleanProperty.default_array -> default_array: boolean, '(read-only) Default value for this array'
|
||||
Brush.add_col -> add_col: float 'Color of cursor when adding'
|
||||
Brush.autosmooth_factor -> autosmooth_factor: float 'Amount of smoothing to automatically apply to each stroke'
|
||||
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 'NO DESCRIPTION'
|
||||
Brush.color -> color: float 'NO DESCRIPTION'
|
||||
Brush.crease_pinch_factor -> crease_pinch_factor: float 'How much the crease brush pinches'
|
||||
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.edge_to_edge -> edge_to_edge: boolean 'Drag anchor brush from edge-to-edge'
|
||||
Brush.icon_filepath -> icon_filepath: string 'File path to brush icon'
|
||||
Brush.imagepaint_tool -> imagepaint_tool: enum 'NO DESCRIPTION'
|
||||
Brush.jitter -> jitter: float 'Jitter the position of the brush while painting'
|
||||
Brush.normal_weight -> normal_weight: float 'How much grab will pull vertexes out of surface during a grab'
|
||||
Brush.plane_offset -> plane_offset: float 'Adjusts plane on which the brush acts towards or away from the object surface'
|
||||
Brush.plane_trim -> plane_trim: float 'If a vertex is further from offset plane than this then it is not affected'
|
||||
Brush.rate -> rate: float 'Interval between paints for Airbrush'
|
||||
Brush.restore_mesh -> restore_mesh: boolean 'Allows a single dot to be carefully positioned'
|
||||
Brush.sculpt_plane -> sculpt_plane: enum 'NO DESCRIPTION'
|
||||
Brush.sculpt_tool -> sculpt_tool: enum 'NO DESCRIPTION'
|
||||
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.stroke_method -> stroke_method: enum 'NO DESCRIPTION'
|
||||
Brush.sub_col -> sub_col: float 'Color of cursor when subtracting'
|
||||
Brush.texture -> texture: pointer 'NO DESCRIPTION'
|
||||
Brush.texture_angle_source -> texture_angle_source: enum 'NO DESCRIPTION'
|
||||
Brush.texture_angle_source_no_random -> texture_angle_source_no_random: enum 'NO DESCRIPTION'
|
||||
Brush.texture_overlay_alpha -> texture_overlay_alpha: int 'NO DESCRIPTION'
|
||||
Brush.texture_sample_bias -> texture_sample_bias: float 'Value added to texture samples'
|
||||
Brush.texture_slot -> texture_slot: pointer, '(read-only)'
|
||||
Brush.unprojected_radius -> unprojected_radius: float 'Radius of brush in Blender units'
|
||||
Brush.use_accumulate -> use_accumulate: boolean 'Accumulate stroke dabs on top of each other'
|
||||
Brush.use_adaptive_space -> use_adaptive_space: boolean 'Space daubs according to surface orientation instead of screen space'
|
||||
Brush.use_airbrush -> use_airbrush: boolean 'Keep applying paint effect while holding mouse (spray)'
|
||||
Brush.use_alpha -> use_alpha: boolean 'When this is disabled, lock alpha while painting'
|
||||
Brush.use_anchor -> use_anchor: boolean 'Keep the brush anchored to the initial location'
|
||||
Brush.use_custom_icon -> use_custom_icon: boolean 'Set the brush icon from an image file'
|
||||
Brush.use_frontface -> use_frontface: boolean 'Brush only affects vertexes that face the viewer'
|
||||
Brush.use_inverse_smooth_pressure -> use_inverse_smooth_pressure: boolean 'Lighter pressure causes more smoothing to be applied'
|
||||
Brush.use_jitter_pressure -> use_pressure_jitter: boolean 'Enable tablet pressure sensitivity for jitter'
|
||||
Brush.use_locked_size -> use_locked_size: boolean 'When locked brush stays same size relative to object; when unlocked brush size is given in pixels'
|
||||
Brush.use_offset_pressure -> use_offset_pressure: boolean 'Enable tablet pressure sensitivity for offset'
|
||||
Brush.use_original_normal -> use_original_normal: boolean 'When locked keep using normal of surface where stroke was initiated'
|
||||
Brush.use_paint_sculpt -> use_paint_sculpt: boolean 'Use this brush in sculpt mode'
|
||||
Brush.use_paint_texture -> use_paint_texture: boolean 'Use this brush in texture paint mode'
|
||||
Brush.use_paint_vertex -> use_paint_vertex: boolean 'Use this brush in vertex paint mode'
|
||||
Brush.use_paint_weight -> use_paint_weight: boolean 'Use this brush in weight paint mode'
|
||||
Brush.use_persistent -> use_persistent: boolean 'Sculpts on a persistent layer of the mesh'
|
||||
Brush.use_plane_trim -> use_plane_trim: boolean 'Enable Plane Trim'
|
||||
Brush.use_rake -> use_rake: boolean 'Rotate the brush texture to match the stroke direction'
|
||||
Brush.use_random_rotation -> use_random_rotation: boolean 'Rotate the brush texture at random'
|
||||
Brush.use_size_pressure -> use_pressure_size: boolean 'Enable tablet pressure sensitivity for size'
|
||||
Brush.use_smooth_stroke -> use_smooth_stroke: boolean 'Brush lags behind mouse and follows a smoother path'
|
||||
Brush.use_space -> use_space: boolean 'Limit brush application to the distance specified by spacing'
|
||||
Brush.use_space_atten -> use_space_atten: boolean 'Automatically adjusts strength to give consistent results for different spacings'
|
||||
Brush.use_spacing_pressure -> use_pressure_spacing: boolean 'Enable tablet pressure sensitivity for spacing'
|
||||
Brush.use_strength_pressure -> use_pressure_strength: boolean 'Enable tablet pressure sensitivity for strength'
|
||||
Brush.use_texture_overlay -> use_texture_overlay: boolean 'Show texture in viewport'
|
||||
Brush.use_wrap -> use_wrap: boolean 'Enable torus wrapping while painting'
|
||||
Brush.vertexpaint_tool -> vertexpaint_tool: enum 'NO DESCRIPTION'
|
||||
BrushTextureSlot.angle -> angle: float 'Defines brush texture rotation'
|
||||
BrushTextureSlot.map_mode -> map_mode: enum 'NO DESCRIPTION'
|
||||
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.randomize -> use_random_order: boolean 'Randomize the faces or edges during build'
|
||||
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.panorama -> use_panorama: boolean 'Render the scene with a cylindrical camera for pseudo-fisheye lens effects'
|
||||
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.show_limits -> show_limits: boolean 'Draw the clipping range and focus point on the camera'
|
||||
Camera.show_mist -> show_mist: boolean 'Draw a line from the Camera to indicate the mist area'
|
||||
Camera.show_name -> show_name: boolean "Show the active Camera's name in Camera view"
|
||||
Camera.show_passepartout -> show_passepartout: boolean 'Show a darkened overlay outside the image area in Camera view'
|
||||
Camera.show_title_safe -> show_title_safe: boolean 'Show indicators for the title safe zone in Camera view'
|
||||
Camera.type -> type: enum 'Camera types'
|
||||
CameraActuator.axis -> axis: enum 'Specify the axis the Camera will try to get behind'
|
||||
CameraActuator.height -> height: float 'NO DESCRIPTION'
|
||||
CameraActuator.max -> max: float 'NO DESCRIPTION'
|
||||
CameraActuator.min -> min: float 'NO DESCRIPTION'
|
||||
CameraActuator.object -> object: pointer 'Look at this Object'
|
||||
CastModifier.cast_type -> cast_type: enum 'NO DESCRIPTION'
|
||||
CastModifier.factor -> factor: float 'NO DESCRIPTION'
|
||||
CastModifier.from_radius -> use_radius_as_size: boolean 'Use radius as size of projection shape (0 = auto)'
|
||||
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.use_transform -> use_transform: boolean 'Use object transform to control projection shape'
|
||||
CastModifier.vertex_group -> vertex_group: string 'Vertex group name'
|
||||
CastModifier.x -> use_x: boolean 'NO DESCRIPTION'
|
||||
CastModifier.y -> use_y: boolean 'NO DESCRIPTION'
|
||||
CastModifier.z -> use_z: boolean 'NO DESCRIPTION'
|
||||
ChildOfConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
ChildOfConstraint.target -> target: pointer 'Target Object'
|
||||
ChildOfConstraint.use_location_x -> use_location_x: boolean 'Use X Location of Parent'
|
||||
ChildOfConstraint.use_location_y -> use_location_y: boolean 'Use Y Location of Parent'
|
||||
ChildOfConstraint.use_location_z -> use_location_z: boolean 'Use Z Location of Parent'
|
||||
ChildOfConstraint.use_rotation_x -> use_rotation_x: boolean 'Use X Rotation of Parent'
|
||||
ChildOfConstraint.use_rotation_y -> use_rotation_y: boolean 'Use Y Rotation of Parent'
|
||||
ChildOfConstraint.use_rotation_z -> use_rotation_z: boolean 'Use Z Rotation of Parent'
|
||||
ChildOfConstraint.use_scale_x -> use_scale_x: boolean 'Use X Scale of Parent'
|
||||
ChildOfConstraint.use_scale_y -> use_scale_y: boolean 'Use Y Scale of Parent'
|
||||
ChildOfConstraint.use_scale_z -> use_scale_z: boolean 'Use Z Scale of Parent'
|
||||
ClampToConstraint.cyclic -> use_cyclic: boolean 'Treat curve as cyclic curve (no clamping to curve bounding box'
|
||||
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.enable_collision -> use_collision: boolean 'Enable collisions with other objects'
|
||||
ClothCollisionSettings.enable_self_collision -> use_self_collision: boolean 'Enable self collisions'
|
||||
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 -> distance_min: 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_distance_min: 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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
ClothSettings.mass -> mass: float 'Mass of cloth material'
|
||||
ClothSettings.mass_vertex_group -> mass_vertex_group: string 'Vertex Group for pinning of vertices'
|
||||
ClothSettings.pin_cloth -> use_pin_cloth: boolean 'Enable pinning of cloth vertices to other objects/positions'
|
||||
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.stiffness_scaling -> use_stiffness_scale: boolean 'If enabled, stiffness can be scaled along a weight painted vertex group'
|
||||
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 'NO DESCRIPTION'
|
||||
CloudsTexture.stype -> stype: enum 'NO DESCRIPTION'
|
||||
CollectionProperty.fixed_type -> fixed_type: pointer, '(read-only) Fixed pointer type, empty if variable type'
|
||||
CollisionModifier.settings -> settings: pointer, '(read-only)'
|
||||
CollisionSensor.collision_type -> use_material: boolean 'Use material instead of property'
|
||||
CollisionSensor.material -> material: string 'Only look for Objects with this material'
|
||||
CollisionSensor.property -> property: string 'Only look for Objects with this property'
|
||||
CollisionSensor.pulse -> use_pulse: boolean 'Changes to the set of colliding objects generates pulse'
|
||||
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.enabled -> use: boolean 'Enable this objects as a collider for physics systems'
|
||||
CollisionSettings.friction_factor -> friction_factor: float 'Amount of friction during particle collision'
|
||||
CollisionSettings.inner_thickness -> inner_thickness: float 'Inner face thickness'
|
||||
CollisionSettings.kill_particles -> use_particle_kill: boolean 'Kill colliding particles'
|
||||
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 'NO DESCRIPTION'
|
||||
ColorRamp.total -> total: int, '(read-only) Total number of elements'
|
||||
ColorRampElement.color -> color: float 'NO DESCRIPTION'
|
||||
ColorRampElement.position -> position: float 'NO DESCRIPTION'
|
||||
ColorSequence.color -> color: float 'NO DESCRIPTION'
|
||||
CompositorNode.type -> type: enum, '(read-only)'
|
||||
CompositorNodeAlphaOver.convert_premul -> use_premultiply: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeAlphaOver.premul -> premul: float 'Mix Factor'
|
||||
CompositorNodeBilateralblur.iterations -> iterations: int 'NO DESCRIPTION'
|
||||
CompositorNodeBilateralblur.sigma_color -> sigma_color: float 'NO DESCRIPTION'
|
||||
CompositorNodeBilateralblur.sigma_space -> sigma_space: float 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.bokeh -> use_bokeh: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.factor -> factor: float 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.factor_x -> factor_x: float 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.factor_y -> factor_y: float 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.filter_type -> filter_type: enum 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.gamma -> use_gamma_correction: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.relative -> use_relative: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.sizex -> size_x: int 'NO DESCRIPTION'
|
||||
CompositorNodeBlur.sizey -> size_y: int 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
CompositorNodeColorSpill.channel -> channel: enum 'NO DESCRIPTION'
|
||||
CompositorNodeColorSpill.limit_channel -> limit_channel: enum 'NO DESCRIPTION'
|
||||
CompositorNodeColorSpill.ratio -> ratio: float 'Scale limit by value'
|
||||
CompositorNodeColorSpill.unspill -> use_unspill: boolean 'Compensate all channels (diffenrently) by hand'
|
||||
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.crop_size -> use_crop_size: boolean 'Whether to crop the size of the input image'
|
||||
CompositorNodeCrop.x1 -> x1: int 'NO DESCRIPTION'
|
||||
CompositorNodeCrop.x2 -> x2: int 'NO DESCRIPTION'
|
||||
CompositorNodeCrop.y1 -> y1: int 'NO DESCRIPTION'
|
||||
CompositorNodeCrop.y2 -> y2: int 'NO DESCRIPTION'
|
||||
CompositorNodeCurveRGB.mapping -> mapping: pointer, '(read-only)'
|
||||
CompositorNodeCurveVec.mapping -> mapping: pointer, '(read-only)'
|
||||
CompositorNodeDBlur.angle -> angle: float 'NO DESCRIPTION'
|
||||
CompositorNodeDBlur.center_x -> center_x: float 'NO DESCRIPTION'
|
||||
CompositorNodeDBlur.center_y -> center_y: float 'NO DESCRIPTION'
|
||||
CompositorNodeDBlur.distance -> distance: float 'NO DESCRIPTION'
|
||||
CompositorNodeDBlur.iterations -> iterations: int 'NO DESCRIPTION'
|
||||
CompositorNodeDBlur.spin -> spin: float 'NO DESCRIPTION'
|
||||
CompositorNodeDBlur.wrap -> use_wrap: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeDBlur.zoom -> zoom: float 'NO DESCRIPTION'
|
||||
CompositorNodeDefocus.angle -> angle: int 'Bokeh shape rotation offset in degrees'
|
||||
CompositorNodeDefocus.bokeh -> bokeh: enum 'NO DESCRIPTION'
|
||||
CompositorNodeDefocus.f_stop -> f_stop: float 'Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius'
|
||||
CompositorNodeDefocus.gamma_correction -> use_gamma_correction: boolean 'Enable gamma correction before and after main process'
|
||||
CompositorNodeDefocus.max_blur -> blur_max: float 'blur limit, maximum CoC radius, 0=no limit'
|
||||
CompositorNodeDefocus.preview -> use_preview: boolean 'Enable sampling mode, useful for preview when using low samplecounts'
|
||||
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.use_zbuffer -> use_zbuffer: boolean 'Disable when using an image as input instead of actual zbuffer (auto enabled if node not image based, eg. time node)'
|
||||
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 'NO DESCRIPTION'
|
||||
CompositorNodeFlip.axis -> axis: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
CompositorNodeGlare.iterations -> iterations: int 'NO DESCRIPTION'
|
||||
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.rotate_45 -> use_rotate_45: boolean 'Simple star filter: add 45 degree rotation offset'
|
||||
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 'NO DESCRIPTION'
|
||||
CompositorNodeHueSat.sat -> sat: float 'NO DESCRIPTION'
|
||||
CompositorNodeHueSat.val -> val: float 'NO DESCRIPTION'
|
||||
CompositorNodeIDMask.index -> index: int 'Pass index number to convert to alpha'
|
||||
CompositorNodeImage.auto_refresh -> use_auto_refresh: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeImage.cyclic -> use_cyclic: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeImage.frames -> frames: int 'Number of images used in animation'
|
||||
CompositorNodeImage.image -> image: pointer 'NO DESCRIPTION'
|
||||
CompositorNodeImage.layer -> layer: enum 'NO DESCRIPTION'
|
||||
CompositorNodeImage.offset -> offset: int 'Offsets the number of the frame to use in the animation'
|
||||
CompositorNodeImage.start -> start: int 'NO DESCRIPTION'
|
||||
CompositorNodeInvert.alpha -> invert_alpha: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeInvert.rgb -> invert_rgb: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeLensdist.fit -> use_fit: boolean 'For positive distortion factor only: scale image such that black areas are not visible'
|
||||
CompositorNodeLensdist.jitter -> use_jitter: boolean 'Enable/disable jittering; faster, but also noisier'
|
||||
CompositorNodeLensdist.projector -> use_projector: boolean 'Enable/disable projector mode. Effect is applied in horizontal direction only'
|
||||
CompositorNodeLevels.channel -> channel: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
CompositorNodeMapValue.max -> max: float 'NO DESCRIPTION'
|
||||
CompositorNodeMapValue.min -> min: float 'NO DESCRIPTION'
|
||||
CompositorNodeMapValue.offset -> offset: float 'NO DESCRIPTION'
|
||||
CompositorNodeMapValue.size -> size: float 'NO DESCRIPTION'
|
||||
CompositorNodeMapValue.use_max -> use_max: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeMapValue.use_min -> use_min: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeMath.operation -> operation: enum 'NO DESCRIPTION'
|
||||
CompositorNodeMixRGB.alpha -> use_alpha: boolean 'Include alpha of second input in this operation'
|
||||
CompositorNodeMixRGB.blend_type -> blend_type: enum 'NO DESCRIPTION'
|
||||
CompositorNodeOutputFile.exr_codec -> exr_codec: enum 'NO DESCRIPTION'
|
||||
CompositorNodeOutputFile.exr_half -> use_exr_half: boolean 'NO DESCRIPTION'
|
||||
CompositorNodeOutputFile.filepath -> filepath: string 'Output path for the image, same functionality as render output.'
|
||||
CompositorNodeOutputFile.frame_end -> frame_end: int 'NO DESCRIPTION'
|
||||
CompositorNodeOutputFile.frame_start -> frame_start: int 'NO DESCRIPTION'
|
||||
CompositorNodeOutputFile.image_type -> image_type: enum 'NO DESCRIPTION'
|
||||
CompositorNodeOutputFile.quality -> quality: int 'NO DESCRIPTION'
|
||||
CompositorNodePremulKey.mapping -> mapping: enum 'Conversion between premultiplied alpha and key alpha'
|
||||
CompositorNodeRLayers.layer -> layer: enum 'NO DESCRIPTION'
|
||||
CompositorNodeRLayers.scene -> scene: pointer 'NO DESCRIPTION'
|
||||
CompositorNodeRotate.filter -> filter: enum 'Method to use to filter rotation'
|
||||
CompositorNodeScale.space -> space: enum 'Coordinate space to scale relative to'
|
||||
CompositorNodeSplitViewer.axis -> axis: enum 'NO DESCRIPTION'
|
||||
CompositorNodeSplitViewer.factor -> factor: int 'NO DESCRIPTION'
|
||||
CompositorNodeTexture.node_output -> node_output: int 'For node-based textures, which output node to use'
|
||||
CompositorNodeTexture.texture -> texture: pointer 'NO DESCRIPTION'
|
||||
CompositorNodeTime.curve -> curve: pointer, '(read-only)'
|
||||
CompositorNodeTime.end -> end: int 'NO DESCRIPTION'
|
||||
CompositorNodeTime.start -> start: int 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
CompositorNodeValToRGB.color_ramp -> color_ramp: pointer, '(read-only)'
|
||||
CompositorNodeVecBlur.curved -> use_curved: boolean 'Interpolate between frames in a bezier curve, rather than linearly'
|
||||
CompositorNodeVecBlur.factor -> factor: float "Scaling factor for motion vectors; actually 'shutter speed' in frames"
|
||||
CompositorNodeVecBlur.max_speed -> speed_max: int 'Maximum speed, or zero for none'
|
||||
CompositorNodeVecBlur.min_speed -> speed_min: int 'Minimum speed for a pixel to be blurred; used to separate background from foreground'
|
||||
CompositorNodeVecBlur.samples -> samples: int 'NO DESCRIPTION'
|
||||
ConsoleLine.current_character -> current_character: int 'NO DESCRIPTION'
|
||||
ConsoleLine.line -> line: string 'Text in the line'
|
||||
Constraint.active -> active: boolean 'Constraint is the one being edited'
|
||||
Constraint.disabled -> is_valid: boolean, '(read-only) Constraint has invalid settings and will not be evaluated'
|
||||
Constraint.enabled -> enabled: boolean 'Enable/Disable Constraint'
|
||||
Constraint.expanded -> show_expanded: boolean "Constraint's panel is expanded in UI"
|
||||
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.proxy_local -> is_proxy_local: boolean 'Constraint was added in this proxy instance (i.e. did not belong to source Armature)'
|
||||
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.detect_material -> use_material_detect: boolean 'Detect material instead of property'
|
||||
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.fh_normal -> use_fh_normal: boolean 'Add a horizontal spring force on slopes'
|
||||
ConstraintActuator.fh_paralel_axis -> use_fh_paralel_axis: boolean 'Keep object axis parallel to normal'
|
||||
ConstraintActuator.force_distance -> use_force_distance: boolean 'Force distance of object to point of impact of ray'
|
||||
ConstraintActuator.limit -> limit: enum 'NO DESCRIPTION'
|
||||
ConstraintActuator.limit_max -> limit_max: float 'NO DESCRIPTION'
|
||||
ConstraintActuator.limit_min -> limit_min: float 'NO DESCRIPTION'
|
||||
ConstraintActuator.local -> use_local: boolean "Set ray along object's axis or global axis"
|
||||
ConstraintActuator.material -> material: string 'Ray detects only Objects with this material'
|
||||
ConstraintActuator.max_angle -> angle_max: 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 -> rotation_max: float 'Reference Direction'
|
||||
ConstraintActuator.min_angle -> angle_min: 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.normal -> use_normal: boolean 'Set object axis along (local axis) or parallel (global axis) to the normal at hit position'
|
||||
ConstraintActuator.persistent -> use_persistent: boolean 'Persistent actuator: stays active even if ray does not reach target'
|
||||
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 'NO DESCRIPTION'
|
||||
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.region_data -> region_data: 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.active -> use: boolean 'Object contributes to the fluid simulation'
|
||||
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.reverse_frames -> use_reverse_frames: boolean 'Reverse control object movement'
|
||||
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.expanded -> show_expanded: boolean 'Set controller expanded in the user interface'
|
||||
Controller.name -> name: string 'NO DESCRIPTION'
|
||||
Controller.priority -> use_priority: boolean 'Mark controller for execution before all non-marked controllers (good for startup scripts)'
|
||||
Controller.state -> states: boolean, '(read-only) Set Controller state index (1 to 30)'
|
||||
Controller.type -> type: enum 'NO DESCRIPTION'
|
||||
CopyLocationConstraint.head_tail -> head_tail: float 'Target along length of bone: Head=0, Tail=1'
|
||||
CopyLocationConstraint.invert_x -> invert_x: boolean 'Invert the X location'
|
||||
CopyLocationConstraint.invert_y -> invert_y: boolean 'Invert the Y location'
|
||||
CopyLocationConstraint.invert_z -> invert_z: boolean 'Invert the Z location'
|
||||
CopyLocationConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
CopyLocationConstraint.target -> target: pointer 'Target Object'
|
||||
CopyLocationConstraint.use_offset -> use_offset: boolean 'Add original location into copied location'
|
||||
CopyLocationConstraint.use_x -> use_x: boolean "Copy the target's X location"
|
||||
CopyLocationConstraint.use_y -> use_y: boolean "Copy the target's Y location"
|
||||
CopyLocationConstraint.use_z -> use_z: boolean "Copy the target's Z location"
|
||||
CopyRotationConstraint.invert_x -> invert_x: boolean 'Invert the X rotation'
|
||||
CopyRotationConstraint.invert_y -> invert_y: boolean 'Invert the Y rotation'
|
||||
CopyRotationConstraint.invert_z -> invert_z: boolean 'Invert the Z rotation'
|
||||
CopyRotationConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
CopyRotationConstraint.target -> target: pointer 'Target Object'
|
||||
CopyRotationConstraint.use_offset -> use_offset: boolean 'Add original rotation into copied rotation'
|
||||
CopyRotationConstraint.use_x -> use_x: boolean "Copy the target's X rotation"
|
||||
CopyRotationConstraint.use_y -> use_y: boolean "Copy the target's Y rotation"
|
||||
CopyRotationConstraint.use_z -> use_z: boolean "Copy the target's Z rotation"
|
||||
CopyScaleConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
CopyScaleConstraint.target -> target: pointer 'Target Object'
|
||||
CopyScaleConstraint.use_offset -> use_offset: boolean 'Add original scale into copied scale'
|
||||
CopyScaleConstraint.use_x -> use_x: boolean "Copy the target's X scale"
|
||||
CopyScaleConstraint.use_y -> use_y: boolean "Copy the target's Y scale"
|
||||
CopyScaleConstraint.use_z -> use_z: boolean "Copy the target's Z scale"
|
||||
CopyTransformsConstraint.head_tail -> head_tail: float 'Target along length of bone: Head=0, Tail=1'
|
||||
CopyTransformsConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
CopyTransformsConstraint.target -> target: pointer 'Target Object'
|
||||
Curve.animation_data -> animation_data: pointer, '(read-only) Animation data for this datablock'
|
||||
Curve.auto_texspace -> use_auto_texspace: boolean "Adjusts active object's texture space automatically when transforming object"
|
||||
Curve.back -> use_fill_back: boolean 'Draw filled back for extruded/beveled curves'
|
||||
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.draw_handles -> show_handles: boolean 'Display bezier handles in editmode'
|
||||
Curve.draw_normals -> show_normals: boolean 'Display 3D curve normals in editmode'
|
||||
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.front -> use_fill_front: boolean 'Draw filled front for extruded/beveled curves'
|
||||
Curve.map_along_length -> use_map_along_length: boolean 'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'
|
||||
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.use_deform_bounds -> use_deform_bounds: boolean 'Use the mesh bounds to clamp the deformation'
|
||||
Curve.use_deform_fill -> use_fill_deform: boolean 'Fill curve after applying deformation'
|
||||
Curve.use_path -> use_path: boolean 'Enable the curve to become a translation path'
|
||||
Curve.use_path_follow -> use_path_follow: boolean 'Make curve path children to rotate along the path'
|
||||
Curve.use_radius -> use_radius: boolean 'Option for paths: apply the curve radius with path following it and deforming'
|
||||
Curve.use_stretch -> use_stretch: boolean 'Option for curve-deform: makes deformed child to stretch along entire path'
|
||||
Curve.use_time_offset -> use_time_offset: boolean 'Children will use Time Offset value as path distance offset'
|
||||
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'
|
||||
CurveMapPoint.select -> select: boolean 'Selection state of the curve point'
|
||||
CurveMapping.black_level -> black_level: float 'For RGB curves, the color that black is mapped to'
|
||||
CurveMapping.clip -> use_clip: boolean 'Force the curve view to fit a defined boundary'
|
||||
CurveMapping.clip_max_x -> clip_max_x: float 'NO DESCRIPTION'
|
||||
CurveMapping.clip_max_y -> clip_max_y: float 'NO DESCRIPTION'
|
||||
CurveMapping.clip_min_x -> clip_min_x: float 'NO DESCRIPTION'
|
||||
CurveMapping.clip_min_y -> clip_min_y: float 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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'
|
||||
DelaySensor.repeat -> use_repeat: boolean 'Toggle repeat option. If selected, the sensor restarts after Delay+Dur logic tics'
|
||||
DisplaceModifier.direction -> direction: enum 'NO DESCRIPTION'
|
||||
DisplaceModifier.midlevel -> midlevel: float 'Material value that gives no displacement'
|
||||
DisplaceModifier.strength -> strength: float 'NO DESCRIPTION'
|
||||
DisplaceModifier.texture -> texture: pointer 'NO DESCRIPTION'
|
||||
DisplaceModifier.texture_coordinate_object -> texture_coordinate_object: pointer 'NO DESCRIPTION'
|
||||
DisplaceModifier.texture_coordinates -> texture_coordinates: enum 'NO DESCRIPTION'
|
||||
DisplaceModifier.uv_layer -> uv_layer: string 'UV layer name'
|
||||
DisplaceModifier.vertex_group -> vertex_group: string 'Vertex group name'
|
||||
DistortedNoiseTexture.distortion -> distortion: float 'NO DESCRIPTION'
|
||||
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.generate_speed_vectors -> use_speed_vectors: boolean 'Generate speed vectors for vector blur'
|
||||
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.override_time -> use_time_override: boolean "Use a custom start and end time (in seconds) instead of the scene's timeline"
|
||||
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.reverse_frames -> use_reverse_frames: boolean 'Reverse fluid frames'
|
||||
DomainFluidSettings.slip_type -> slip_type: enum 'NO DESCRIPTION'
|
||||
DomainFluidSettings.start_time -> start_time: float 'Simulation time of the first blender frame'
|
||||
DomainFluidSettings.surface_smoothing -> surface_smooth: 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'
|
||||
NEGATE * DopeSheet.collapse_summary -> show_expanded_summary: boolean 'Collapse summary when shown, so all other channels get hidden. (DopeSheet Editors Only)'
|
||||
DopeSheet.display_armature -> show_armatures: boolean 'Include visualization of Armature related Animation data'
|
||||
DopeSheet.display_camera -> show_cameras: boolean 'Include visualization of Camera related Animation data'
|
||||
DopeSheet.display_curve -> show_curves: boolean 'Include visualization of Curve related Animation data'
|
||||
DopeSheet.display_hidden -> display_hidden: boolean "Include channels from objects/bone that aren't visible"
|
||||
DopeSheet.display_lamp -> show_lamps: boolean 'Include visualization of Lamp related Animation data'
|
||||
DopeSheet.display_material -> show_materials: boolean 'Include visualization of Material related Animation data'
|
||||
DopeSheet.display_mesh -> show_meshes: boolean 'Include visualization of Mesh related Animation data'
|
||||
DopeSheet.display_metaball -> show_metaballs: boolean 'Include visualization of Metaball related Animation data'
|
||||
DopeSheet.display_node -> show_nodes: boolean 'Include visualization of Node related Animation data'
|
||||
DopeSheet.display_particle -> show_particles: boolean 'Include visualization of Particle related Animation data'
|
||||
DopeSheet.display_scene -> show_scenes: boolean 'Include visualization of Scene related Animation data'
|
||||
DopeSheet.display_shapekeys -> show_shapekeys: boolean 'Include visualization of ShapeKey related Animation data'
|
||||
DopeSheet.display_summary -> show_summary: boolean "Display an additional 'summary' line. (DopeSheet Editors only)"
|
||||
DopeSheet.display_texture -> show_textures: boolean 'Include visualization of Texture related Animation data'
|
||||
DopeSheet.display_transforms -> show_transforms: boolean 'Include visualization of Object-level Animation data (mostly Transforms)'
|
||||
DopeSheet.display_world -> show_worlds: boolean 'Include visualization of World related Animation data'
|
||||
DopeSheet.filtering_group -> filtering_group: pointer 'Group that included Object should be a member of'
|
||||
DopeSheet.include_missing_nla -> show_missing_nla: boolean 'Include Animation Data blocks with no NLA data. (NLA Editor only)'
|
||||
DopeSheet.only_group_objects -> show_only_group_objects: boolean 'Only include channels from Objects in the specified Group'
|
||||
DopeSheet.only_selected -> show_only_selected: boolean 'Only include channels relating to selected objects and data'
|
||||
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.invalid -> is_valid: boolean 'Driver could not be evaluated in past, so should be skipped'
|
||||
Driver.show_debug_info -> show_debug_info: boolean 'Show intermediate values for the driver calculations to allow debugging of drivers'
|
||||
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'
|
||||
DriverTarget.use_local_space_transforms -> use_local_space_transform: boolean 'Use transforms in Local Space (as opposed to the worldspace default)'
|
||||
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'
|
||||
EdgeSplitModifier.use_edge_angle -> use_edge_angle: boolean 'Split edges with high angle between faces'
|
||||
EdgeSplitModifier.use_sharp -> use_edge_sharp: boolean 'Split edges that are marked as sharp'
|
||||
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.connected -> use_connect: boolean "When bone has a parent, bone's head is struck to the parent's tail"
|
||||
EditBone.cyclic_offset -> use_cyclic_offset: boolean "When bone doesn't have a parent, it receives cyclic offset effects"
|
||||
EditBone.deform -> use_deform: boolean 'Bone does not deform any geometry'
|
||||
EditBone.draw_wire -> show_wire: boolean 'Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes'
|
||||
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.hide -> hide: boolean 'Bone is not visible when in Edit Mode'
|
||||
EditBone.hide_select -> hide_select: boolean 'Bone is able to be selected'
|
||||
EditBone.hinge -> use_hinge: boolean 'Bone inherits rotation or scale from parent bone'
|
||||
EditBone.inherit_scale -> use_inherit_scale: boolean 'Bone inherits scaling from parent bone'
|
||||
EditBone.layer -> layers: boolean 'Layers bone exists in'
|
||||
EditBone.local_location -> use_local_location: boolean 'Bone location is set in local space'
|
||||
EditBone.lock -> lock: boolean 'Bone is not able to be transformed when in Edit Mode'
|
||||
EditBone.matrix -> matrix: float, '(read-only) Read-only matrix calculated from the roll (armature space)'
|
||||
EditBone.multiply_vertexgroup_with_envelope -> use_envelope_multiply: boolean 'When deforming bone, multiply effects of Vertex Group weights with Envelope influence'
|
||||
EditBone.name -> name: string 'NO DESCRIPTION'
|
||||
EditBone.parent -> parent: pointer 'Parent edit bone (in same Armature)'
|
||||
EditBone.roll -> roll: float 'Bone rotation around head-tail axis'
|
||||
EditBone.select -> select: boolean 'NO DESCRIPTION'
|
||||
EditBone.select_head -> select_head: boolean 'NO DESCRIPTION'
|
||||
EditBone.select_tail -> select_tail: boolean 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
EditObjectActuator.enable_3d_tracking -> use_3d_tracking: boolean 'Enable 3D tracking'
|
||||
EditObjectActuator.linear_velocity -> linear_velocity: float 'Velocity upon creation'
|
||||
EditObjectActuator.local_angular_velocity -> use_local_angular_velocity: boolean 'Apply the rotation locally'
|
||||
EditObjectActuator.local_linear_velocity -> use_local_linear_velocity: boolean 'Apply the transformation locally'
|
||||
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.replace_display_mesh -> use_replace_display_mesh: boolean 'Replace the display mesh'
|
||||
EditObjectActuator.replace_physics_mesh -> use_replace_physics_mesh: boolean 'Replace the physics mesh (triangle bounds only - compound shapes not supported)'
|
||||
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.color_saturation -> color_saturation: float 'NO DESCRIPTION'
|
||||
EffectSequence.convert_float -> use_float: boolean 'Convert input to float data'
|
||||
EffectSequence.crop -> crop: pointer, '(read-only)'
|
||||
EffectSequence.de_interlace -> use_deinterlace: boolean 'For video movies to remove fields'
|
||||
EffectSequence.flip_x -> use_flip_x: boolean 'Flip on the X axis'
|
||||
EffectSequence.flip_y -> use_flip_y: boolean 'Flip on the Y axis'
|
||||
EffectSequence.multiply_colors -> color_multiply: float 'NO DESCRIPTION'
|
||||
EffectSequence.premultiply -> use_premultiply: boolean 'Convert RGB from key alpha to premultiplied alpha'
|
||||
EffectSequence.proxy -> proxy: pointer, '(read-only)'
|
||||
EffectSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean 'Use a custom directory to store data'
|
||||
EffectSequence.proxy_custom_file -> use_proxy_custom_file: boolean 'Use a custom file to read proxy data from'
|
||||
EffectSequence.reverse_frames -> use_reverse_frames: boolean 'Reverse frame order'
|
||||
EffectSequence.strobe -> strobe: float 'Only display every nth frame'
|
||||
EffectSequence.transform -> transform: pointer, '(read-only)'
|
||||
EffectSequence.use_color_balance -> use_color_balance: boolean '(3-Way color correction) on input'
|
||||
EffectSequence.use_crop -> use_crop: boolean 'Crop image before processing'
|
||||
EffectSequence.use_proxy -> use_proxy: boolean 'Use a preview proxy for this strip'
|
||||
EffectSequence.use_translation -> use_translation: boolean 'Translate image before processing'
|
||||
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.do_growing_hair -> apply_to_hair_growing: boolean 'Use force fields when growing hair'
|
||||
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.ignore_layers -> layers_ignore: boolean 'Hide objects on these layers when generating the Environment Map'
|
||||
EnvironmentMap.mapping -> mapping: enum 'NO DESCRIPTION'
|
||||
EnvironmentMap.resolution -> resolution: int 'Pixel resolution of the rendered environment map'
|
||||
EnvironmentMap.source -> source: enum 'NO DESCRIPTION'
|
||||
EnvironmentMap.viewpoint_object -> viewpoint_object: pointer "Object to use as the environment map's viewpoint location"
|
||||
EnvironmentMap.zoom -> zoom: float 'NO DESCRIPTION'
|
||||
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.filter_size_minimum -> use_filter_size_min: boolean 'Use Filter Size as a minimal filter value in pixels'
|
||||
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'
|
||||
EnvironmentMapTexture.mipmap -> use_mipmap: boolean 'Uses auto-generated MIP maps for the image'
|
||||
EnvironmentMapTexture.mipmap_gauss -> use_mipmap_gauss: boolean 'Uses Gauss filter to sample down MIP maps'
|
||||
Event.alt -> is_pressed_alt: boolean, '(read-only) True when the Alt/Option key is held'
|
||||
Event.ascii -> ascii: string, '(read-only) Single ASCII character for this event'
|
||||
Event.ctrl -> is_pressed_ctrl: boolean, '(read-only) True when the Ctrl key is held'
|
||||
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.oskey -> is_pressed_cmd: boolean, '(read-only) True when the Cmd key is held'
|
||||
Event.shift -> is_pressed_shift: boolean, '(read-only) True when the Shift key is held'
|
||||
Event.type -> type: enum, '(read-only)'
|
||||
Event.value -> value: enum, '(read-only) The type of event, only applies to some'
|
||||
ExplodeModifier.alive -> show_alive: boolean 'Show mesh when particles are alive'
|
||||
ExplodeModifier.dead -> show_dead: boolean 'Show mesh when particles are dead'
|
||||
ExplodeModifier.protect -> protect: float 'Clean vertex group edges'
|
||||
ExplodeModifier.size -> use_size: boolean 'Use particle size for the shrapnel'
|
||||
ExplodeModifier.split_edges -> use_edge_split: boolean 'Split face edges for nicer shrapnel'
|
||||
ExplodeModifier.unborn -> show_unborn: boolean 'Show mesh when particles are unborn'
|
||||
ExplodeModifier.vertex_group -> vertex_group: string 'NO DESCRIPTION'
|
||||
ExpressionController.expression -> expression: string 'NO DESCRIPTION'
|
||||
FCurve.array_index -> array_index: int 'Index to the specific property affected by F-Curve if applicable'
|
||||
FCurve.auto_clamped_handles -> use_auto_handle_clamp: boolean 'All auto-handles for F-Curve are clamped'
|
||||
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.enabled -> enabled: boolean 'False when F-Curve could not be evaluated in past, so should be skipped when evaluating'
|
||||
FCurve.extrapolation -> extrapolation: enum 'NO DESCRIPTION'
|
||||
FCurve.group -> group: pointer 'Action Group that this F-Curve belongs to'
|
||||
FCurve.hide -> hide: boolean 'F-Curve and its keyframes are hidden in the Graph Editor graphs'
|
||||
FCurve.keyframe_points -> keyframe_points: collection, '(read-only) User-editable keyframes'
|
||||
FCurve.lock -> lock: boolean "F-Curve's settings cannot be edited"
|
||||
FCurve.modifiers -> modifiers: collection, '(read-only) Modifiers affecting the shape of the F-Curve'
|
||||
FCurve.mute -> mute: boolean 'F-Curve is not evaluated'
|
||||
FCurve.sampled_points -> sampled_points: collection, '(read-only) Sampled animation data'
|
||||
FCurve.select -> select: boolean 'F-Curve is selected for editing'
|
||||
FCurveModifiers.active -> active: pointer 'Active F-Curve Modifier'
|
||||
FCurveSample.co -> co: float 'Point coordinates'
|
||||
FCurveSample.select -> select: boolean 'Selection status'
|
||||
FModifier.active -> active: boolean 'F-Curve Modifier is the one being edited'
|
||||
NEGATE * FModifier.disabled -> use: boolean, '(read-only) F-Curve Modifier has invalid settings and will not be evaluated'
|
||||
FModifier.expanded -> show_expanded: boolean "F-Curve Modifier's panel is expanded in UI"
|
||||
FModifier.mute -> mute: boolean 'F-Curve Modifier will not be evaluated'
|
||||
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_max: float 'Upper distance from Reference Value for 1:1 default influence'
|
||||
FModifierEnvelope.default_minimum -> default_min: 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 -> max: float 'Upper bound of envelope at this control-point'
|
||||
FModifierEnvelopeControlPoint.minimum -> min: float 'Lower bound of envelope at this control-point'
|
||||
FModifierFunctionGenerator.additive -> use_additive: boolean 'Values generated by this modifier are applied on top of the existing values instead of overwriting them'
|
||||
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.additive -> use_additive: boolean 'Values generated by this modifier are applied on top of the existing values instead of overwriting them'
|
||||
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 -> max_x: float 'Highest X value to allow'
|
||||
FModifierLimits.maximum_y -> max_y: float 'Highest Y value to allow'
|
||||
FModifierLimits.minimum_x -> min_x: float 'Lowest X value to allow'
|
||||
FModifierLimits.minimum_y -> min_y: float 'Lowest Y value to allow'
|
||||
FModifierLimits.use_maximum_x -> use_max_x: boolean 'Use the maximum X value'
|
||||
FModifierLimits.use_maximum_y -> use_max_y: boolean 'Use the maximum Y value'
|
||||
FModifierLimits.use_minimum_x -> use_min_x: boolean 'Use the minimum X value'
|
||||
FModifierLimits.use_minimum_y -> use_min_y: boolean 'Use the minimum Y value'
|
||||
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'
|
||||
FModifierStepped.use_frame_end -> use_frame_end: boolean "Restrict modifier to only act before its 'end' frame"
|
||||
FModifierStepped.use_frame_start -> use_frame_start: boolean "Restrict modifier to only act after its 'start' frame"
|
||||
FcurveActuator.add -> use_add: boolean 'F-Curve is added to the current loc/rot/scale in global or local coordinate according to Local flag'
|
||||
FcurveActuator.child -> apply_to_children: boolean 'Update F-Curve on all children Objects as well'
|
||||
FcurveActuator.force -> use_force: boolean 'Apply F-Curve as a global or local force depending on the local option (dynamic objects only)'
|
||||
FcurveActuator.frame_end -> frame_end: int 'NO DESCRIPTION'
|
||||
FcurveActuator.frame_property -> frame_property: string "Assign the action's current frame number to this property"
|
||||
FcurveActuator.frame_start -> frame_start: int 'NO DESCRIPTION'
|
||||
FcurveActuator.local -> use_local: boolean 'Let the F-Curve act in local coordinates, used in Force and Add mode'
|
||||
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.do_absorption -> use_absorption: boolean 'Force gets absorbed by collision objects'
|
||||
FieldSettings.do_location -> apply_to_location: boolean "Effect particles' location"
|
||||
FieldSettings.do_rotation -> apply_to_rotation: boolean "Effect particles' dynamic rotation"
|
||||
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.force_2d -> use_2d_force: boolean 'Apply force only in 2d'
|
||||
FieldSettings.global_coordinates -> use_global_coordinates: boolean 'Use effector/global coordinates for turbulence'
|
||||
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.guide_path_add -> use_guide_path_add: boolean 'Based on distance/falloff it adds a portion of the entire path'
|
||||
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 -> distance_max: float 'Maximum distance for the field to work'
|
||||
FieldSettings.minimum_distance -> distance_min: float "Minimum distance for the field's fall-off"
|
||||
FieldSettings.multiple_springs -> use_multiple_springs: boolean 'Every point is effected by multiple springs'
|
||||
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_max: float 'Maximum radial distance for the field to work'
|
||||
FieldSettings.radial_minimum -> radial_min: float "Minimum radial distance for the field's fall-off"
|
||||
FieldSettings.rest_length -> rest_length: float 'Rest length of the harmonic force'
|
||||
FieldSettings.root_coordinates -> use_root_coordinates: boolean 'Texture coordinates from root particle locations'
|
||||
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.use_coordinates -> use_object_coordinates: boolean 'Use object/global coordinates for texture'
|
||||
FieldSettings.use_guide_path_weight -> use_guide_path_weight: boolean 'Use curve weights to influence the particle influence along the curve'
|
||||
FieldSettings.use_max_distance -> use_max_distance: boolean 'Use a maximum distance for the field to work'
|
||||
FieldSettings.use_min_distance -> use_min_distance: boolean "Use a minimum distance for the field's fall-off"
|
||||
FieldSettings.use_radial_max -> use_radial_max: boolean 'Use a maximum radial distance for the field to work'
|
||||
FieldSettings.use_radial_min -> use_radial_min: boolean "Use a minimum radial distance for the field's fall-off"
|
||||
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.do_filter -> use_filter: boolean 'Enable filtering of files'
|
||||
FileSelectParams.file -> file: string 'Active file in the file browser'
|
||||
FileSelectParams.filter_blender -> use_filter_blender: boolean 'Show .blend files'
|
||||
FileSelectParams.filter_folder -> use_filter_folder: boolean 'Show folders'
|
||||
FileSelectParams.filter_font -> use_filter_font: boolean 'Show font files'
|
||||
FileSelectParams.filter_image -> use_filter_image: boolean 'Show image files'
|
||||
FileSelectParams.filter_movie -> use_filter_movie: boolean 'Show movie files'
|
||||
FileSelectParams.filter_script -> use_filter_script: boolean 'Show script files'
|
||||
FileSelectParams.filter_sound -> use_filter_sound: boolean 'Show sound files'
|
||||
FileSelectParams.filter_text -> use_filter_text: boolean 'Show text files'
|
||||
NEGATE * FileSelectParams.hide_dot -> show_hidden: boolean 'Hide hidden dot files'
|
||||
FileSelectParams.sort -> sort: enum 'NO DESCRIPTION'
|
||||
FileSelectParams.title -> title: string, '(read-only) Title for the file browser'
|
||||
Filter2DActuator.enable_motion_blur -> use_motion_blur: boolean 'Enable/Disable Motion Blur'
|
||||
Filter2DActuator.filter_pass -> filter_pass: int 'Set filter order'
|
||||
Filter2DActuator.glsl_shader -> glsl_shader: pointer 'NO DESCRIPTION'
|
||||
Filter2DActuator.mode -> mode: enum 'NO DESCRIPTION'
|
||||
Filter2DActuator.motion_blur_factor -> motion_blur_factor: float 'Set motion blur factor'
|
||||
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.sticky -> use_sticky: boolean 'Immobilize object while constrained'
|
||||
FloorConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
FloorConstraint.target -> target: pointer 'Target Object'
|
||||
FloorConstraint.use_rotation -> use_rotation: boolean "Use the target's rotation to determine floor"
|
||||
FluidFluidSettings.active -> use: boolean 'Object contributes to the fluid simulation'
|
||||
FluidFluidSettings.export_animated_mesh -> use_animated_mesh: boolean 'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
|
||||
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'
|
||||
FollowPathConstraint.use_curve_follow -> use_curve_follow: boolean 'Object will follow the heading and banking of the curve'
|
||||
FollowPathConstraint.use_curve_radius -> use_curve_radius: boolean 'Objects scale by the curve radius'
|
||||
FollowPathConstraint.use_fixed_position -> use_fixed_location: boolean 'Object will stay locked to a single point somewhere along the length of the curve regardless of time'
|
||||
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'
|
||||
Function.registered -> is_registered: boolean, '(read-only) Function is registered as callback as part of type registration'
|
||||
Function.registered_optional -> is_registered_optional: boolean, '(read-only) Function is optionally registered as callback part of type registration'
|
||||
GPencilFrame.frame_number -> frame_number: int 'The frame on which this sketch appears'
|
||||
GPencilFrame.paint_lock -> is_edited: boolean 'Frame is being edited (painted on)'
|
||||
GPencilFrame.select -> select: boolean 'Frame is selected for editing in the DopeSheet'
|
||||
GPencilFrame.strokes -> strokes: collection, '(read-only) Freehand curves defining the sketch on this frame'
|
||||
GPencilLayer.active -> active: boolean 'Set active layer for editing'
|
||||
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.frame_lock -> lock_frame: boolean 'Lock current frame displayed by layer'
|
||||
GPencilLayer.frames -> frames: collection, '(read-only) Sketches for this layer on different frames'
|
||||
GPencilLayer.hide -> hide: boolean 'Set layer Visibility'
|
||||
GPencilLayer.info -> info: string 'Layer name'
|
||||
GPencilLayer.line_thickness -> line_width: int 'Thickness of strokes (in pixels)'
|
||||
GPencilLayer.lock -> lock: boolean 'Protect layer from further editing and/or frame changes'
|
||||
GPencilLayer.max_ghost_range -> ghost_range_max: 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'
|
||||
GPencilLayer.select -> select: boolean 'Layer is selected for editing in the DopeSheet'
|
||||
GPencilLayer.show_points -> show_points: boolean 'Draw the points which make up the strokes (for debugging purposes)'
|
||||
GPencilLayer.use_onion_skinning -> use_onion_skinning: boolean 'Ghost frames on either side of frame'
|
||||
GPencilStroke.points -> points: collection, '(read-only) Stroke data points'
|
||||
GPencilStrokePoint.co -> co: float 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
GameBooleanProperty.value -> value: boolean 'Property value'
|
||||
GameFloatProperty.value -> value: float 'Property value'
|
||||
GameIntProperty.value -> value: int 'Property value'
|
||||
GameObjectSettings.actor -> use_actor: boolean 'Object is detected by the Near and Radar sensor'
|
||||
GameObjectSettings.actuators -> actuators: collection, '(read-only) Game engine actuators to act on events'
|
||||
GameObjectSettings.all_states -> use_all_states: boolean 'Set all state bits'
|
||||
GameObjectSettings.anisotropic_friction -> use_anisotropic_friction: boolean 'Enable anisotropic friction'
|
||||
GameObjectSettings.collision_bounds -> collision_bounds: enum 'Selects the collision type'
|
||||
GameObjectSettings.collision_compound -> use_collision_compound: boolean 'Add children to form a compound collision object'
|
||||
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.debug_state -> show_debug_state: boolean 'Print state debug info in the game engine'
|
||||
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.ghost -> use_ghost: boolean 'Object does not restitute collisions, like a ghost'
|
||||
GameObjectSettings.initial_state -> states_initial: boolean 'Initial state when the game starts'
|
||||
GameObjectSettings.lock_x_axis -> lock_location_x: boolean 'Disable simulation of linear motion along the X axis'
|
||||
GameObjectSettings.lock_x_rot_axis -> lock_rotation_x: boolean 'Disable simulation of angular motion along the X axis'
|
||||
GameObjectSettings.lock_y_axis -> lock_location_y: boolean 'Disable simulation of linear motion along the Y axis'
|
||||
GameObjectSettings.lock_y_rot_axis -> lock_rotation_y: boolean 'Disable simulation of angular motion along the Y axis'
|
||||
GameObjectSettings.lock_z_axis -> lock_location_z: boolean 'Disable simulation of linear motion along the Z axis'
|
||||
GameObjectSettings.lock_z_rot_axis -> lock_rotation_z: boolean 'Disable simulation of angular motion along the Z axis'
|
||||
GameObjectSettings.mass -> mass: float 'Mass of the object'
|
||||
GameObjectSettings.material_physics -> use_material_physics: boolean 'Use physics settings in materials'
|
||||
GameObjectSettings.maximum_velocity -> velocity_max: float 'Clamp velocity to this maximum speed'
|
||||
GameObjectSettings.minimum_velocity -> velocity_min: float 'Clamp velocity to this minimum speed (except when totally still)'
|
||||
NEGATE * GameObjectSettings.no_sleeping -> use_sleep: boolean 'Disable auto (de)activation in physics simulation'
|
||||
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.rotate_from_normal -> use_rotate_from_normal: boolean 'Use face normal to rotate object, so that it points away from the surface'
|
||||
GameObjectSettings.rotation_damping -> rotation_damping: float 'General rotation damping'
|
||||
GameObjectSettings.sensors -> sensors: collection, '(read-only) Game engine sensor to detect events'
|
||||
GameObjectSettings.show_actuators -> show_actuators: boolean 'Shows actuators for this object in the user interface'
|
||||
GameObjectSettings.show_controllers -> show_controllers: boolean 'Shows controllers for this object in the user interface'
|
||||
GameObjectSettings.show_sensors -> show_sensors: boolean 'Shows sensors for this object in the user interface'
|
||||
GameObjectSettings.show_state_panel -> show_state_panel: boolean 'Show state panel'
|
||||
GameObjectSettings.soft_body -> soft_body: pointer, '(read-only) Settings for Bullet soft body simulation'
|
||||
GameObjectSettings.use_activity_culling -> use_activity_culling: boolean 'Disable simulation of angular motion along the Z axis'
|
||||
GameObjectSettings.use_collision_bounds -> use_collision_bounds: boolean 'Specify a collision bounds type other than the default'
|
||||
GameObjectSettings.used_state -> states_used: boolean, '(read-only) States which are being used by controllers'
|
||||
GameObjectSettings.visible_state -> states_visible: boolean 'State determining which controllers are displayed'
|
||||
GameProperty.debug -> show_debug: boolean 'Print debug information for this property'
|
||||
GameProperty.name -> name: string "Available as GameObject attributes in the game engine's python API"
|
||||
GameProperty.type -> type: enum 'NO DESCRIPTION'
|
||||
GameSoftBodySettings.bending_const -> use_bending_constraints: boolean 'Enable bending constraints'
|
||||
GameSoftBodySettings.cluster_iterations -> cluster_iterations: int 'Specify the number of cluster iterations'
|
||||
GameSoftBodySettings.cluster_rigid_to_softbody -> use_cluster_rigid_to_softbody: boolean 'Enable cluster collision between soft and rigid body'
|
||||
GameSoftBodySettings.cluster_soft_to_softbody -> use_cluster_soft_to_softbody: boolean 'Enable cluster collision between soft and soft body'
|
||||
GameSoftBodySettings.dynamic_friction -> dynamic_friction: float 'Dynamic Friction'
|
||||
GameSoftBodySettings.linstiff -> linear_stiffness: 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.shape_match -> use_shape_match: boolean 'Enable soft body shape matching goal'
|
||||
GameSoftBodySettings.threshold -> threshold: float 'Shape matching threshold'
|
||||
GameSoftBodySettings.welding -> weld_threshold: 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.only_boost -> use_only_boost: boolean 'Show the glow buffer only'
|
||||
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 'NO DESCRIPTION'
|
||||
GreasePencil.layers -> layers: collection, '(read-only)'
|
||||
GreasePencil.use_stroke_endpoints -> use_stroke_endpoints: boolean 'Only use the first and last parts of the stroke for snapping'
|
||||
Group.dupli_offset -> dupli_offset: float 'Offset from the origin to use when instancing as DupliGroup'
|
||||
Group.layer -> layers: boolean 'Layers visible when this groups is instanced as a dupli'
|
||||
Group.objects -> objects: collection, '(read-only) A collection of this groups objects'
|
||||
Header.bl_idname -> bl_idname: string 'NO DESCRIPTION'
|
||||
Header.bl_space_type -> bl_space_type: enum 'NO DESCRIPTION'
|
||||
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.fake_user -> use_fake_user: boolean 'Saves this datablock even if it has no users'
|
||||
ID.library -> library: pointer, '(read-only) Library file the datablock is linked from'
|
||||
ID.name -> name: string 'Unique datablock ID name'
|
||||
ID.tag -> tag: boolean 'Tools can use this to tag data, (initial state is undefined)'
|
||||
ID.users -> users: int, '(read-only) Number of times this datablock is referenced'
|
||||
IDProperty.collection -> collection: collection, '(read-only)'
|
||||
IDProperty.double -> double: float 'NO DESCRIPTION'
|
||||
IDProperty.double_array -> double_array: float 'NO DESCRIPTION'
|
||||
IDProperty.float -> float: float 'NO DESCRIPTION'
|
||||
IDProperty.float_array -> float_array: float 'NO DESCRIPTION'
|
||||
IDProperty.group -> group: pointer, '(read-only)'
|
||||
IDProperty.int -> int: int 'NO DESCRIPTION'
|
||||
IDProperty.int_array -> int_array: int 'NO DESCRIPTION'
|
||||
IDProperty.string -> string: string 'NO DESCRIPTION'
|
||||
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.animated -> use_animation: boolean 'Use as animated texture in the game engine'
|
||||
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.clamp_x -> use_clamp_x: boolean 'Disable texture repeating horizontally'
|
||||
Image.clamp_y -> use_clamp_y: boolean 'Disable texture repeating vertically'
|
||||
Image.depth -> depth: int, '(read-only) Image bit depth'
|
||||
Image.dirty -> is_dirty: boolean, '(read-only) Image has changed and is not saved'
|
||||
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.fields -> use_fields: boolean 'Use fields of the image'
|
||||
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.has_data -> has_data: boolean, '(read-only) True if this image has data'
|
||||
Image.mapping -> mapping: enum 'Mapping type to use for this image in the game engine'
|
||||
Image.packed_file -> packed_file: pointer, '(read-only)'
|
||||
Image.premultiply -> use_premultiply: boolean 'Convert RGB from key alpha to premultiplied alpha'
|
||||
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 -> use_tiles: boolean 'Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)'
|
||||
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.invert_stencil -> invert_stencil: boolean 'Invert the stencil layer'
|
||||
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)'
|
||||
ImagePaint.show_brush -> show_brush: boolean 'Enables brush shape while not drawing'
|
||||
ImagePaint.show_brush_draw -> show_brush_draw: boolean 'Enables brush shape while drawing'
|
||||
ImagePaint.use_backface_cull -> use_backface_culling: boolean 'Ignore faces pointing away from the view (faster)'
|
||||
ImagePaint.use_clone_layer -> use_clone_layer: boolean 'Use another UV layer as clone source, otherwise use 3D the cursor as the source'
|
||||
ImagePaint.use_normal_falloff -> use_normal_falloff: boolean 'Paint most on faces pointing towards the view'
|
||||
ImagePaint.use_occlude -> use_occlude: boolean 'Only paint onto the faces directly under the brush (slower)'
|
||||
ImagePaint.use_projection -> use_projection: boolean 'Use projection painting for improved consistency in the brush strokes'
|
||||
ImagePaint.use_stencil_layer -> use_stencil_layer: boolean 'Set the mask layer from the UV layer buttons'
|
||||
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.color_saturation -> color_saturation: float 'NO DESCRIPTION'
|
||||
ImageSequence.convert_float -> use_float: boolean 'Convert input to float data'
|
||||
ImageSequence.crop -> crop: pointer, '(read-only)'
|
||||
ImageSequence.de_interlace -> use_deinterlace: boolean 'For video movies to remove fields'
|
||||
ImageSequence.directory -> directory: string 'NO DESCRIPTION'
|
||||
ImageSequence.elements -> elements: collection, '(read-only)'
|
||||
ImageSequence.flip_x -> use_flip_x: boolean 'Flip on the X axis'
|
||||
ImageSequence.flip_y -> use_flip_y: boolean 'Flip on the Y axis'
|
||||
ImageSequence.multiply_colors -> multiply_colors: float 'NO DESCRIPTION'
|
||||
ImageSequence.premultiply -> use_premultiply: boolean 'Convert RGB from key alpha to premultiplied alpha'
|
||||
ImageSequence.proxy -> proxy: pointer, '(read-only)'
|
||||
ImageSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean 'Use a custom directory to store data'
|
||||
ImageSequence.proxy_custom_file -> use_proxy_custom_file: boolean 'Use a custom file to read proxy data from'
|
||||
ImageSequence.reverse_frames -> use_reverse_frames: boolean 'Reverse frame order'
|
||||
ImageSequence.strobe -> strobe: float 'Only display every nth frame'
|
||||
ImageSequence.transform -> transform: pointer, '(read-only)'
|
||||
ImageSequence.use_color_balance -> use_color_balance: boolean '(3-Way color correction) on input'
|
||||
ImageSequence.use_crop -> use_crop: boolean 'Crop image before processing'
|
||||
ImageSequence.use_proxy -> use_proxy: boolean 'Use a preview proxy for this strip'
|
||||
ImageSequence.use_translation -> use_translation: boolean 'Translate image before processing'
|
||||
ImageTexture.calculate_alpha -> use_calculate_alpha: boolean 'Calculates an alpha channel based on RGB values in the image'
|
||||
ImageTexture.checker_distance -> checker_distance: float 'Sets distance between checker tiles'
|
||||
ImageTexture.checker_even -> use_checker_even: boolean 'Sets even checker tiles'
|
||||
ImageTexture.checker_odd -> use_checker_odd: boolean 'Sets odd 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.filter_size_minimum -> use_minimum_filter_size: boolean 'Use Filter Size as a minimal filter value in pixels'
|
||||
ImageTexture.flip_axis -> use_flip_axis: boolean "Flips the texture's X and Y axis"
|
||||
ImageTexture.image -> image: pointer 'NO DESCRIPTION'
|
||||
ImageTexture.image_user -> image_user: pointer, '(read-only) Parameters defining which layer, pass and frame of the image is displayed'
|
||||
ImageTexture.interpolation -> use_interpolation: boolean 'Interpolates pixels using Area filter'
|
||||
ImageTexture.invert_alpha -> invert_alpha: boolean 'Inverts all the alpha values in the image'
|
||||
ImageTexture.mipmap -> use_mipmap: boolean 'Uses auto-generated MIP maps for the image'
|
||||
ImageTexture.mipmap_gauss -> use_mipmap_gauss: boolean 'Uses Gauss filter to sample down MIP maps'
|
||||
ImageTexture.mirror_x -> use_mirror_x: boolean 'Mirrors the image repetition on the X direction'
|
||||
ImageTexture.mirror_y -> use_mirror_y: boolean 'Mirrors the image repetition on the Y direction'
|
||||
ImageTexture.normal_map -> use_normal_map: boolean 'Uses image RGB values for normal mapping'
|
||||
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'
|
||||
ImageTexture.use_alpha -> use_alpha: boolean 'Uses the alpha channel information in the image'
|
||||
ImageUser.auto_refresh -> use_auto_refresh: boolean 'Always refresh image on frame changes'
|
||||
ImageUser.cyclic -> use_cyclic: boolean 'Cycle the images in the movie'
|
||||
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.active -> use: boolean 'Object contributes to the fluid simulation'
|
||||
InflowFluidSettings.export_animated_mesh -> use_animated_mesh: boolean 'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
|
||||
InflowFluidSettings.inflow_velocity -> inflow_velocity: float 'Initial velocity of fluid'
|
||||
InflowFluidSettings.local_coordinates -> use_local_coordinates: boolean 'Use local coordinates for inflow. (e.g. for rotating objects)'
|
||||
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.auto_step -> use_auto_step: boolean 'Automatically determine the optimal number of steps for best performance/accuracy trade off'
|
||||
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 -> step_max: float 'Higher bound for timestep in second in case of automatic substeps'
|
||||
Itasc.max_velocity -> velocity_max: float 'Maximum joint velocity in rad/s. Default=50'
|
||||
Itasc.min_step -> step_min: float 'Lower bound for timestep in second in case of automatic substeps'
|
||||
Itasc.mode -> mode: enum 'NO DESCRIPTION'
|
||||
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.all_events -> use_all_events: boolean 'Triggered by all events on this joysticks current type (axis/button/hat)'
|
||||
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.relative -> use_relative: boolean 'Makes shape keys relative'
|
||||
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'
|
||||
KeyConfig.user_defined -> is_user_defined: boolean, '(read-only) Indicates that a keyconfig was defined by the user'
|
||||
KeyMap.children_expanded -> show_expanded_children: boolean 'Children expanded in the user interface'
|
||||
KeyMap.items -> items: collection, '(read-only) Items in the keymap, linking an operator to an input event'
|
||||
KeyMap.items_expanded -> show_expanded_items: boolean 'Expanded in the user interface'
|
||||
KeyMap.modal -> is_modal: boolean, '(read-only) Indicates that a keymap is used for translate modal events for an operator'
|
||||
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'
|
||||
KeyMap.user_defined -> is_user_defined: boolean 'Keymap is defined by the user'
|
||||
KeyMapItem.active -> active: boolean 'Activate or deactivate item'
|
||||
KeyMapItem.alt -> pressed_alt: boolean 'Alt key pressed'
|
||||
KeyMapItem.any -> pressed_any: boolean 'Any modifier keys pressed'
|
||||
KeyMapItem.ctrl -> pressed_ctrl: boolean 'Control key pressed'
|
||||
KeyMapItem.expanded -> show_expanded: boolean 'Show key map event and property details in the user interface'
|
||||
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.oskey -> pressed_cmd: boolean 'Operating system key pressed'
|
||||
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.shift -> pressed_shift: boolean 'Shift key pressed'
|
||||
KeyMapItem.type -> type: enum 'Type of event'
|
||||
KeyMapItem.value -> value: enum 'NO DESCRIPTION'
|
||||
KeyboardSensor.all_keys -> use_all_keys: boolean 'Trigger this sensor on any keystroke'
|
||||
KeyboardSensor.key -> key: enum 'NO DESCRIPTION'
|
||||
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 -> handle_left: float 'Coordinates of the first handle'
|
||||
Keyframe.handle1_type -> handle_left_type: enum 'Handle types'
|
||||
Keyframe.handle2 -> handle_right: float 'Coordinates of the second handle'
|
||||
Keyframe.handle2_type -> handle_right_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.select_control_point -> select_control_point: boolean 'Control point selection status'
|
||||
Keyframe.select_left_handle -> select_left_handle: boolean 'Handle 1 selection status'
|
||||
Keyframe.select_right_handle -> select_right_handle: boolean 'Handle 2 selection status'
|
||||
Keyframe.type -> type: enum 'The type of keyframe'
|
||||
KeyingSet.absolute -> use_absolute: boolean 'Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)'
|
||||
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.insertkey_needed -> use_insertkey_needed: boolean "Only insert keyframes where they're needed in the relevant F-Curves"
|
||||
KeyingSet.insertkey_visual -> use_insertkey_visual: boolean "Insert keyframes based on 'visual transforms'"
|
||||
KeyingSet.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb: boolean 'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
|
||||
KeyingSet.name -> name: string 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
KeyingSetInfo.bl_label -> bl_label: string 'NO DESCRIPTION'
|
||||
KeyingSetInfo.insertkey_needed -> use_insertkey_needed: boolean "Only insert keyframes where they're needed in the relevant F-Curves"
|
||||
KeyingSetInfo.insertkey_visual -> use_insertkey_visual: boolean "Insert keyframes based on 'visual transforms'"
|
||||
KeyingSetInfo.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb: boolean 'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
|
||||
KeyingSetPath.array_index -> array_index: int 'Index to the specific setting if applicable'
|
||||
KeyingSetPath.data_path -> data_path: string 'Path to property setting'
|
||||
KeyingSetPath.entire_array -> use_entire_array: boolean "When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used"
|
||||
KeyingSetPath.group -> group: string 'Name of Action Group to assign setting(s) for this path to'
|
||||
KeyingSetPath.grouping -> group_method: 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'
|
||||
KeyingSetPath.insertkey_needed -> use_insertkey_needed: boolean "Only insert keyframes where they're needed in the relevant F-Curves"
|
||||
KeyingSetPath.insertkey_visual -> use_insertkey_visual: boolean "Insert keyframes based on 'visual transforms'"
|
||||
KeyingSetPath.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb: boolean 'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
KinematicConstraint.pole_target -> pole_target: pointer 'Object for pole rotation'
|
||||
KinematicConstraint.pos_lock_x -> lock_location_x: boolean 'Constraint position along X axis'
|
||||
KinematicConstraint.pos_lock_y -> lock_location_y: boolean 'Constraint position along Y axis'
|
||||
KinematicConstraint.pos_lock_z -> lock_location_z: boolean 'Constraint position along Z axis'
|
||||
KinematicConstraint.rot_lock_x -> lock_rotation_x: boolean 'Constraint rotation along X axis'
|
||||
KinematicConstraint.rot_lock_y -> lock_rotation_y: boolean 'Constraint rotation along Y axis'
|
||||
KinematicConstraint.rot_lock_z -> lock_rotation_z: boolean 'Constraint rotation along Z axis'
|
||||
KinematicConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
KinematicConstraint.target -> target: pointer 'Target Object'
|
||||
KinematicConstraint.use_position -> use_location: boolean 'Chain follows position of target'
|
||||
KinematicConstraint.use_rotation -> use_rotation: boolean 'Chain follows rotation of target'
|
||||
KinematicConstraint.use_stretch -> use_stretch: boolean 'Enable IK Stretching'
|
||||
KinematicConstraint.use_tail -> use_tail: boolean "Include bone's tail as last element in chain"
|
||||
KinematicConstraint.use_target -> use_target: boolean 'Disable for targetless IK'
|
||||
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.diffuse -> use_diffuse: boolean 'Lamp does diffuse shading'
|
||||
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.layer -> use_own_layer: boolean 'Illuminates objects only on the same layer the lamp is on'
|
||||
Lamp.negative -> use_negative: boolean 'Lamp casts negative light'
|
||||
Lamp.specular -> use_specular: boolean 'Lamp creates specular highlights'
|
||||
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_intensity: 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_intensity: float 'Sun brightness'
|
||||
LampSkySettings.sun_intensity -> sun_intensity: float 'Sun intensity'
|
||||
LampSkySettings.sun_size -> sun_size: float 'Sun size'
|
||||
LampSkySettings.use_atmosphere -> use_atmosphere: boolean 'Apply sun effect on atmosphere'
|
||||
LampSkySettings.use_sky -> use_sky: boolean 'Apply sun effect on sky'
|
||||
LampTextureSlot.color_factor -> color_factor: float 'Amount texture affects color values'
|
||||
LampTextureSlot.map_color -> use_map_color: boolean 'Lets the texture affect the basic color of the lamp'
|
||||
LampTextureSlot.map_shadow -> use_map_shadow: boolean 'Lets the texture affect the shadow color of the lamp'
|
||||
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 'NO DESCRIPTION'
|
||||
Lattice.interpolation_type_u -> interpolation_type_u: enum 'NO DESCRIPTION'
|
||||
Lattice.interpolation_type_v -> interpolation_type_v: enum 'NO DESCRIPTION'
|
||||
Lattice.interpolation_type_w -> interpolation_type_w: enum 'NO DESCRIPTION'
|
||||
Lattice.outside -> use_outside: boolean 'Only draw, and take into account, the outer vertices'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
LimitDistanceConstraint.target -> target: pointer 'Target Object'
|
||||
LimitLocationConstraint.limit_transform -> limit_transform: boolean 'Transforms are affected by this constraint as well'
|
||||
LimitLocationConstraint.maximum_x -> max_x: float 'Highest X value to allow'
|
||||
LimitLocationConstraint.maximum_y -> max_y: float 'Highest Y value to allow'
|
||||
LimitLocationConstraint.maximum_z -> max_z: float 'Highest Z value to allow'
|
||||
LimitLocationConstraint.minimum_x -> min_x: float 'Lowest X value to allow'
|
||||
LimitLocationConstraint.minimum_y -> min_y: float 'Lowest Y value to allow'
|
||||
LimitLocationConstraint.minimum_z -> min_z: float 'Lowest Z value to allow'
|
||||
LimitLocationConstraint.use_maximum_x -> use_max_x: boolean 'Use the maximum X value'
|
||||
LimitLocationConstraint.use_maximum_y -> use_max_y: boolean 'Use the maximum Y value'
|
||||
LimitLocationConstraint.use_maximum_z -> use_max_z: boolean 'Use the maximum Z value'
|
||||
LimitLocationConstraint.use_minimum_x -> use_min_x: boolean 'Use the minimum X value'
|
||||
LimitLocationConstraint.use_minimum_y -> use_min_y: boolean 'Use the minimum Y value'
|
||||
LimitLocationConstraint.use_minimum_z -> use_min_z: boolean 'Use the minimum Z value'
|
||||
LimitRotationConstraint.limit_transform -> limit_transform: boolean 'Transforms are affected by this constraint as well'
|
||||
LimitRotationConstraint.maximum_x -> max_x: float 'Highest X value to allow'
|
||||
LimitRotationConstraint.maximum_y -> max_y: float 'Highest Y value to allow'
|
||||
LimitRotationConstraint.maximum_z -> max_z: float 'Highest Z value to allow'
|
||||
LimitRotationConstraint.minimum_x -> min_x: float 'Lowest X value to allow'
|
||||
LimitRotationConstraint.minimum_y -> min_y: float 'Lowest Y value to allow'
|
||||
LimitRotationConstraint.minimum_z -> min_z: float 'Lowest Z value to allow'
|
||||
LimitRotationConstraint.use_limit_x -> use_limit_x: boolean 'Use the minimum X value'
|
||||
LimitRotationConstraint.use_limit_y -> use_limit_y: boolean 'Use the minimum Y value'
|
||||
LimitRotationConstraint.use_limit_z -> use_limit_z: boolean 'Use the minimum Z value'
|
||||
LimitScaleConstraint.limit_transform -> limit_transform: boolean 'Transforms are affected by this constraint as well'
|
||||
LimitScaleConstraint.maximum_x -> max_x: float 'Highest X value to allow'
|
||||
LimitScaleConstraint.maximum_y -> max_y: float 'Highest Y value to allow'
|
||||
LimitScaleConstraint.maximum_z -> max_z: float 'Highest Z value to allow'
|
||||
LimitScaleConstraint.minimum_x -> min_x: float 'Lowest X value to allow'
|
||||
LimitScaleConstraint.minimum_y -> min_y: float 'Lowest Y value to allow'
|
||||
LimitScaleConstraint.minimum_z -> min_z: float 'Lowest Z value to allow'
|
||||
LimitScaleConstraint.use_maximum_x -> use_max_x: boolean 'Use the maximum X value'
|
||||
LimitScaleConstraint.use_maximum_y -> use_max_y: boolean 'Use the maximum Y value'
|
||||
LimitScaleConstraint.use_maximum_z -> use_max_z: boolean 'Use the maximum Z value'
|
||||
LimitScaleConstraint.use_minimum_x -> use_min_x: boolean 'Use the minimum X value'
|
||||
LimitScaleConstraint.use_minimum_y -> use_min_y: boolean 'Use the minimum Y value'
|
||||
LimitScaleConstraint.use_minimum_z -> use_min_z: boolean 'Use the minimum Z value'
|
||||
LockedTrackConstraint.lock -> lock: enum 'Axis that points upward'
|
||||
LockedTrackConstraint.subtarget -> subtarget: string 'NO DESCRIPTION'
|
||||
LockedTrackConstraint.target -> target: pointer 'Target Object'
|
||||
LockedTrackConstraint.track -> track: enum 'Axis that points to the target object'
|
||||
Macro.bl_description -> bl_description: string 'NO DESCRIPTION'
|
||||
Macro.bl_idname -> bl_idname: string 'NO DESCRIPTION'
|
||||
Macro.bl_label -> bl_label: string 'NO DESCRIPTION'
|
||||
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.debug -> show_debug: boolean 'Print debugging information in console'
|
||||
Main.file_is_saved -> is_saved: boolean, '(read-only) Has the current session been saved to disk as a .blend file'
|
||||
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 'NO DESCRIPTION'
|
||||
MarbleTexture.noisebasis2 -> noisebasis2: enum 'NO DESCRIPTION'
|
||||
MarbleTexture.stype -> stype: enum 'NO DESCRIPTION'
|
||||
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.invert -> invert_vertex_group: boolean 'Use vertices that are not part of region defined'
|
||||
MaskModifier.mode -> mode: enum 'NO DESCRIPTION'
|
||||
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.cast_approximate -> use_cast_approximate: boolean 'Allow this material to cast shadows when using approximate ambient occlusion.'
|
||||
Material.cast_buffer_shadows -> use_cast_buffer_shadows: boolean 'Allow this material to cast shadows from shadow buffer lamps'
|
||||
Material.cast_shadows_only -> use_cast_shadows_only: boolean 'Makes objects with this material appear invisible, only casting shadows (not rendered)'
|
||||
Material.cubic -> use_cubic: boolean 'Use cubic interpolation for diffuse values, for smoother transitions'
|
||||
Material.darkness -> darkness: float 'Minnaert darkness'
|
||||
Material.diffuse_color -> diffuse_color: float 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
Material.diffuse_ramp_factor -> diffuse_ramp_factor: float 'Blending factor (also uses alpha in Colorband)'
|
||||
Material.diffuse_ramp_input -> diffuse_ramp_input: enum 'NO DESCRIPTION'
|
||||
Material.diffuse_shader -> diffuse_shader: enum 'NO DESCRIPTION'
|
||||
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'
|
||||
NEGATE * Material.exclude_mist -> use_mist: boolean 'Excludes this material from mist effects (in world settings)'
|
||||
Material.face_texture -> use_face_texture: boolean "Replaces the object's base color with color from face assigned image textures"
|
||||
Material.face_texture_alpha -> use_face_texture_alpha: boolean "Replaces the object's base alpha value with alpha from face assigned image textures"
|
||||
Material.full_oversampling -> use_full_oversampling: boolean 'Force this material to render full shading/textures for all anti-aliasing samples'
|
||||
Material.halo -> halo: pointer, '(read-only) Halo settings for the material'
|
||||
Material.invert_z -> invert_z: boolean "Renders material's faces with an inverted Z buffer (scanline only)"
|
||||
Material.light_group -> light_group: pointer 'Limit lighting to lamps in this Group'
|
||||
Material.light_group_exclusive -> use_light_group_exclusive: boolean 'Material uses the light group exclusively - these lamps are excluded from other scene lighting'
|
||||
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.object_color -> use_object_color: boolean 'Modulate the result with a per-object color'
|
||||
Material.only_shadow -> use_only_shadow: boolean "Renders shadows as the material's alpha value, making materials transparent except for shadowed areas"
|
||||
Material.physics -> physics: pointer, '(read-only) Game physics settings'
|
||||
Material.preview_render_type -> preview_render_type: enum 'Type of preview render'
|
||||
Material.ray_shadow_bias -> use_ray_shadow_bias: boolean 'Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)'
|
||||
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.receive_transparent_shadows -> use_transparent_shadows: boolean 'Allow this object to receive transparent shadows casted through other objects'
|
||||
Material.roughness -> rough: float 'Oren-Nayar Roughness'
|
||||
Material.shadeless -> use_shadeless: boolean 'Makes this material insensitive to light or shadow'
|
||||
Material.shadow_buffer_bias -> shadow_buffer_bias: float 'Factor to multiply shadow buffer bias with (0 is ignore.)'
|
||||
Material.shadow_casting_alpha -> shadow_cast_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.shadows -> use_shadows: boolean 'Allows this material to receive shadows'
|
||||
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_hard: int 'NO DESCRIPTION'
|
||||
Material.specular_intensity -> specular_intensity: float 'NO DESCRIPTION'
|
||||
Material.specular_ior -> specular_ior: float 'NO DESCRIPTION'
|
||||
Material.specular_ramp -> specular_ramp: pointer, '(read-only) Color ramp used to affect specular shading'
|
||||
Material.specular_ramp_blend -> specular_ramp_blend: enum 'NO DESCRIPTION'
|
||||
Material.specular_ramp_factor -> specular_ramp_factor: float 'Blending factor (also uses alpha in Colorband)'
|
||||
Material.specular_ramp_input -> specular_ramp_input: enum 'NO DESCRIPTION'
|
||||
Material.specular_shader -> specular_shader: enum 'NO DESCRIPTION'
|
||||
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.tangent_shading -> use_tangent_shading: boolean "Use the material's tangent vector instead of the normal for shading - for anisotropic shading effects"
|
||||
Material.texture_slots -> texture_slots: collection, '(read-only) Texture slots defining the mapping and influence of textures'
|
||||
Material.traceable -> use_traceable: boolean 'Include this material and geometry that uses it in ray tracing calculations'
|
||||
Material.translucency -> translucency: float 'Amount of diffuse shading on the back side'
|
||||
Material.transparency -> use_transparency: boolean 'Render material as transparent'
|
||||
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.use_diffuse_ramp -> use_diffuse_ramp: boolean 'Toggle diffuse ramp operations'
|
||||
Material.use_nodes -> use_nodes: boolean 'Use shader nodes to render the material'
|
||||
Material.use_sky -> use_sky: boolean 'Renders this material with zero alpha, with sky background in place (scanline only)'
|
||||
Material.use_specular_ramp -> use_specular_ramp: boolean 'Toggle specular ramp operations'
|
||||
Material.use_textures -> use_textures: boolean 'Enable/Disable each texture'
|
||||
Material.vertex_color_light -> use_vertex_color_light: boolean 'Add vertex colors as additional lighting'
|
||||
Material.vertex_color_paint -> use_vertex_color_paint: boolean "Replaces object base color with vertex colors (multiplies with 'texture face' face assigned textures)"
|
||||
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_mode -> use_flare_mode: boolean 'Renders halo as a lensflare'
|
||||
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 -> hard: 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.lines -> use_lines: boolean 'Renders star shaped lines over halo'
|
||||
MaterialHalo.ring -> use_ring: boolean 'Renders rings over 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.shaded -> use_shading: boolean 'Lets halo receive light and shadows from external objects'
|
||||
MaterialHalo.size -> size: float 'Sets the dimension of the halo'
|
||||
MaterialHalo.soft -> use_soft: boolean 'Softens the edges of halos at intersections with other geometry'
|
||||
MaterialHalo.star -> use_star: boolean 'Renders halo as a star'
|
||||
MaterialHalo.star_tips -> star_tips: int 'Sets the number of points on the star shaped halo'
|
||||
MaterialHalo.texture -> use_texture: boolean 'Gives halo a texture'
|
||||
MaterialHalo.vertex_normal -> use_vertex_normal: boolean 'Uses the vertex normal to specify the dimension of the halo'
|
||||
MaterialHalo.xalpha -> use_extreme_alpha: boolean 'Uses extreme alpha'
|
||||
MaterialPhysics.align_to_normal -> use_align_to_normal: boolean 'Align dynamic game objects along the surface normal, when inside the physics distance area'
|
||||
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.enabled -> use: boolean 'Enable raytraced reflections'
|
||||
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.blender_units -> use_blender_units: boolean 'Use Blender units for widths instead of pixels'
|
||||
MaterialStrand.min_size -> size_min: 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.surface_diffuse -> use_surface_diffuse: boolean 'Make diffuse shading more similar to shading the surface'
|
||||
MaterialStrand.tangent_shading -> use_tangent_shading: boolean 'Uses direction of strands as normal for tangent-shading'
|
||||
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.enabled -> use: boolean 'Enable diffuse subsurface scatting effects in a material'
|
||||
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.enabled -> use: boolean 'Enable this material texture slot'
|
||||
MaterialTextureSlot.from_dupli -> use_from_dupli: boolean "Dupli's instanced from verts, faces or particles, inherit texture coordinate from their parent"
|
||||
MaterialTextureSlot.from_original -> use_from_original: boolean "Dupli's derive their object coordinates from the original objects transformation"
|
||||
MaterialTextureSlot.hardness_factor -> hard_factor: float 'Amount texture affects hardness'
|
||||
MaterialTextureSlot.map_alpha -> use_map_alpha: boolean 'Causes the texture to affect the alpha value'
|
||||
MaterialTextureSlot.map_ambient -> use_map_ambient: boolean 'Causes the texture to affect the value of ambient'
|
||||
MaterialTextureSlot.map_colordiff -> use_map_colordiff: boolean 'Causes the texture to affect basic color of the material'
|
||||
MaterialTextureSlot.map_coloremission -> use_map_coloremission: boolean 'Causes the texture to affect the color of emission'
|
||||
MaterialTextureSlot.map_colorreflection -> use_map_colorreflection: boolean 'Causes the texture to affect the color of scattered light'
|
||||
MaterialTextureSlot.map_colorspec -> use_map_colorspec: boolean 'Causes the texture to affect the specularity color'
|
||||
MaterialTextureSlot.map_colortransmission -> use_map_colortransmission: boolean 'Causes the texture to affect the result color after other light has been scattered/absorbed'
|
||||
MaterialTextureSlot.map_density -> use_map_density: boolean "Causes the texture to affect the volume's density"
|
||||
MaterialTextureSlot.map_diffuse -> use_map_diffuse: boolean 'Causes the texture to affect the value of the materials diffuse reflectivity'
|
||||
MaterialTextureSlot.map_displacement -> use_map_displacement: boolean 'Let the texture displace the surface'
|
||||
MaterialTextureSlot.map_emission -> use_map_emission: boolean "Causes the texture to affect the volume's emission"
|
||||
MaterialTextureSlot.map_emit -> use_map_emit: boolean 'Causes the texture to affect the emit value'
|
||||
MaterialTextureSlot.map_hardness -> use_map_hardness: boolean 'Causes the texture to affect the hardness value'
|
||||
MaterialTextureSlot.map_mirror -> use_map_mirror: boolean 'Causes the texture to affect the mirror color'
|
||||
MaterialTextureSlot.map_normal -> use_map_normal: boolean 'Causes the texture to affect the rendered normal'
|
||||
MaterialTextureSlot.map_raymir -> use_map_raymir: boolean 'Causes the texture to affect the ray-mirror value'
|
||||
MaterialTextureSlot.map_reflection -> use_map_reflect: boolean "Causes the texture to affect the reflected light's brightness"
|
||||
MaterialTextureSlot.map_scattering -> use_map_scatter: boolean "Causes the texture to affect the volume's scattering"
|
||||
MaterialTextureSlot.map_specular -> use_map_specular: boolean 'Causes the texture to affect the value of specular reflectivity'
|
||||
MaterialTextureSlot.map_translucency -> use_map_translucency: boolean 'Causes the texture to affect the translucency value'
|
||||
MaterialTextureSlot.map_warp -> use_map_warp: boolean 'Let the texture warp texture coordinates of next channels'
|
||||
MaterialTextureSlot.mapping -> mapping: enum 'NO DESCRIPTION'
|
||||
MaterialTextureSlot.mirror_factor -> mirror_factor: float 'Amount texture affects mirror color'
|
||||
MaterialTextureSlot.new_bump -> use_new_bump: boolean 'Use new, corrected bump mapping code (backwards compatibility option)'
|
||||
MaterialTextureSlot.normal_factor -> normal_factor: float 'Amount texture affects normal values'
|
||||
MaterialTextureSlot.normal_map_space -> normal_map_space: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
MaterialTextureSlot.y_mapping -> y_mapping: enum 'NO DESCRIPTION'
|
||||
MaterialTextureSlot.z_mapping -> z_mapping: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
MaterialVolume.external_shadows -> use_external_shadows: boolean 'Receive shadows from sources outside the volume (temporary)'
|
||||
MaterialVolume.light_cache -> use_light_cache: boolean 'Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy'
|
||||
MaterialVolume.lighting_mode -> light_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 'NO DESCRIPTION'
|
||||
Menu.bl_label -> bl_label: string 'NO DESCRIPTION'
|
||||
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.all_edges -> show_all_edges: boolean 'Displays all edges for wireframe in all view modes in the 3D view'
|
||||
Mesh.animation_data -> animation_data: pointer, '(read-only) Animation data for this datablock'
|
||||
Mesh.auto_texspace -> use_auto_texspace: boolean "Adjusts active object's texture space automatically when transforming object"
|
||||
Mesh.autosmooth -> use_autosmooth: boolean "Treats all set-smoothed faces with angles less than the specified angle as 'smooth' during render"
|
||||
Mesh.autosmooth_angle -> autosmooth_angle: int "Defines maximum angle between face normals that 'Auto Smooth' will operate on"
|
||||
Mesh.double_sided -> show_double_sided: boolean 'Render/display the mesh with double or single sided lighting'
|
||||
Mesh.draw_bevel_weights -> show_bevel_weights: boolean 'Displays weights created for the Bevel modifier'
|
||||
Mesh.draw_creases -> show_creases: boolean 'Displays creases created for subsurf weighting'
|
||||
Mesh.draw_edge_angle -> show_edge_angle: boolean 'Displays the angles in the selected edges in degrees'
|
||||
Mesh.draw_edge_length -> show_edge_length: boolean 'Displays selected edge lengths, Using global values when set in the transform panel'
|
||||
Mesh.draw_edges -> show_edges: boolean 'Displays selected edges using highlights in the 3D view and UV editor'
|
||||
Mesh.draw_face_area -> show_face_area: boolean 'Displays the area of selected faces'
|
||||
Mesh.draw_faces -> show_faces: boolean 'Displays all faces as shades in the 3D view and UV editor'
|
||||
Mesh.draw_normals -> show_normals: boolean 'Displays face normals as lines'
|
||||
Mesh.draw_seams -> show_seams: boolean 'Displays UV unwrapping seams'
|
||||
Mesh.draw_sharp -> show_sharp: boolean 'Displays sharp edges, used with the EdgeSplit modifier'
|
||||
Mesh.draw_vertex_normals -> show_vertex_normals: boolean 'Displays vertex normals as lines'
|
||||
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.use_mirror_topology -> use_mirror_topology: boolean 'Use topology based mirroring'
|
||||
Mesh.use_mirror_x -> use_mirror_x: boolean 'X Axis mirror editing'
|
||||
Mesh.use_paint_mask -> use_paint_mask: boolean 'Face selection masking for painting'
|
||||
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 'NO DESCRIPTION'
|
||||
MeshColor.color2 -> color2: float 'NO DESCRIPTION'
|
||||
MeshColor.color3 -> color3: float 'NO DESCRIPTION'
|
||||
MeshColor.color4 -> color4: float 'NO DESCRIPTION'
|
||||
MeshColorLayer.active -> active: boolean 'Sets the layer as active for display and editing'
|
||||
MeshColorLayer.active_render -> active_render: boolean 'Sets the layer as active for rendering'
|
||||
MeshColorLayer.data -> data: collection, '(read-only)'
|
||||
MeshColorLayer.name -> name: string 'NO DESCRIPTION'
|
||||
MeshDeformModifier.dynamic -> use_dynamic_bind: boolean 'Recompute binding dynamically on top of other deformers (slower and more memory consuming.)'
|
||||
MeshDeformModifier.invert -> invert_vertex_group: boolean 'Invert vertex group influence'
|
||||
MeshDeformModifier.is_bound -> is_bound: boolean, '(read-only) Whether geometry has been bound to control cage'
|
||||
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.fgon -> is_fgon: boolean, '(read-only) Fgon edge'
|
||||
MeshEdge.hide -> hide: boolean 'NO DESCRIPTION'
|
||||
MeshEdge.index -> index: int, '(read-only) Index number of the vertex'
|
||||
MeshEdge.loose -> is_loose: boolean, '(read-only) Loose edge'
|
||||
MeshEdge.seam -> use_seam: boolean 'Seam edge for UV unwrapping'
|
||||
MeshEdge.select -> select: boolean 'NO DESCRIPTION'
|
||||
MeshEdge.sharp -> use_sharp: boolean 'Sharp edge for the EdgeSplit modifier'
|
||||
MeshEdge.verts -> verts: int 'Vertex indices'
|
||||
MeshFace.area -> area: float, '(read-only) read only area of the face'
|
||||
MeshFace.hide -> hide: boolean 'NO DESCRIPTION'
|
||||
MeshFace.index -> index: int, '(read-only) Index number of the vertex'
|
||||
MeshFace.material_index -> material_index: int 'NO DESCRIPTION'
|
||||
MeshFace.normal -> normal: float, '(read-only) local space unit length normal vector for this face'
|
||||
MeshFace.select -> select: boolean 'NO DESCRIPTION'
|
||||
MeshFace.smooth -> use_smooth: boolean 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
MeshFloatPropertyLayer.data -> data: collection, '(read-only)'
|
||||
MeshFloatPropertyLayer.name -> name: string 'NO DESCRIPTION'
|
||||
MeshIntProperty.value -> value: int 'NO DESCRIPTION'
|
||||
MeshIntPropertyLayer.data -> data: collection, '(read-only)'
|
||||
MeshIntPropertyLayer.name -> name: string 'NO DESCRIPTION'
|
||||
MeshSticky.co -> co: float 'Sticky texture coordinate location'
|
||||
MeshStringProperty.value -> value: string 'NO DESCRIPTION'
|
||||
MeshStringPropertyLayer.data -> data: collection, '(read-only)'
|
||||
MeshStringPropertyLayer.name -> name: string 'NO DESCRIPTION'
|
||||
MeshTextureFace.alpha_sort -> use_alpha_sort: boolean 'Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)'
|
||||
MeshTextureFace.billboard -> use_billboard: boolean 'Billboard with Z-axis constraint'
|
||||
MeshTextureFace.collision -> use_collision: boolean 'Use face for collision and ray-sensor detection'
|
||||
MeshTextureFace.halo -> use_halo: boolean 'Screen aligned billboard'
|
||||
MeshTextureFace.image -> image: pointer 'NO DESCRIPTION'
|
||||
MeshTextureFace.invisible -> hide: boolean 'Make face invisible'
|
||||
MeshTextureFace.light -> use_light: boolean 'Use light for face'
|
||||
MeshTextureFace.object_color -> use_object_color: boolean 'Use ObColor instead of vertex colors'
|
||||
MeshTextureFace.select_uv -> select_uv: boolean 'NO DESCRIPTION'
|
||||
MeshTextureFace.shadow -> use_shadow_face: boolean 'Face is used for shadow'
|
||||
MeshTextureFace.shared -> use_blend_shared: boolean 'Blend vertex colors across face when vertices are shared'
|
||||
MeshTextureFace.tex -> use_texture: boolean 'Render face with texture'
|
||||
MeshTextureFace.text -> use_bitmap_text: boolean 'Enable bitmap text on face'
|
||||
MeshTextureFace.transp -> transp: enum 'Transparency blending mode'
|
||||
MeshTextureFace.twoside -> use_twoside: boolean 'Render face two-sided'
|
||||
MeshTextureFace.uv -> uv: float 'NO DESCRIPTION'
|
||||
MeshTextureFace.uv1 -> uv1: float 'NO DESCRIPTION'
|
||||
MeshTextureFace.uv2 -> uv2: float 'NO DESCRIPTION'
|
||||
MeshTextureFace.uv3 -> uv3: float 'NO DESCRIPTION'
|
||||
MeshTextureFace.uv4 -> uv4: float 'NO DESCRIPTION'
|
||||
MeshTextureFace.uv_pinned -> pin_uv: boolean 'NO DESCRIPTION'
|
||||
MeshTextureFace.uv_raw -> uv_raw: float 'Fixed size UV coordinates array'
|
||||
MeshTextureFaceLayer.active -> active: boolean 'Sets the layer as active for display and editing'
|
||||
MeshTextureFaceLayer.active_clone -> active_clone: boolean 'Sets the layer as active for cloning'
|
||||
MeshTextureFaceLayer.active_render -> active_render: boolean 'Sets the layer as active for rendering'
|
||||
MeshTextureFaceLayer.data -> data: collection, '(read-only)'
|
||||
MeshTextureFaceLayer.name -> name: string 'NO DESCRIPTION'
|
||||
MeshVertex.bevel_weight -> bevel_weight: float "Weight used by the Bevel modifier 'Only Vertices' option"
|
||||
MeshVertex.co -> co: float 'NO DESCRIPTION'
|
||||
MeshVertex.groups -> groups: collection, '(read-only) Weights for the vertex groups this vertex is member of'
|
||||
MeshVertex.hide -> hide: boolean 'NO DESCRIPTION'
|
||||
MeshVertex.index -> index: int, '(read-only) Index number of the vertex'
|
||||
MeshVertex.normal -> normal: float 'Vertex Normal'
|
||||
MeshVertex.select -> select: boolean 'NO DESCRIPTION'
|
||||
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.auto_texspace -> use_auto_texspace: boolean "Adjusts active object's texture space automatically when transforming object"
|
||||
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.hide -> hide: boolean 'Hide element'
|
||||
MetaElement.location -> location: float 'NO DESCRIPTION'
|
||||
MetaElement.negative -> use_negative: boolean 'Set metaball as negative one'
|
||||
MetaElement.radius -> radius: float 'NO DESCRIPTION'
|
||||
MetaElement.rotation -> rotation: float 'NO DESCRIPTION'
|
||||
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.color_saturation -> color_saturation: float 'NO DESCRIPTION'
|
||||
MetaSequence.convert_float -> use_float: boolean 'Convert input to float data'
|
||||
MetaSequence.crop -> crop: pointer, '(read-only)'
|
||||
MetaSequence.de_interlace -> use_deinterlace: boolean 'For video movies to remove fields'
|
||||
MetaSequence.flip_x -> use_flip_x: boolean 'Flip on the X axis'
|
||||
MetaSequence.flip_y -> use_flip_y: boolean 'Flip on the Y axis'
|
||||
MetaSequence.multiply_colors -> multiply_colors: float 'NO DESCRIPTION'
|
||||
MetaSequence.premultiply -> use_premultiply: boolean 'Convert RGB from key alpha to premultiplied alpha'
|
||||
MetaSequence.proxy -> proxy: pointer, '(read-only)'
|
||||
MetaSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean 'Use a custom directory to store data'
|
||||
MetaSequence.proxy_custom_file -> use_proxy_custom_file: boolean 'Use a custom file to read proxy data from'
|
||||
MetaSequence.reverse_frames -> use_reverse_frames: boolean 'Reverse frame order'
|
||||
MetaSequence.sequences -> sequences: collection, '(read-only)'
|
||||
MetaSequence.strobe -> strobe: float 'Only display every nth frame'
|
||||
MetaSequence.transform -> transform: pointer, '(read-only)'
|
||||
MetaSequence.use_color_balance -> use_color_balance: boolean '(3-Way color correction) on input'
|
||||
MetaSequence.use_crop -> use_crop: boolean 'Crop image before processing'
|
||||
MetaSequence.use_proxy -> use_proxy: boolean 'Use a preview proxy for this strip'
|
||||
MetaSequence.use_translation -> use_translation: boolean 'Translate image before processing'
|
||||
MirrorModifier.clip -> use_clip: boolean 'Prevents vertices from going through the mirror during transform'
|
||||
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'
|
||||
MirrorModifier.mirror_u -> use_mirror_u: boolean 'Mirror the U texture coordinate around the 0.5 point'
|
||||
MirrorModifier.mirror_v -> use_mirror_v: boolean 'Mirror the V texture coordinate around the 0.5 point'
|
||||
MirrorModifier.mirror_vertex_groups -> use_mirror_vertex_groups: boolean 'Mirror vertex groups (e.g. .R->.L)'
|
||||
MirrorModifier.x -> use_x: boolean 'Enable X axis mirror'
|
||||
MirrorModifier.y -> use_y: boolean 'Enable Y axis mirror'
|
||||
MirrorModifier.z -> use_z: boolean 'Enable Z axis mirror'
|
||||
Modifier.editmode -> show_in_editmode: boolean 'Use modifier while in the edit mode'
|
||||
Modifier.expanded -> show_expanded: boolean 'Set modifier expanded in the user interface'
|
||||
Modifier.name -> name: string 'Modifier name'
|
||||
Modifier.on_cage -> show_on_cage: boolean 'Enable direct editing of modifier control cage'
|
||||
Modifier.realtime -> show_realtime: boolean 'Realtime display of a modifier'
|
||||
Modifier.render -> use_render: boolean 'Use modifier during rendering'
|
||||
Modifier.type -> type: enum, '(read-only)'
|
||||
MotionPath.editing -> is_edited: boolean 'Path is being edited'
|
||||
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'
|
||||
MotionPath.use_bone_head -> use_bone_head: boolean, '(read-only) For PoseBone paths, use the bone head location when calculating this path'
|
||||
MotionPathVert.co -> co: float 'NO DESCRIPTION'
|
||||
MotionPathVert.select -> select: boolean 'Path point is selected for editing'
|
||||
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.color_saturation -> color_saturation: float 'NO DESCRIPTION'
|
||||
MovieSequence.convert_float -> use_float: boolean 'Convert input to float data'
|
||||
MovieSequence.crop -> crop: pointer, '(read-only)'
|
||||
MovieSequence.de_interlace -> use_deinterlace: boolean 'For video movies to remove fields'
|
||||
MovieSequence.filepath -> filepath: string 'NO DESCRIPTION'
|
||||
MovieSequence.flip_x -> use_flip_x: boolean 'Flip on the X axis'
|
||||
MovieSequence.flip_y -> use_flip_y: boolean 'Flip on the Y axis'
|
||||
MovieSequence.mpeg_preseek -> mpeg_preseek: int 'For MPEG movies, preseek this many frames'
|
||||
MovieSequence.multiply_colors -> multiply_colors: float 'NO DESCRIPTION'
|
||||
MovieSequence.premultiply -> use_premultiply: boolean 'Convert RGB from key alpha to premultiplied alpha'
|
||||
MovieSequence.proxy -> proxy: pointer, '(read-only)'
|
||||
MovieSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean 'Use a custom directory to store data'
|
||||
MovieSequence.proxy_custom_file -> use_proxy_custom_file: boolean 'Use a custom file to read proxy data from'
|
||||
MovieSequence.reverse_frames -> use_reverse_frames: boolean 'Reverse frame order'
|
||||
MovieSequence.strobe -> strobe: float 'Only display every nth frame'
|
||||
MovieSequence.transform -> transform: pointer, '(read-only)'
|
||||
MovieSequence.use_color_balance -> use_color_balance: boolean '(3-Way color correction) on input'
|
||||
MovieSequence.use_crop -> use_crop: boolean 'Crop image before processing'
|
||||
MovieSequence.use_proxy -> use_proxy: boolean 'Use a preview proxy for this strip'
|
||||
MovieSequence.use_translation -> use_translation: boolean 'Translate image before processing'
|
||||
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.color_saturation -> color_saturation: float 'NO DESCRIPTION'
|
||||
MulticamSequence.convert_float -> use_float: boolean 'Convert input to float data'
|
||||
MulticamSequence.crop -> crop: pointer, '(read-only)'
|
||||
MulticamSequence.de_interlace -> use_deinterlace: boolean 'For video movies to remove fields'
|
||||
MulticamSequence.flip_x -> use_flip_x: boolean 'Flip on the X axis'
|
||||
MulticamSequence.flip_y -> use_flip_y: boolean 'Flip on the Y axis'
|
||||
MulticamSequence.multicam_source -> multicam_source: int 'NO DESCRIPTION'
|
||||
MulticamSequence.multiply_colors -> multiply_colors: float 'NO DESCRIPTION'
|
||||
MulticamSequence.premultiply -> use_premultiply: boolean 'Convert RGB from key alpha to premultiplied alpha'
|
||||
MulticamSequence.proxy -> proxy: pointer, '(read-only)'
|
||||
MulticamSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean 'Use a custom directory to store data'
|
||||
MulticamSequence.proxy_custom_file -> use_proxy_custom_file: boolean 'Use a custom file to read proxy data from'
|
||||
MulticamSequence.reverse_frames -> use_reverse_frames: boolean 'Reverse frame order'
|
||||
MulticamSequence.strobe -> strobe: float 'Only display every nth frame'
|
||||
MulticamSequence.transform -> transform: pointer, '(read-only)'
|
||||
MulticamSequence.use_color_balance -> use_color_balance: boolean '(3-Way color correction) on input'
|
||||
MulticamSequence.use_crop -> use_crop: boolean 'Crop image before processing'
|
||||
MulticamSequence.use_proxy -> use_proxy: boolean 'Use a preview proxy for this strip'
|
||||
MulticamSequence.use_translation -> use_translation: boolean 'Translate image before processing'
|
||||
MultiresModifier.external -> is_external: boolean, '(read-only) Store multires displacements outside the .blend file, to save memory'
|
||||
MultiresModifier.filepath -> filepath: string 'Path to external displacements file'
|
||||
MultiresModifier.levels -> levels: int 'Number of subdivisions to use in the viewport'
|
||||
MultiresModifier.optimal_display -> show_only_control_edges: boolean 'Skip drawing/rendering of interior subdivided edges'
|
||||
MultiresModifier.render_levels -> render_levels: int 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
NetRenderJob.name -> name: string 'NO DESCRIPTION'
|
||||
NetRenderSettings.active_blacklisted_slave_index -> active_blacklisted_slave_index: int 'NO DESCRIPTION'
|
||||
NetRenderSettings.active_job_index -> active_job_index: int 'NO DESCRIPTION'
|
||||
NetRenderSettings.active_slave_index -> active_slave_index: int 'NO DESCRIPTION'
|
||||
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.master_broadcast -> use_master_broadcast: boolean 'broadcast master server address on local network'
|
||||
NetRenderSettings.master_clear -> use_master_clear: boolean 'delete saved files on exit'
|
||||
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.slave_clear -> use_slave_clear: boolean 'delete downloaded files on exit'
|
||||
NetRenderSettings.slave_outputlog -> use_slave_output_log: boolean 'Output render text log to console as well as sending it to the master'
|
||||
NetRenderSettings.slave_thumb -> use_slave_thumb: boolean 'Generate thumbnails on slaves instead of master'
|
||||
NetRenderSettings.slaves -> slaves: collection, '(read-only)'
|
||||
NetRenderSettings.slaves_blacklist -> slaves_blacklist: collection, '(read-only)'
|
||||
NetRenderSlave.name -> name: string 'NO DESCRIPTION'
|
||||
NlaStrip.action -> action: pointer 'Action referenced by this strip'
|
||||
NlaStrip.action_frame_end -> action_frame_end: float 'NO DESCRIPTION'
|
||||
NlaStrip.action_frame_start -> action_frame_start: float 'NO DESCRIPTION'
|
||||
NlaStrip.active -> active: boolean, '(read-only) NLA Strip is active'
|
||||
NlaStrip.animated_influence -> use_animated_influence: boolean 'Influence setting is controlled by an F-Curve rather than automatically determined'
|
||||
NlaStrip.animated_time -> use_animated_time: boolean 'Strip time is controlled by an F-Curve rather than automatically determined'
|
||||
NlaStrip.animated_time_cyclic -> use_animated_time_cyclic: boolean 'Cycle the animated time within the action start & end'
|
||||
NlaStrip.auto_blending -> use_auto_blend: boolean 'Number of frames for Blending In/Out is automatically determined from overlapping strips'
|
||||
NlaStrip.blend_in -> blend_in: float 'Number of frames at start of strip to fade in influence'
|
||||
NlaStrip.blend_out -> blend_out: float 'NO DESCRIPTION'
|
||||
NlaStrip.blending -> blend_type: 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 'NO DESCRIPTION'
|
||||
NlaStrip.frame_start -> frame_start: float 'NO DESCRIPTION'
|
||||
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.mute -> mute: boolean 'NLA Strip is not evaluated'
|
||||
NlaStrip.name -> name: string 'NO DESCRIPTION'
|
||||
NlaStrip.repeat -> repeat: float 'Number of times to repeat the action range'
|
||||
NlaStrip.reversed -> use_reverse: boolean 'NLA Strip is played back in reverse order (only when timing is automatically determined)'
|
||||
NlaStrip.scale -> scale: float 'Scaling factor for action'
|
||||
NlaStrip.select -> select: boolean 'NLA Strip is selected'
|
||||
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.active -> active: boolean, '(read-only) NLA Track is active'
|
||||
NlaTrack.lock -> lock: boolean 'NLA Track is locked'
|
||||
NlaTrack.mute -> mute: boolean 'NLA Track is not evaluated'
|
||||
NlaTrack.name -> name: string 'NO DESCRIPTION'
|
||||
NlaTrack.select -> select: boolean 'NLA Track is selected'
|
||||
NlaTrack.solo -> is_solo: boolean, '(read-only) NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)'
|
||||
NlaTrack.strips -> strips: collection, '(read-only) NLA Strips on this NLA-track'
|
||||
Node.inputs -> inputs: collection, '(read-only)'
|
||||
Node.location -> location: float 'NO DESCRIPTION'
|
||||
Node.name -> name: string 'Node name'
|
||||
Node.outputs -> outputs: collection, '(read-only)'
|
||||
NodeGroup.nodetree -> nodetree: pointer 'NO DESCRIPTION'
|
||||
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_axis -> show_axis: boolean "Displays the object's origin and axis"
|
||||
Object.draw_bounds -> show_bounds: boolean "Displays the object's bounds"
|
||||
Object.draw_bounds_type -> draw_bounds_type: enum 'Object boundary display type'
|
||||
Object.draw_name -> show_name: boolean "Displays the object's name"
|
||||
Object.draw_texture_space -> show_texture_space: boolean "Displays the object's texture space"
|
||||
Object.draw_transparent -> show_transparent: boolean 'Enables transparent materials for the object (Mesh only)'
|
||||
Object.draw_wire -> show_wire: boolean "Adds the object's wireframe over solid drawing"
|
||||
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.duplis_used -> is_duplicator: boolean, '(read-only)'
|
||||
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.hide -> hide: boolean 'Restrict visibility in the viewport'
|
||||
Object.hide_render -> hide_render: boolean 'Restrict renderability'
|
||||
Object.hide_select -> hide_select: boolean 'Restrict selection in the viewport'
|
||||
Object.layers -> layers: boolean 'Layers the object is on'
|
||||
Object.location -> location: float 'Location of the object'
|
||||
Object.lock_location -> lock_location: boolean 'Lock editing of location in the interface'
|
||||
Object.lock_rotation -> lock_rotation: boolean 'Lock editing of rotation in the interface'
|
||||
Object.lock_rotation_w -> lock_rotation_w: boolean "Lock editing of 'angle' component of four-component rotations in the interface"
|
||||
Object.lock_rotations_4d -> lock_rotations_4d: boolean 'Lock editing of four component rotations by components (instead of as Eulers)'
|
||||
Object.lock_scale -> lock_scale: boolean 'Lock editing of scale in the interface'
|
||||
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 -> 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 'NO DESCRIPTION'
|
||||
Object.rotation_quaternion -> rotation_quaternion: float 'Rotation in Quaternions'
|
||||
Object.scale -> scale: float 'Scaling of the object'
|
||||
Object.select -> select: boolean 'Object selection state'
|
||||
Object.shape_key_edit_mode -> use_shape_key_edit_mode: boolean 'Apply shape keys in edit mode (for Meshes only)'
|
||||
Object.shape_key_lock -> show_shape_key: boolean 'Always show the current Shape for this Object'
|
||||
Object.slow_parent -> use_slow_parent: boolean 'Create a delay in the parent relationship'
|
||||
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.time_offset_add_parent -> use_time_offset_add_parent: boolean 'Add the parents time offset value'
|
||||
Object.time_offset_edit -> use_time_offset_edit: boolean 'Use time offset when inserting keys and display time offset for F-Curve and action views'
|
||||
Object.time_offset_parent -> use_time_offset_parent: boolean 'Apply the time offset to this objects parent relationship'
|
||||
Object.time_offset_particle -> use_time_offset_particle: boolean 'Let the time offset work on the particle effect'
|
||||
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.use_dupli_faces_scale -> use_dupli_faces_scale: boolean 'Scale dupli based on face size'
|
||||
Object.use_dupli_frames_speed -> use_dupli_frames_speed: boolean 'Set dupliframes to use the frame'
|
||||
Object.use_dupli_verts_rotation -> use_dupli_verts_rotation: boolean 'Rotate dupli according to vertex normal'
|
||||
Object.vertex_groups -> vertex_groups: collection, '(read-only) Vertex groups of the object'
|
||||
Object.x_ray -> show_x_ray: boolean 'Makes the object draw in front of others'
|
||||
ObjectActuator.add_linear_velocity -> use_add_linear_velocity: boolean 'Toggles between ADD and SET linV'
|
||||
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.local_angular_velocity -> use_local_angular_velocity: boolean 'Angular velocity is defined in local coordinates'
|
||||
ObjectActuator.local_force -> use_local_force: boolean 'Force is defined in local coordinates'
|
||||
ObjectActuator.local_linear_velocity -> use_local_linear_velocity: boolean 'Velocity is defined in local coordinates'
|
||||
ObjectActuator.local_location -> use_local_location: boolean 'Location is defined in local coordinates'
|
||||
ObjectActuator.local_rotation -> use_local_rotation: boolean 'Rotation is defined in local coordinates'
|
||||
ObjectActuator.local_torque -> use_local_torque: boolean 'Torque is defined in local coordinates'
|
||||
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.servo_limit_x -> use_servo_limit_x: boolean 'Set limit to force along the X axis'
|
||||
ObjectActuator.servo_limit_y -> use_servo_limit_y: boolean 'Set limit to force along the Y axis'
|
||||
ObjectActuator.servo_limit_z -> use_servo_limit_z: boolean 'Set limit to force along the Z axis'
|
||||
ObjectActuator.torque -> torque: float 'Sets the torque'
|
||||
ObjectBase.layers -> layers: boolean 'Layers the object base is on'
|
||||
ObjectBase.object -> object: pointer, '(read-only) Object this base links to'
|
||||
ObjectBase.select -> select: boolean 'Object base selection state'
|
||||
ObjectConstraints.active -> active: pointer 'Active Object constraint'
|
||||
ObstacleFluidSettings.active -> use: boolean 'Object contributes to the fluid simulation'
|
||||
ObstacleFluidSettings.export_animated_mesh -> use_animated_mesh: boolean 'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
|
||||
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 'NO DESCRIPTION'
|
||||
ObstacleFluidSettings.volume_initialization -> volume_initialization: enum 'Volume initialization type'
|
||||
Operator.bl_description -> bl_description: string 'NO DESCRIPTION'
|
||||
Operator.bl_idname -> bl_idname: string 'NO DESCRIPTION'
|
||||
Operator.bl_label -> bl_label: string 'NO DESCRIPTION'
|
||||
Operator.bl_options -> bl_options: enum 'Options for this operator type'
|
||||
Operator.has_reports -> has_reports: boolean, '(read-only) Operator has a set of reports (warnings and errors) from last execution'
|
||||
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 'NO DESCRIPTION'
|
||||
OperatorStrokeElement.mouse -> mouse: float 'NO DESCRIPTION'
|
||||
OperatorStrokeElement.pen_flip -> pen_flip: boolean 'NO DESCRIPTION'
|
||||
OperatorStrokeElement.pressure -> pressure: float 'Tablet pressure'
|
||||
OperatorStrokeElement.time -> time: float 'NO DESCRIPTION'
|
||||
OperatorTypeMacro.properties -> properties: pointer, '(read-only)'
|
||||
OutflowFluidSettings.active -> use: boolean 'Object contributes to the fluid simulation'
|
||||
OutflowFluidSettings.export_animated_mesh -> use_animated_mesh: boolean 'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
|
||||
OutflowFluidSettings.volume_initialization -> volume_initialization: enum 'Volume initialization type'
|
||||
PackedFile.size -> size: int, '(read-only) Size of packed file in bytes'
|
||||
Paint.brush -> brush: pointer 'Active paint brush'
|
||||
Paint.fast_navigate -> show_low_resolution: boolean 'For multires, show low resolution while navigating the view'
|
||||
Paint.show_brush -> show_brush: boolean 'NO DESCRIPTION'
|
||||
Paint.show_brush_on_surface -> show_brush_on_surface: boolean 'NO DESCRIPTION'
|
||||
Panel.bl_context -> bl_context: string 'NO DESCRIPTION'
|
||||
Panel.bl_default_closed -> bl_use_closed: boolean 'NO DESCRIPTION'
|
||||
Panel.bl_idname -> bl_idname: string 'NO DESCRIPTION'
|
||||
Panel.bl_label -> bl_label: string 'NO DESCRIPTION'
|
||||
Panel.bl_region_type -> bl_region_type: enum 'NO DESCRIPTION'
|
||||
Panel.bl_show_header -> bl_show_header: boolean 'NO DESCRIPTION'
|
||||
Panel.bl_space_type -> bl_space_type: enum 'NO DESCRIPTION'
|
||||
Panel.layout -> layout: pointer, '(read-only)'
|
||||
Panel.text -> text: string 'NO DESCRIPTION'
|
||||
ParentActuator.compound -> use_compound: boolean 'Add this object shape to the parent shape (only if the parent shape is already compound)'
|
||||
ParentActuator.ghost -> use_ghost: boolean 'Make this object ghost while parented (only if not compound)'
|
||||
ParentActuator.mode -> mode: enum 'NO DESCRIPTION'
|
||||
ParentActuator.object -> object: pointer 'Set this object as parent'
|
||||
Particle.alive_state -> alive_state: enum 'NO DESCRIPTION'
|
||||
Particle.angular_velocity -> angular_velocity: float 'NO DESCRIPTION'
|
||||
Particle.birthtime -> birthtime: float 'NO DESCRIPTION'
|
||||
Particle.die_time -> die_time: float 'NO DESCRIPTION'
|
||||
Particle.hair -> hair: collection, '(read-only)'
|
||||
Particle.is_existing -> is_existing: boolean, '(read-only)'
|
||||
Particle.is_visible -> is_visible: boolean, '(read-only)'
|
||||
Particle.keys -> keys: collection, '(read-only)'
|
||||
Particle.lifetime -> lifetime: float 'NO DESCRIPTION'
|
||||
Particle.location -> location: float 'NO DESCRIPTION'
|
||||
Particle.prev_angular_velocity -> prev_angular_velocity: float 'NO DESCRIPTION'
|
||||
Particle.prev_location -> prev_location: float 'NO DESCRIPTION'
|
||||
Particle.prev_rotation -> prev_rotation: float 'NO DESCRIPTION'
|
||||
Particle.prev_velocity -> prev_velocity: float 'NO DESCRIPTION'
|
||||
Particle.rotation -> rotation: float 'NO DESCRIPTION'
|
||||
Particle.size -> size: float 'NO DESCRIPTION'
|
||||
Particle.velocity -> velocity: float 'NO DESCRIPTION'
|
||||
ParticleBrush.count -> count: int 'Particle count'
|
||||
ParticleBrush.curve -> curve: pointer, '(read-only)'
|
||||
ParticleBrush.length_mode -> length_mode: enum 'NO DESCRIPTION'
|
||||
ParticleBrush.puff_mode -> puff_mode: enum 'NO DESCRIPTION'
|
||||
ParticleBrush.size -> size: int 'Brush size'
|
||||
ParticleBrush.steps -> steps: int 'Brush steps'
|
||||
ParticleBrush.strength -> strength: float 'Brush strength'
|
||||
ParticleBrush.use_puff_volume -> use_puff_volume: boolean 'Apply puff to unselected end-points, (helps maintain hair volume when puffing root)'
|
||||
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_interpolate -> use_add_interpolate: boolean 'Interpolate new particles from the existing ones'
|
||||
ParticleEdit.add_keys -> add_keys: int 'How many keys to make new particles with'
|
||||
ParticleEdit.auto_velocity -> use_auto_velocity: boolean 'Calculate point velocities automatically'
|
||||
ParticleEdit.brush -> brush: pointer, '(read-only)'
|
||||
ParticleEdit.draw_particles -> show_particles: boolean 'Draw actual particles'
|
||||
ParticleEdit.draw_step -> draw_step: int 'How many steps to draw the path with'
|
||||
ParticleEdit.editable -> is_editable: boolean, '(read-only) A valid edit mode exists'
|
||||
ParticleEdit.emitter_deflect -> use_emitter_deflect: boolean 'Keep paths from intersecting the emitter'
|
||||
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.fade_time -> use_fade_time: boolean 'Fade paths and keys further away from current frame'
|
||||
ParticleEdit.hair -> is_hair: boolean, '(read-only) Editing hair'
|
||||
ParticleEdit.keep_lengths -> use_preserve_lengths: boolean 'Keep path lengths constant'
|
||||
ParticleEdit.keep_root -> use_preserve_root: boolean 'Keep root keys unmodified'
|
||||
ParticleEdit.object -> object: pointer, '(read-only) The edited object'
|
||||
ParticleEdit.selection_mode -> selection_mode: enum 'Particle select and display mode'
|
||||
ParticleEdit.tool -> tool: enum 'NO DESCRIPTION'
|
||||
ParticleEdit.type -> type: enum 'NO DESCRIPTION'
|
||||
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.drops -> use_drops: boolean 'Show drop particles'
|
||||
ParticleFluidSettings.floats -> use_floats: boolean 'Show floating foam particles'
|
||||
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'
|
||||
ParticleFluidSettings.tracer -> use_tracer: boolean 'Show tracer particles'
|
||||
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.alive -> use_alive: boolean 'Show instances when particles are alive'
|
||||
ParticleInstanceModifier.axis -> axis: enum 'Pole axis for rotation'
|
||||
ParticleInstanceModifier.children -> use_children: boolean 'Create instances from child particles'
|
||||
ParticleInstanceModifier.dead -> use_dead: boolean 'Show instances when particles are dead'
|
||||
ParticleInstanceModifier.keep_shape -> use_preserve_shape: boolean "Don't stretch the object"
|
||||
ParticleInstanceModifier.normal -> use_normal: boolean 'Create instances from normal particles'
|
||||
ParticleInstanceModifier.object -> object: pointer 'Object that has the particle system'
|
||||
ParticleInstanceModifier.particle_system_number -> particle_system_number: int 'NO DESCRIPTION'
|
||||
ParticleInstanceModifier.position -> position: float 'Position along path'
|
||||
ParticleInstanceModifier.random_position -> random_position: float 'Randomize position along path'
|
||||
ParticleInstanceModifier.size -> use_size: boolean 'Use particle size to scale the instances'
|
||||
ParticleInstanceModifier.unborn -> use_unborn: boolean 'Show instances when particles are unborn'
|
||||
ParticleInstanceModifier.use_path -> use_path: boolean 'Create instances along particle paths'
|
||||
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.abs_path_time -> use_absolute_path_time: boolean 'Path timing is in absolute frames'
|
||||
ParticleSettings.active_dupliweight -> active_dupliweight: pointer, '(read-only)'
|
||||
ParticleSettings.active_dupliweight_index -> active_dupliweight_index: int 'NO DESCRIPTION'
|
||||
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.animate_branching -> use_animate_branching: boolean 'Animate branching'
|
||||
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_lock -> lock_billboard: boolean 'Lock the billboards align axis'
|
||||
ParticleSettings.billboard_object -> billboard_object: pointer 'Billboards face this object (default is active camera)'
|
||||
ParticleSettings.billboard_offset -> billboard_offset: float 'NO DESCRIPTION'
|
||||
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.boids_2d -> lock_boids_to_surface: boolean 'Constrain boids to a surface'
|
||||
ParticleSettings.branch_threshold -> branch_threshold: float 'Threshold of branching'
|
||||
ParticleSettings.branching -> use_branching: boolean 'Branch child paths from each other'
|
||||
ParticleSettings.brownian_factor -> brownian_factor: float 'Specify the amount of Brownian motion'
|
||||
ParticleSettings.child_effector -> apply_effector_to_children: boolean 'Apply effectors to children'
|
||||
ParticleSettings.child_guide -> apply_guide_to_children: boolean 'NO DESCRIPTION'
|
||||
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.die_on_collision -> use_die_on_collision: boolean 'Particles die when they collide with a deflector object'
|
||||
ParticleSettings.died -> use_died: boolean 'Show particles after they have died'
|
||||
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_health -> show_health: boolean 'Draw boid health'
|
||||
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.emitter -> use_render_emitter: boolean 'Render emitter Object also'
|
||||
ParticleSettings.enable_simplify -> use_simplify: boolean 'Remove child strands as the object becomes smaller on the screen'
|
||||
ParticleSettings.even_distribution -> use_even_distribution: boolean 'Use even distribution from faces based on face areas or edge lengths'
|
||||
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_invert -> invert_grid: boolean 'Invert what is considered object and what is not'
|
||||
ParticleSettings.grid_resolution -> grid_resolution: int 'The resolution of the particle grid'
|
||||
ParticleSettings.hair_bspline -> use_hair_bspline: boolean 'Interpolate hair using B-Splines'
|
||||
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 'NO DESCRIPTION'
|
||||
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.material_color -> show_material_color: boolean "Draw particles using material's diffuse color"
|
||||
ParticleSettings.normal_factor -> normal_factor: float 'Let the surface normal give the particle a starting speed'
|
||||
ParticleSettings.num -> show_number: boolean 'Show particle number'
|
||||
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.parent -> use_parents: boolean 'Render parent particles'
|
||||
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.rand_group -> use_group_pick_random: boolean 'Pick objects from group randomly'
|
||||
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.react_multiple -> use_react_multiple: boolean 'React multiple times'
|
||||
ParticleSettings.react_start_end -> use_react_start_end: boolean 'Give birth to unreacted particles eventually'
|
||||
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_adaptive -> use_render_adaptive: boolean 'Use adapative rendering for paths'
|
||||
ParticleSettings.render_step -> render_step: int 'How many steps paths are rendered with (power of 2)'
|
||||
ParticleSettings.render_strand -> use_strand_primitive: boolean 'Use the strand primitive for rendering'
|
||||
ParticleSettings.rendered_child_nbr -> rendered_child_nbr: int 'Amount of children/parent for rendering'
|
||||
ParticleSettings.rotate_from -> rotate_from: enum 'NO DESCRIPTION'
|
||||
ParticleSettings.rotation_dynamic -> use_dynamic_rotation: boolean 'Sets rotation to dynamic/constant'
|
||||
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.self_effect -> use_self_effect: boolean 'Particle effectors effect themselves'
|
||||
ParticleSettings.show_size -> show_size: boolean 'Show particle size'
|
||||
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.size_deflect -> use_size_deflect: boolean "Use particle's size in deflection"
|
||||
ParticleSettings.sizemass -> use_multiply_size_mass: boolean 'Multiply mass by particle size'
|
||||
ParticleSettings.subframes -> subframes: int 'Subframes to simulate for improved stability and finer granularity simulations'
|
||||
ParticleSettings.symmetric_branching -> use_symmetric_branching: boolean 'Start and end points are the same'
|
||||
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.trand -> use_emit_random: boolean 'Emit in random order of elements'
|
||||
ParticleSettings.type -> type: enum 'NO DESCRIPTION'
|
||||
ParticleSettings.unborn -> use_unborn: boolean 'Show particles before they are emitted'
|
||||
ParticleSettings.use_global_dupli -> use_global_dupli: boolean "Use object's global coordinates for duplication"
|
||||
ParticleSettings.use_group_count -> use_group_count: boolean 'Use object multiple times in the same group'
|
||||
ParticleSettings.userjit -> userjit: int 'Emission locations / face (0 = automatic)'
|
||||
ParticleSettings.velocity -> show_velocity: boolean 'Show particle velocity'
|
||||
ParticleSettings.velocity_length -> use_velocity_length: boolean 'Multiply line length by particle speed'
|
||||
ParticleSettings.viewport -> use_simplify_viewport: boolean 'NO DESCRIPTION'
|
||||
ParticleSettings.virtual_parents -> virtual_parents: float 'Relative amount of virtual parents'
|
||||
ParticleSettings.whole_group -> use_whole_group: boolean 'Use whole group at once'
|
||||
ParticleSystem.active_particle_target -> active_particle_target: pointer, '(read-only)'
|
||||
ParticleSystem.active_particle_target_index -> active_particle_target_index: int 'NO DESCRIPTION'
|
||||
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.editable -> is_editable: boolean, '(read-only) Particle system can be edited in particle mode'
|
||||
ParticleSystem.edited -> is_edited: boolean, '(read-only) Particle system has been edited in particle mode'
|
||||
ParticleSystem.global_hair -> is_global_hair: boolean, '(read-only) Hair keys are in global coordinate space'
|
||||
ParticleSystem.hair_dynamics -> use_hair_dynamics: boolean 'Enable hair dynamics using cloth simulation'
|
||||
ParticleSystem.keyed_timing -> use_keyed_timing: boolean 'Use key times'
|
||||
ParticleSystem.multiple_caches -> has_multiple_caches: boolean, '(read-only) Particle system has multiple point caches'
|
||||
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_clump_negate -> invert_vertex_group_clump: boolean 'Negate the effect of the clump vertex group'
|
||||
ParticleSystem.vertex_group_density -> vertex_group_density: string 'Vertex group to control density'
|
||||
ParticleSystem.vertex_group_density_negate -> invert_vertex_group_density: boolean 'Negate the effect of the density vertex group'
|
||||
ParticleSystem.vertex_group_field -> vertex_group_field: string 'Vertex group to control field'
|
||||
ParticleSystem.vertex_group_field_negate -> invert_vertex_group_field: boolean 'Negate the effect of the field vertex group'
|
||||
ParticleSystem.vertex_group_kink -> vertex_group_kink: string 'Vertex group to control kink'
|
||||
ParticleSystem.vertex_group_kink_negate -> invert_vertex_group_kink: boolean 'Negate the effect of the kink vertex group'
|
||||
ParticleSystem.vertex_group_length -> vertex_group_length: string 'Vertex group to control length'
|
||||
ParticleSystem.vertex_group_length_negate -> invert_vertex_group_length: boolean 'Negate the effect of the length vertex group'
|
||||
ParticleSystem.vertex_group_rotation -> vertex_group_rotation: string 'Vertex group to control rotation'
|
||||
ParticleSystem.vertex_group_rotation_negate -> invert_vertex_group_rotation: boolean 'Negate the effect of the rotation vertex group'
|
||||
ParticleSystem.vertex_group_roughness1 -> vertex_group_rough1: string 'Vertex group to control roughness 1'
|
||||
ParticleSystem.vertex_group_roughness1_negate -> invert_vertex_group_roughness1: boolean 'Negate the effect of the roughness 1 vertex group'
|
||||
ParticleSystem.vertex_group_roughness2 -> vertex_group_rough2: string 'Vertex group to control roughness 2'
|
||||
ParticleSystem.vertex_group_roughness2_negate -> invert_vertex_group_roughness2: boolean 'Negate the effect of the roughness 2 vertex group'
|
||||
ParticleSystem.vertex_group_roughness_end -> vertex_group_rough_end: string 'Vertex group to control roughness end'
|
||||
ParticleSystem.vertex_group_roughness_end_negate -> invert_vertex_group_roughness_end: boolean 'Negate the effect of the roughness end vertex group'
|
||||
ParticleSystem.vertex_group_size -> vertex_group_size: string 'Vertex group to control size'
|
||||
ParticleSystem.vertex_group_size_negate -> invert_vertex_group_size: boolean 'Negate the effect of the size vertex group'
|
||||
ParticleSystem.vertex_group_tangent -> vertex_group_tangent: string 'Vertex group to control tangent'
|
||||
ParticleSystem.vertex_group_tangent_negate -> invert_vertex_group_tangent: boolean 'Negate the effect of the tangent vertex group'
|
||||
ParticleSystem.vertex_group_velocity -> vertex_group_velocity: string 'Vertex group to control velocity'
|
||||
ParticleSystem.vertex_group_velocity_negate -> invert_vertex_group_velocity: boolean 'Negate the effect of the velocity vertex group'
|
||||
ParticleSystemModifier.particle_system -> particle_system: pointer, '(read-only) Particle System that this modifier controls'
|
||||
ParticleTarget.duration -> duration: float 'NO DESCRIPTION'
|
||||
ParticleTarget.mode -> mode: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
ParticleTarget.valid -> is_valid: boolean 'Keyed particles target is valid'
|
||||
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 'NO DESCRIPTION'
|
||||
PivotConstraint.target -> target: pointer 'Target Object, defining the position of the pivot when defined'
|
||||
PivotConstraint.use_relative_position -> use_relative_location: boolean 'Offset will be an absolute point in space instead of relative to the target'
|
||||
PluginSequence.filename -> filename: string, '(read-only)'
|
||||
PointCache.active_point_cache_index -> active_point_cache_index: int 'NO DESCRIPTION'
|
||||
PointCache.baked -> is_baked: boolean, '(read-only)'
|
||||
PointCache.baking -> is_baking: boolean, '(read-only)'
|
||||
PointCache.disk_cache -> use_disk_cache: boolean 'Save cache files to disk (.blend file must be saved first)'
|
||||
PointCache.external -> use_external: boolean 'Read cache from an external location'
|
||||
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.frames_skipped -> frames_skipped: boolean, '(read-only)'
|
||||
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.outdated -> is_outdated: boolean, '(read-only)'
|
||||
PointCache.point_cache_list -> point_cache_list: collection, '(read-only) Point cache list'
|
||||
PointCache.quick_cache -> use_quick_cache: boolean 'Update simulation with cache steps'
|
||||
PointCache.step -> step: int 'Number of frames between cached frames'
|
||||
PointCache.use_library_path -> use_library_path: boolean 'Use this files path when library linked into another file.'
|
||||
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_soft: 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 -> use_turbulence: boolean 'Add directed noise to the density at render-time'
|
||||
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 'NO DESCRIPTION'
|
||||
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.only_shadow -> use_only_shadow: boolean 'Causes light to cast shadows only without illuminating objects'
|
||||
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_layer -> use_shadow_layer: boolean 'Causes only objects on the same layer to cast shadows'
|
||||
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_sample_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)'
|
||||
PointLamp.sphere -> use_sphere: boolean 'Sets light intensity to zero beyond lamp distance'
|
||||
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.has_ik -> is_in_ik_chain: boolean, '(read-only) Is part of an IK chain'
|
||||
PoseBone.head -> head: float, "(read-only) Location of head of the channel's bone"
|
||||
NEGATE * PoseBone.ik_dof_x -> lock_ik_x: boolean 'Allow movement around the X axis'
|
||||
NEGATE * PoseBone.ik_dof_y -> lock_ik_y: boolean 'Allow movement around the Y axis'
|
||||
NEGATE * PoseBone.ik_dof_z -> lock_ik_z: boolean 'Allow movement around the Z axis'
|
||||
PoseBone.ik_limit_x -> lock_ik_x: boolean 'Limit movement around the X axis'
|
||||
PoseBone.ik_limit_y -> lock_ik_y: boolean 'Limit movement around the Y axis'
|
||||
PoseBone.ik_limit_z -> lock_ik_z: boolean 'Limit movement around the Z axis'
|
||||
PoseBone.ik_lin_control -> use_ik_lin_control: boolean 'Apply channel size as IK constraint if stretching is enabled'
|
||||
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_control -> use_ik_rot_control: boolean 'Apply channel rotation as IK constraint'
|
||||
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 'NO DESCRIPTION'
|
||||
PoseBone.lock_location -> lock_location: boolean 'Lock editing of location in the interface'
|
||||
PoseBone.lock_rotation -> lock_rotation: boolean 'Lock editing of rotation in the interface'
|
||||
PoseBone.lock_rotation_w -> lock_rotation_w: boolean "Lock editing of 'angle' component of four-component rotations in the interface"
|
||||
PoseBone.lock_rotations_4d -> lock_rotations_4d: boolean 'Lock editing of four component rotations by components (instead of as Eulers)'
|
||||
PoseBone.lock_scale -> lock_scale: boolean 'Lock editing of scale in the interface'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
PoseBone.rotation_quaternion -> rotation_quaternion: float 'Rotation in Quaternions'
|
||||
PoseBone.scale -> scale: float 'NO DESCRIPTION'
|
||||
PoseBone.select -> select: boolean 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
PoseTemplateSettings.active_template_index -> active_template_index: int 'NO DESCRIPTION'
|
||||
PoseTemplateSettings.generate_def_rig -> use_generate_deform_rig: boolean 'Create a copy of the metarig, constrainted by the generated rig'
|
||||
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.is_never_none -> is_never_none: boolean, "(read-only) True when this value can't be set to None"
|
||||
Property.is_readonly -> is_readonly: boolean, '(read-only) Property is editable through RNA'
|
||||
Property.is_required -> is_required: boolean, '(read-only) False when this property is an optional argument in an RNA function'
|
||||
Property.name -> name: string, '(read-only) Human readable name'
|
||||
Property.registered -> is_registered: boolean, '(read-only) Property is registered as part of type registration'
|
||||
Property.registered_optional -> is_registered_optional: boolean, '(read-only) Property is optionally registered as part of type registration'
|
||||
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'
|
||||
Property.use_output -> is_output: boolean, '(read-only) True when this property is an output value from an RNA function'
|
||||
PropertyActuator.mode -> mode: enum 'NO DESCRIPTION'
|
||||
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 -> value_max: string 'Specify maximum value in Interval type'
|
||||
PropertySensor.min_value -> value_min: string 'Specify minimum value in Interval type'
|
||||
PropertySensor.property -> property: string 'NO DESCRIPTION'
|
||||
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.script_error -> has_script_error: boolean, '(read-only) The linked Python script has thrown an error'
|
||||
PythonConstraint.targets -> targets: collection, '(read-only) Target Objects'
|
||||
PythonConstraint.text -> text: pointer 'The text object that contains the Python script'
|
||||
PythonConstraint.use_targets -> use_targets: boolean 'Use the targets indicated in the constraint panel'
|
||||
PythonController.debug -> use_debug: boolean 'Continuously reload the module from disk for editing external modules without restarting'
|
||||
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.always_true -> use_always_true: boolean 'Always false or always true'
|
||||
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'
|
||||
RaySensor.x_ray_mode -> use_x_ray: boolean "See through objects that don't have the 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.box_clip -> use_box_clip: boolean "Clip objects based on what's visible in other side views"
|
||||
RegionView3D.box_preview -> show_synced_view: boolean 'Sync view position between side views'
|
||||
RegionView3D.lock_rotation -> lock_rotation: boolean 'Lock view rotation in side views'
|
||||
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 'NO DESCRIPTION'
|
||||
RenderEngine.bl_label -> bl_label: string 'NO DESCRIPTION'
|
||||
RenderEngine.bl_postprocess -> bl_use_postprocess: boolean 'NO DESCRIPTION'
|
||||
RenderEngine.bl_preview -> bl_use_preview: boolean 'NO DESCRIPTION'
|
||||
RenderLayer.all_z -> use_all_z: boolean, '(read-only) Fill in Z values for solid faces in invisible layers, for masking'
|
||||
RenderLayer.edge -> use_edge_enhance: boolean, '(read-only) Render Edge-enhance in this Layer (only works for Solid faces)'
|
||||
RenderLayer.enabled -> use: boolean, '(read-only) Disable or enable the render layer'
|
||||
RenderLayer.halo -> use_halo: boolean, '(read-only) Render Halos in this Layer (on top of Solid)'
|
||||
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.pass_ao -> use_pass_ambient_occlusion: boolean, '(read-only) Deliver AO pass'
|
||||
RenderLayer.pass_ao_exclude -> exclude_ambient_occlusion: boolean, '(read-only) Exclude AO pass from combined'
|
||||
RenderLayer.pass_color -> use_pass_color: boolean, '(read-only) Deliver shade-less color pass'
|
||||
RenderLayer.pass_combined -> use_pass_combined: boolean, '(read-only) Deliver full combined RGBA buffer'
|
||||
RenderLayer.pass_diffuse -> use_pass_diffuse: boolean, '(read-only) Deliver diffuse pass'
|
||||
RenderLayer.pass_emit -> use_pass_emit: boolean, '(read-only) Deliver emission pass'
|
||||
RenderLayer.pass_emit_exclude -> exclude_emit: boolean, '(read-only) Exclude emission pass from combined'
|
||||
RenderLayer.pass_environment -> use_pass_environment: boolean, '(read-only) Deliver environment lighting pass'
|
||||
RenderLayer.pass_environment_exclude -> exclude_environment: boolean, '(read-only) Exclude environment pass from combined'
|
||||
RenderLayer.pass_indirect -> use_pass_indirect: boolean, '(read-only) Deliver indirect lighting pass'
|
||||
RenderLayer.pass_indirect_exclude -> exclude_indirect: boolean, '(read-only) Exclude indirect pass from combined'
|
||||
RenderLayer.pass_mist -> use_pass_mist: boolean, '(read-only) Deliver mist factor pass (0.0-1.0)'
|
||||
RenderLayer.pass_normal -> use_pass_normal: boolean, '(read-only) Deliver normal pass'
|
||||
RenderLayer.pass_object_index -> use_pass_object_index: boolean, '(read-only) Deliver object index pass'
|
||||
RenderLayer.pass_reflection -> use_pass_reflection: boolean, '(read-only) Deliver raytraced reflection pass'
|
||||
RenderLayer.pass_reflection_exclude -> exclude_reflection: boolean, '(read-only) Exclude raytraced reflection pass from combined'
|
||||
RenderLayer.pass_refraction -> use_pass_refraction: boolean, '(read-only) Deliver raytraced refraction pass'
|
||||
RenderLayer.pass_refraction_exclude -> exclude_refraction: boolean, '(read-only) Exclude raytraced refraction pass from combined'
|
||||
RenderLayer.pass_shadow -> use_pass_shadow: boolean, '(read-only) Deliver shadow pass'
|
||||
RenderLayer.pass_shadow_exclude -> exclude_shadow: boolean, '(read-only) Exclude shadow pass from combined'
|
||||
RenderLayer.pass_specular -> use_pass_specular: boolean, '(read-only) Deliver specular pass'
|
||||
RenderLayer.pass_specular_exclude -> exclude_specular: boolean, '(read-only) Exclude specular pass from combined'
|
||||
RenderLayer.pass_uv -> use_pass_uv: boolean, '(read-only) Deliver texture UV pass'
|
||||
RenderLayer.pass_vector -> use_pass_vector: boolean, '(read-only) Deliver speed vector pass'
|
||||
RenderLayer.pass_z -> use_pass_z: boolean, '(read-only) Deliver Z values pass'
|
||||
RenderLayer.passes -> passes: collection, '(read-only)'
|
||||
RenderLayer.rect -> rect: float 'NO DESCRIPTION'
|
||||
RenderLayer.sky -> use_sky: boolean, '(read-only) Render Sky in this Layer'
|
||||
RenderLayer.solid -> use_solid: boolean, '(read-only) Render Solid faces in this Layer'
|
||||
RenderLayer.strand -> use_strand: boolean, '(read-only) Render Strands in this Layer'
|
||||
RenderLayer.visible_layers -> layers: boolean, '(read-only) Scene layers included in this render layer'
|
||||
RenderLayer.zmask -> use_zmask: boolean, "(read-only) Only render what's in front of the solid z values"
|
||||
RenderLayer.zmask_layers -> layers_zmask: boolean, '(read-only) Zmask scene layers'
|
||||
RenderLayer.zmask_negate -> invert_zmask: boolean, '(read-only) For Zmask, only render what is behind solid z values instead of in front'
|
||||
RenderLayer.ztransp -> use_ztransp: boolean, '(read-only) Render Z-Transparent faces in this Layer (On top of Solid and Halos)'
|
||||
RenderPass.channel_id -> channel_id: string, '(read-only)'
|
||||
RenderPass.channels -> channels: int, '(read-only)'
|
||||
RenderPass.name -> name: string, '(read-only)'
|
||||
RenderPass.rect -> rect: float 'NO DESCRIPTION'
|
||||
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.backbuf -> use_backbuf: boolean 'Render backbuffer image'
|
||||
RenderSettings.bake_aa_mode -> bake_aa_mode: enum 'NO DESCRIPTION'
|
||||
RenderSettings.bake_active -> use_bake_active_to_selected: boolean 'Bake shading on the surface of selected objects to the active object'
|
||||
RenderSettings.bake_bias -> bake_bias: float 'Bias towards faces further away from the object (in blender units)'
|
||||
RenderSettings.bake_clear -> use_bake_clear: boolean 'Clear Images before baking'
|
||||
RenderSettings.bake_distance -> bake_distance: float 'Maximum distance from active object to other object (in blender units'
|
||||
RenderSettings.bake_enable_aa -> use_bake_antialiasing: boolean 'Enables Anti-aliasing'
|
||||
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_normalized -> use_bake_normalized: boolean 'With displacement normalize to the distance, with ambient occlusion normalize without using material settings'
|
||||
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_log -> use_cineon_log: boolean 'Convert to logarithmic color space'
|
||||
RenderSettings.cineon_white -> cineon_white: int 'Log conversion reference whitepoint'
|
||||
RenderSettings.color_management -> use_color_management: boolean 'Use color profiles and gamma corrected imaging pipeline'
|
||||
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.crop_to_border -> use_crop_to_border: boolean 'Crop the rendered frame to the defined border size'
|
||||
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 -> use_edge_enhance: boolean 'use_Create a toon outline around the edges of geometry'
|
||||
RenderSettings.edge_color -> edge_color: float 'NO DESCRIPTION'
|
||||
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.fields -> use_fields: boolean 'Render image to two fields per frame, for interlaced TV output'
|
||||
RenderSettings.fields_still -> use_fields_still: boolean 'Disable the time difference between fields'
|
||||
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.free_image_textures -> use_free_image_textures: boolean 'Free all image texture from memory after render, to save memory before compositing'
|
||||
RenderSettings.free_unused_nodes -> use_free_unused_nodes: boolean 'Free Nodes that are not used while compositing, to save memory'
|
||||
RenderSettings.full_sample -> use_full_sample: boolean 'Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing'
|
||||
RenderSettings.is_movie_format -> is_movie_format: boolean, '(read-only) When true the format is a movie'
|
||||
RenderSettings.layers -> layers: collection, '(read-only)'
|
||||
RenderSettings.motion_blur -> use_motion_blur: boolean 'Use multi-sampled 3D scene motion blur'
|
||||
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.multiple_engines -> has_multiple_engines: boolean, '(read-only) More than one rendering engine is available'
|
||||
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.render_antialiasing -> use_antialiasing: boolean 'Render and combine multiple samples per pixel to prevent jagged edges'
|
||||
RenderSettings.render_stamp -> use_stamp: boolean 'Render the stamp info text in the rendered image'
|
||||
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.save_buffers -> use_save_buffers: boolean 'Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample)'
|
||||
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.simplify_triangulate -> use_simplify_triangulate: boolean 'Disables non-planer quads being triangulated'
|
||||
RenderSettings.single_layer -> use_single_layer: boolean 'Only render the active layer'
|
||||
RenderSettings.stamp_background -> stamp_background: float 'Color to use behind stamp text'
|
||||
RenderSettings.stamp_camera -> use_stamp_camera: boolean 'Include the name of the active camera in image metadata'
|
||||
RenderSettings.stamp_date -> use_stamp_date: boolean 'Include the current date in image metadata'
|
||||
RenderSettings.stamp_filename -> use_stamp_filename: boolean 'Include the filename of the .blend file in image metadata'
|
||||
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_frame -> use_stamp_frame: boolean 'Include the frame number in image metadata'
|
||||
RenderSettings.stamp_marker -> use_stamp_marker: boolean 'Include the name of the last marker in image metadata'
|
||||
RenderSettings.stamp_note -> use_stamp_note: boolean 'Include a custom note in image metadata'
|
||||
RenderSettings.stamp_note_text -> stamp_note_text: string 'Custom text to appear in the stamp note'
|
||||
RenderSettings.stamp_render_time -> use_stamp_render_time: boolean 'Include the render time in the stamp image'
|
||||
RenderSettings.stamp_scene -> use_stamp_scene: boolean 'Include the name of the active scene in image metadata'
|
||||
RenderSettings.stamp_sequencer_strip -> use_stamp_sequencer_strip: boolean 'Include the name of the foreground sequence strip in image metadata'
|
||||
RenderSettings.stamp_time -> use_stamp_time: boolean 'Include the render frame as HH:MM:SS.FF in image metadata'
|
||||
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'
|
||||
RenderSettings.tiff_bit -> use_tiff_16bit: boolean 'Save TIFF with 16 bits per channel'
|
||||
RenderSettings.use_border -> use_border: boolean 'Render a user-defined border region, within the frame size. Note, this disables save_buffers and full_sample'
|
||||
RenderSettings.use_compositing -> use_compositing: boolean 'Process the render result through the compositing pipeline, if compositing nodes are enabled'
|
||||
RenderSettings.use_envmaps -> use_envmaps: boolean 'Calculate environment maps while rendering'
|
||||
RenderSettings.use_file_extension -> use_file_extension: boolean 'Add the file format extensions to the rendered file name (eg: filename + .jpg)'
|
||||
RenderSettings.use_game_engine -> use_game_engine: boolean, '(read-only) Current rendering engine is a game engine'
|
||||
RenderSettings.use_instances -> use_instances: boolean 'Instance support leads to effective memory reduction when using duplicates'
|
||||
RenderSettings.use_local_coords -> use_local_coords: boolean 'Vertex coordinates are stored localy on each primitive. Increases memory usage, but may have impact on speed'
|
||||
RenderSettings.use_overwrite -> use_overwrite: boolean 'Overwrite existing files while rendering'
|
||||
RenderSettings.use_placeholder -> use_placeholder: boolean "Create empty placeholder files while rendering frames (similar to Unix 'touch')"
|
||||
RenderSettings.use_radiosity -> use_radiosity: boolean 'Calculate radiosity in a pre-process before rendering'
|
||||
RenderSettings.use_raytracing -> use_raytrace: boolean 'Pre-calculate the raytrace accelerator and render raytracing effects'
|
||||
RenderSettings.use_sequencer -> use_sequencer: boolean 'Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist'
|
||||
RenderSettings.use_sequencer_gl_preview -> use_sequencer_gl_preview: boolean 'NO DESCRIPTION'
|
||||
RenderSettings.use_sequencer_gl_render -> use_sequencer_gl_render: boolean 'NO DESCRIPTION'
|
||||
RenderSettings.use_shadows -> use_shadows: boolean 'Calculate shadows while rendering'
|
||||
RenderSettings.use_simplify -> use_simplify: boolean 'Enable simplification of scene for quicker preview renders'
|
||||
RenderSettings.use_sss -> use_sss: boolean 'Calculate sub-surface scattering in materials rendering'
|
||||
RenderSettings.use_textures -> use_textures: boolean 'Use textures to affect material properties'
|
||||
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'
|
||||
NEGATE * RigidBodyJointConstraint.disable_linked_collision -> use_linked_collision: boolean 'Disable collision between linked bodies'
|
||||
RigidBodyJointConstraint.draw_pivot -> show_pivot: boolean 'Display the pivot point and rotation in 3D view'
|
||||
RigidBodyJointConstraint.pivot_type -> pivot_type: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
Scene.frame_drop -> use_frame_drop: boolean 'Play back dropping frames if frame display is too slow'
|
||||
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.layers -> layers: boolean 'Layers visible when rendering the scene'
|
||||
Scene.mute_audio -> mute_audio: boolean 'Play back of audio from Sequence Editor will be muted'
|
||||
Scene.network_render -> network_render: pointer, '(read-only) Network Render Settings'
|
||||
Scene.nla_tweakmode_on -> use_nla_tweakmode: boolean, '(read-only) Indicates whether there is any action referenced by NLA being edited. Strictly read-only'
|
||||
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.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.scrub_audio -> use_audio_scrub: boolean 'Play audio from Sequence Editor while scrubbing'
|
||||
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_audio -> use_audio_sync: boolean 'Play back and sync with audio clock, dropping frames if frame display is too slow'
|
||||
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.use_gravity -> use_gravity: boolean 'Use global gravity for all dynamics'
|
||||
Scene.use_nodes -> use_nodes: boolean 'Enable the compositing node tree'
|
||||
Scene.use_preview_range -> use_preview_range: boolean 'Use an alternative start/end frame for UI playback, rather than the scene start/end frame'
|
||||
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 'NO DESCRIPTION'
|
||||
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 -> use_activity_culling: boolean 'Activity culling is enabled'
|
||||
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.auto_start -> use_auto_start: boolean 'Automatically start game at load time'
|
||||
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 -> frame_color: float 'Set colour of the bars'
|
||||
SceneGameData.framing_type -> frame_type: enum 'Select the type of Framing you want'
|
||||
SceneGameData.frequency -> frequency: int 'Displays clock frequency of fullscreen display'
|
||||
SceneGameData.fullscreen -> show_fullscreen: boolean 'Starts player in a new fullscreen display'
|
||||
SceneGameData.glsl_extra_textures -> use_glsl_extra_textures: boolean 'Use extra textures like normal or specular maps for GLSL rendering'
|
||||
SceneGameData.glsl_lights -> use_glsl_lights: boolean 'Use lights for GLSL rendering'
|
||||
SceneGameData.glsl_nodes -> use_glsl_nodes: boolean 'Use nodes for GLSL rendering'
|
||||
SceneGameData.glsl_ramps -> use_glsl_ramps: boolean 'Use ramps for GLSL rendering'
|
||||
SceneGameData.glsl_shaders -> use_glsl_shaders: boolean 'Use shaders for GLSL rendering'
|
||||
SceneGameData.glsl_shadows -> use_glsl_shadows: boolean 'Use shadows for GLSL rendering'
|
||||
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.show_debug_properties -> show_debug_properties: boolean 'Show properties marked for debugging while the game runs'
|
||||
SceneGameData.show_framerate_profile -> show_framerate_profile: boolean 'Show framerate and profiling information while the game runs'
|
||||
SceneGameData.show_physics_visualization -> show_physics_visualization: boolean 'Show a visualization of physics bounds and interactions'
|
||||
SceneGameData.stereo -> stereo: enum 'NO DESCRIPTION'
|
||||
SceneGameData.stereo_mode -> stereo_mode: enum 'Stereographic techniques'
|
||||
SceneGameData.use_animation_record -> use_animation_record: boolean 'Record animation to fcurves'
|
||||
SceneGameData.use_deprecation_warnings -> use_deprecation_warnings: boolean 'Print warnings when using deprecated features in the python API'
|
||||
SceneGameData.use_display_lists -> use_display_lists: boolean 'Use display lists to speed up rendering by keeping geometry on the GPU'
|
||||
SceneGameData.use_frame_rate -> use_frame_rate: boolean 'Respect the frame rate rather than rendering as many frames as possible'
|
||||
SceneGameData.use_occlusion_culling -> use_occlusion_culling: boolean 'Use optimized Bullet DBVT tree for view frustum and occlusion culling'
|
||||
SceneObjects.active -> active: pointer 'Active object for this scene'
|
||||
SceneRenderLayer.all_z -> use_all_z: boolean 'Fill in Z values for solid faces in invisible layers, for masking'
|
||||
SceneRenderLayer.edge -> use_edge_enhance: boolean 'Render Edge-enhance in this Layer (only works for Solid faces)'
|
||||
SceneRenderLayer.enabled -> use: boolean 'Disable or enable the render layer'
|
||||
SceneRenderLayer.halo -> use_halo: boolean 'Render Halos in this Layer (on top of Solid)'
|
||||
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'
|
||||
SceneRenderLayer.pass_ao -> use_pass_ambient_occlusion: boolean 'Deliver AO pass'
|
||||
SceneRenderLayer.pass_ao_exclude -> exclude_ambient_occlusion: boolean 'Exclude AO pass from combined'
|
||||
SceneRenderLayer.pass_color -> use_pass_color: boolean 'Deliver shade-less color pass'
|
||||
SceneRenderLayer.pass_combined -> use_pass_combined: boolean 'Deliver full combined RGBA buffer'
|
||||
SceneRenderLayer.pass_diffuse -> use_pass_diffuse: boolean 'Deliver diffuse pass'
|
||||
SceneRenderLayer.pass_emit -> use_pass_emit: boolean 'Deliver emission pass'
|
||||
SceneRenderLayer.pass_emit_exclude -> exclude_emit: boolean 'Exclude emission pass from combined'
|
||||
SceneRenderLayer.pass_environment -> use_pass_environment: boolean 'Deliver environment lighting pass'
|
||||
SceneRenderLayer.pass_environment_exclude -> exclude_environment: boolean 'Exclude environment pass from combined'
|
||||
SceneRenderLayer.pass_indirect -> use_pass_indirect: boolean 'Deliver indirect lighting pass'
|
||||
SceneRenderLayer.pass_indirect_exclude -> exclude_indirect: boolean 'Exclude indirect pass from combined'
|
||||
SceneRenderLayer.pass_mist -> use_pass_mist: boolean 'Deliver mist factor pass (0.0-1.0)'
|
||||
SceneRenderLayer.pass_normal -> use_pass_normal: boolean 'Deliver normal pass'
|
||||
SceneRenderLayer.pass_object_index -> use_pass_object_index: boolean 'Deliver object index pass'
|
||||
SceneRenderLayer.pass_reflection -> use_pass_reflection: boolean 'Deliver raytraced reflection pass'
|
||||
SceneRenderLayer.pass_reflection_exclude -> exclude_reflection: boolean 'Exclude raytraced reflection pass from combined'
|
||||
SceneRenderLayer.pass_refraction -> use_pass_refraction: boolean 'Deliver raytraced refraction pass'
|
||||
SceneRenderLayer.pass_refraction_exclude -> exclude_refraction: boolean 'Exclude raytraced refraction pass from combined'
|
||||
SceneRenderLayer.pass_shadow -> use_pass_shadow: boolean 'Deliver shadow pass'
|
||||
SceneRenderLayer.pass_shadow_exclude -> exclude_shadow: boolean 'Exclude shadow pass from combined'
|
||||
SceneRenderLayer.pass_specular -> use_pass_specular: boolean 'Deliver specular pass'
|
||||
SceneRenderLayer.pass_specular_exclude -> exclude_specular: boolean 'Exclude specular pass from combined'
|
||||
SceneRenderLayer.pass_uv -> use_pass_uv: boolean 'Deliver texture UV pass'
|
||||
SceneRenderLayer.pass_vector -> use_pass_vector: boolean 'Deliver speed vector pass'
|
||||
SceneRenderLayer.pass_z -> use_pass_z: boolean 'Deliver Z values pass'
|
||||
SceneRenderLayer.sky -> use_sky: boolean 'Render Sky in this Layer'
|
||||
SceneRenderLayer.solid -> use_solid: boolean 'Render Solid faces in this Layer'
|
||||
SceneRenderLayer.strand -> use_strand: boolean 'Render Strands in this Layer'
|
||||
SceneRenderLayer.visible_layers -> layers: boolean 'Scene layers included in this render layer'
|
||||
SceneRenderLayer.zmask -> use_zmask: boolean "Only render what's in front of the solid z values"
|
||||
SceneRenderLayer.zmask_layers -> layers_zmask: boolean 'Zmask scene layers'
|
||||
SceneRenderLayer.zmask_negate -> invert_zmask: boolean 'For Zmask, only render what is behind solid z values instead of in front'
|
||||
SceneRenderLayer.ztransp -> use_ztransp: boolean 'Render Z-Transparent faces in this Layer (On top of Solid and Halos)'
|
||||
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.color_saturation -> color_saturation: float 'NO DESCRIPTION'
|
||||
SceneSequence.convert_float -> use_float: boolean 'Convert input to float data'
|
||||
SceneSequence.crop -> crop: pointer, '(read-only)'
|
||||
SceneSequence.de_interlace -> use_deinterlace: boolean 'For video movies to remove fields'
|
||||
SceneSequence.flip_x -> use_flip_x: boolean 'Flip on the X axis'
|
||||
SceneSequence.flip_y -> use_flip_y: boolean 'Flip on the Y axis'
|
||||
SceneSequence.multiply_colors -> multiply_colors: float 'NO DESCRIPTION'
|
||||
SceneSequence.premultiply -> use_premultiply: boolean 'Convert RGB from key alpha to premultiplied alpha'
|
||||
SceneSequence.proxy -> proxy: pointer, '(read-only)'
|
||||
SceneSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean 'Use a custom directory to store data'
|
||||
SceneSequence.proxy_custom_file -> use_proxy_custom_file: boolean 'Use a custom file to read proxy data from'
|
||||
SceneSequence.reverse_frames -> use_reverse_frames: boolean 'Reverse frame order'
|
||||
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)'
|
||||
SceneSequence.use_color_balance -> use_color_balance: boolean '(3-Way color correction) on input'
|
||||
SceneSequence.use_crop -> use_crop: boolean 'Crop image before processing'
|
||||
SceneSequence.use_proxy -> use_proxy: boolean 'Use a preview proxy for this strip'
|
||||
SceneSequence.use_translation -> use_translation: boolean 'Translate image before processing'
|
||||
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.use_full_resolution -> use_full_resolution: boolean 'Sample every pixel of the image'
|
||||
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 'NO DESCRIPTION'
|
||||
Screen.animation_playing -> is_animation_playing: boolean, '(read-only) Animation playback is active'
|
||||
Screen.areas -> areas: collection, '(read-only) Areas the screen is subdivided into'
|
||||
Screen.fullscreen -> is_fullscreen: boolean, '(read-only) An area is maximised, filling this screen'
|
||||
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'
|
||||
ScrewModifier.use_normal_calculate -> use_normal_calculate: boolean 'Calculate the order of edges (needed for meshes, but not curves)'
|
||||
ScrewModifier.use_normal_flip -> use_normal_flip: boolean 'Flip normals of lathed faces'
|
||||
ScrewModifier.use_object_screw_offset -> use_object_screw_offset: boolean 'Use the distance between the objects to make a screw'
|
||||
Sculpt.lock_x -> lock_x: boolean 'Disallow changes to the X axis of vertices'
|
||||
Sculpt.lock_y -> lock_y: boolean 'Disallow changes to the Y axis of vertices'
|
||||
Sculpt.lock_z -> lock_z: boolean 'Disallow changes to the Z axis of vertices'
|
||||
Sculpt.radial_symm -> radial_symm: int 'Number of times to copy strokes across the surface'
|
||||
Sculpt.symmetry_x -> use_symmetry_x: boolean 'Mirror brush across the X axis'
|
||||
Sculpt.symmetry_y -> use_symmetry_y: boolean 'Mirror brush across the Y axis'
|
||||
Sculpt.symmetry_z -> use_symmetry_z: boolean 'Mirror brush across the Z axis'
|
||||
Sculpt.use_openmp -> use_openmp: boolean 'Take advantage of multiple CPU cores to improve sculpting performance'
|
||||
Sculpt.use_symmetry_feather -> use_symmetry_feather: boolean 'Reduce the strength of the brush where it overlaps symmetrical daubs'
|
||||
Sensor.expanded -> show_expanded: boolean 'Set sensor expanded in the user interface'
|
||||
Sensor.frequency -> frequency: int 'Delay between repeated pulses(in logic tics, 0=no delay)'
|
||||
Sensor.invert -> invert: boolean 'Invert the level(output) of this sensor'
|
||||
Sensor.level -> use_level: boolean 'Level detector, trigger controllers of new states (only applicable upon logic state transition)'
|
||||
Sensor.name -> name: string 'Sensor name'
|
||||
Sensor.pinned -> pinned: boolean 'Display when not linked to a visible states controller'
|
||||
Sensor.pulse_false_level -> use_pulse_false_level: boolean 'Activate FALSE level triggering (pulse mode)'
|
||||
Sensor.pulse_true_level -> use_pulse_true_level: boolean 'Activate TRUE level triggering (pulse mode)'
|
||||
Sensor.tap -> use_tap: boolean 'Trigger controllers only for an instant, even while the sensor remains true'
|
||||
Sensor.type -> type: enum 'NO DESCRIPTION'
|
||||
Sequence.blend_mode -> blend_type: enum 'NO DESCRIPTION'
|
||||
Sequence.blend_opacity -> blend_opacity: float 'NO DESCRIPTION'
|
||||
Sequence.channel -> channel: int 'Y position of the sequence strip'
|
||||
Sequence.effect_fader -> effect_fader: float 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
Sequence.frame_still_end -> frame_still_end: int, '(read-only)'
|
||||
Sequence.frame_still_start -> frame_still_start: int, '(read-only)'
|
||||
Sequence.lock -> lock: boolean "Lock strip so that it can't be transformed"
|
||||
Sequence.mute -> mute: boolean 'NO DESCRIPTION'
|
||||
Sequence.name -> name: string 'NO DESCRIPTION'
|
||||
Sequence.select -> select: boolean 'NO DESCRIPTION'
|
||||
Sequence.select_left_handle -> select_left_handle: boolean 'NO DESCRIPTION'
|
||||
Sequence.select_right_handle -> select_right_handle: boolean 'NO DESCRIPTION'
|
||||
Sequence.speed_fader -> speed_fader: float 'NO DESCRIPTION'
|
||||
Sequence.type -> type: enum, '(read-only)'
|
||||
Sequence.use_effect_default_fade -> use_default_fade: boolean 'Fade effect using the built-in default (usually make transition as long as effect strip)'
|
||||
SequenceColorBalance.gain -> gain: float 'Color balance gain (highlights)'
|
||||
SequenceColorBalance.gamma -> gamma: float 'Color balance gamma (midtones)'
|
||||
SequenceColorBalance.inverse_gain -> invert_gain: boolean 'NO DESCRIPTION'
|
||||
SequenceColorBalance.inverse_gamma -> invert_gamma: boolean 'NO DESCRIPTION'
|
||||
SequenceColorBalance.inverse_lift -> invert_lift: boolean 'NO DESCRIPTION'
|
||||
SequenceColorBalance.lift -> lift: float 'Color balance lift (shadows)'
|
||||
SequenceCrop.bottom -> bottom: int 'NO DESCRIPTION'
|
||||
SequenceCrop.left -> left: int 'NO DESCRIPTION'
|
||||
SequenceCrop.right -> right: int 'NO DESCRIPTION'
|
||||
SequenceCrop.top -> top: int 'NO DESCRIPTION'
|
||||
SequenceEditor.active_strip -> active_strip: pointer 'NO DESCRIPTION'
|
||||
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.overlay_lock -> overlay_lock: boolean 'NO DESCRIPTION'
|
||||
SequenceEditor.sequences -> sequences: collection, '(read-only)'
|
||||
SequenceEditor.sequences_all -> sequences_all: collection, '(read-only)'
|
||||
SequenceEditor.show_overlay -> show_overlay: boolean 'Partial overlay ontop of the sequencer'
|
||||
SequenceElement.filename -> filename: string 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
SequenceTransform.offset_y -> offset_y: int 'NO DESCRIPTION'
|
||||
ShaderNode.type -> type: enum, '(read-only)'
|
||||
ShaderNodeExtendedMaterial.diffuse -> use_diffuse: boolean 'Material Node outputs Diffuse'
|
||||
ShaderNodeExtendedMaterial.invert_normal -> invert_normal: boolean 'Material Node uses inverted normal'
|
||||
ShaderNodeExtendedMaterial.material -> material: pointer 'NO DESCRIPTION'
|
||||
ShaderNodeExtendedMaterial.specular -> use_specular: boolean 'Material Node outputs Specular'
|
||||
ShaderNodeGeometry.color_layer -> color_layer: string 'NO DESCRIPTION'
|
||||
ShaderNodeGeometry.uv_layer -> uv_layer: string 'NO DESCRIPTION'
|
||||
ShaderNodeMapping.clamp_maximum -> use_max: boolean 'Clamp the output coordinate to a maximum value'
|
||||
ShaderNodeMapping.clamp_minimum -> use_min: boolean 'Clamp the output coordinate to a minimum value'
|
||||
ShaderNodeMapping.location -> location: float 'Location offset for the input coordinate'
|
||||
ShaderNodeMapping.maximum -> max: float 'Maximum value to clamp coordinate to'
|
||||
ShaderNodeMapping.minimum -> min: 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.diffuse -> use_diffuse: boolean 'Material Node outputs Diffuse'
|
||||
ShaderNodeMaterial.invert_normal -> invert_normal: boolean 'Material Node uses inverted normal'
|
||||
ShaderNodeMaterial.material -> material: pointer 'NO DESCRIPTION'
|
||||
ShaderNodeMaterial.specular -> use_specular: boolean 'Material Node outputs Specular'
|
||||
ShaderNodeMath.operation -> operation: enum 'NO DESCRIPTION'
|
||||
ShaderNodeMixRGB.alpha -> use_alpha: boolean 'Include alpha of second input in this operation'
|
||||
ShaderNodeMixRGB.blend_type -> blend_type: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
ShaderNodeValToRGB.color_ramp -> color_ramp: pointer, '(read-only)'
|
||||
ShaderNodeVectorCurve.mapping -> mapping: pointer, '(read-only)'
|
||||
ShaderNodeVectorMath.operation -> operation: enum 'NO DESCRIPTION'
|
||||
ShapeActionActuator.action -> action: pointer 'NO DESCRIPTION'
|
||||
ShapeActionActuator.blendin -> blendin: int 'Number of frames of motion blending'
|
||||
ShapeActionActuator.continue_last_frame -> use_continue_last_frame: boolean 'Restore last frame when switching on/off, otherwise play from the start each time'
|
||||
ShapeActionActuator.frame_end -> frame_end: int 'NO DESCRIPTION'
|
||||
ShapeActionActuator.frame_property -> frame_property: string "Assign the action's current frame number to this property"
|
||||
ShapeActionActuator.frame_start -> frame_start: int 'NO DESCRIPTION'
|
||||
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.mute -> mute: boolean 'Mute this shape key'
|
||||
ShapeKey.name -> name: string 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
ShapeKeyBezierPoint.handle_1_co -> handle_1_co: float 'NO DESCRIPTION'
|
||||
ShapeKeyBezierPoint.handle_2_co -> handle_2_co: float 'NO DESCRIPTION'
|
||||
ShapeKeyCurvePoint.co -> co: float 'NO DESCRIPTION'
|
||||
ShapeKeyCurvePoint.tilt -> tilt: float 'NO DESCRIPTION'
|
||||
ShapeKeyPoint.co -> co: float 'NO DESCRIPTION'
|
||||
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'
|
||||
ShrinkwrapConstraint.use_x -> use_x: boolean 'Projection over X Axis'
|
||||
ShrinkwrapConstraint.use_y -> use_y: boolean 'Projection over Y Axis'
|
||||
ShrinkwrapConstraint.use_z -> use_z: boolean 'Projection over Z Axis'
|
||||
ShrinkwrapModifier.auxiliary_target -> auxiliary_target: pointer 'Additional mesh target to shrink to'
|
||||
ShrinkwrapModifier.cull_back_faces -> use_cull_back_faces: boolean 'Stop vertices from projecting to a back face on the target'
|
||||
ShrinkwrapModifier.cull_front_faces -> use_cull_front_faces: boolean 'Stop vertices from projecting to a front face on the target'
|
||||
ShrinkwrapModifier.keep_above_surface -> use_keep_above_surface: boolean 'NO DESCRIPTION'
|
||||
ShrinkwrapModifier.mode -> mode: enum 'NO DESCRIPTION'
|
||||
ShrinkwrapModifier.negative -> use_negative_direction: boolean 'Allow vertices to move in the negative direction of axis'
|
||||
ShrinkwrapModifier.offset -> offset: float 'Distance to keep from the target'
|
||||
ShrinkwrapModifier.positive -> use_positive_direction: boolean 'Allow vertices to move in the positive direction of axis'
|
||||
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'
|
||||
ShrinkwrapModifier.x -> use_project_x: boolean 'NO DESCRIPTION'
|
||||
ShrinkwrapModifier.y -> use_project_y: boolean 'NO DESCRIPTION'
|
||||
ShrinkwrapModifier.z -> use_project_z: boolean 'NO DESCRIPTION'
|
||||
SimpleDeformModifier.factor -> factor: float 'NO DESCRIPTION'
|
||||
SimpleDeformModifier.limits -> limits: float 'Lower/Upper limits for deform'
|
||||
SimpleDeformModifier.lock_x_axis -> lock_x: boolean 'NO DESCRIPTION'
|
||||
SimpleDeformModifier.lock_y_axis -> lock_y: boolean 'NO DESCRIPTION'
|
||||
SimpleDeformModifier.mode -> mode: enum 'NO DESCRIPTION'
|
||||
SimpleDeformModifier.origin -> origin: pointer 'Origin of modifier space coordinates'
|
||||
SimpleDeformModifier.relative -> use_relative: boolean 'Sets the origin of deform space to be relative to the object'
|
||||
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_smoke -> use_dissolve_smoke: boolean 'Enable smoke to disappear over time'
|
||||
SmokeDomainSettings.dissolve_smoke_log -> use_dissolve_smoke_log: boolean 'Using 1/x'
|
||||
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.highres -> use_high_resolution: boolean 'Enable high resolution (using amplification)'
|
||||
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.smoke_domain_colli -> smoke_domain_colli: enum 'Selects which domain border will be treated as collision object.'
|
||||
SmokeDomainSettings.smoothemitter -> smoothemitter: boolean 'Smoothens emitted smoke to avoid blockiness.'
|
||||
SmokeDomainSettings.strength -> strength: float 'Strength of wavelet noise'
|
||||
SmokeDomainSettings.time_scale -> time_scale: float 'Adjust simulation speed.'
|
||||
SmokeDomainSettings.viewhighres -> show_high_resolution: boolean 'Show high resolution (using amplification)'
|
||||
SmokeDomainSettings.vorticity -> vorticity: float 'Amount of turbulence/rotation in fluid.'
|
||||
SmokeFlowSettings.absolute -> absolute: boolean 'Only allows given density value in emitter area.'
|
||||
SmokeFlowSettings.density -> density: float 'NO DESCRIPTION'
|
||||
SmokeFlowSettings.initial_velocity -> initial_velocity: boolean "Smoke inherits it's velocity from the emitter particle"
|
||||
NEGATE * SmokeFlowSettings.outflow -> use_outflow: boolean 'Deletes smoke from simulation'
|
||||
SmokeFlowSettings.psys -> psys: pointer 'Particle systems emitted from the object'
|
||||
SmokeFlowSettings.temperature -> temperature: float 'Temperature difference to ambient temperature'
|
||||
SmokeFlowSettings.velocity_multiplier -> velocity_multiplier: float 'Multiplier to adjust velocity passed to smoke'
|
||||
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 'NO DESCRIPTION'
|
||||
SmoothModifier.factor -> factor: float 'NO DESCRIPTION'
|
||||
SmoothModifier.repeat -> repeat: int 'NO DESCRIPTION'
|
||||
SmoothModifier.vertex_group -> vertex_group: string 'Vertex group name'
|
||||
SmoothModifier.x -> use_x: boolean 'NO DESCRIPTION'
|
||||
SmoothModifier.y -> use_y: boolean 'NO DESCRIPTION'
|
||||
SmoothModifier.z -> use_z: boolean 'NO DESCRIPTION'
|
||||
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.auto_step -> use_auto_step: boolean 'Use velocities for automagic step sizes'
|
||||
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 -> bend: 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.diagnose -> use_diagnose: boolean 'Turn on SB diagnose console prints'
|
||||
SoftBodySettings.edge_collision -> use_edge_collision: boolean 'Edges collide too'
|
||||
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.estimate_matrix -> use_estimate_matrix: boolean 'estimate matrix .. split to COM , ROT ,SCALE'
|
||||
SoftBodySettings.face_collision -> use_face_collision: boolean 'Faces collide too, SLOOOOOW warning'
|
||||
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 -> step_max: int 'Maximal # solver steps/frame'
|
||||
SoftBodySettings.minstep -> step_min: 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.self_collision -> use_self_collision: boolean 'Enable naive vertex ball self collision'
|
||||
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'
|
||||
SoftBodySettings.stiff_quads -> use_stiff_quads: boolean 'Adds diagonal springs on 4-gons'
|
||||
SoftBodySettings.use_edges -> use_edges: boolean 'Use Edges as springs'
|
||||
SoftBodySettings.use_goal -> use_goal: boolean 'Define forces for vertices to stick to animated position'
|
||||
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.invert -> invert_vertex_group: boolean 'Invert the vertex group influence'
|
||||
SolidifyModifier.offset -> offset: float 'NO DESCRIPTION'
|
||||
SolidifyModifier.thickness -> thickness: float 'Thickness of the shell'
|
||||
SolidifyModifier.use_even_offset -> use_even_offset: boolean 'Maintain thickness by adjusting for sharp corners (slow, disable when not needed)'
|
||||
SolidifyModifier.use_quality_normals -> use_quality_normals: boolean 'Calculate normals which result in more even thickness (slow, disable when not needed)'
|
||||
SolidifyModifier.use_rim -> use_rim: boolean 'Create edge loops between the inner and outer surfaces on face edges (slow, disable when not needed)'
|
||||
SolidifyModifier.use_rim_material -> use_rim_material: boolean 'Use in the next material for rim faces'
|
||||
SolidifyModifier.vertex_group -> vertex_group: string 'Vertex group name'
|
||||
Sound.caching -> use_ram_cache: boolean 'The sound file is decoded and loaded into RAM'
|
||||
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.enable_sound_3d -> use_3d_sound: boolean 'Enable/Disable 3D Sound'
|
||||
SoundActuator.max_distance_3d -> distance_3d_max: float 'The maximum distance at which you can hear the sound'
|
||||
SoundActuator.maximum_gain_3d -> gain_3d_max: float 'The maximum gain of the sound, no matter how near it is'
|
||||
SoundActuator.minimum_gain_3d -> gain_3d_min: float 'The minimum gain of the sound, no matter how far it is away'
|
||||
SoundActuator.mode -> mode: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
SpaceConsole.selection_start -> selection_start: int 'NO DESCRIPTION'
|
||||
SpaceConsole.show_report_debug -> show_report_debug: boolean 'Display debug reporting info'
|
||||
SpaceConsole.show_report_error -> show_report_error: boolean 'Display error text'
|
||||
SpaceConsole.show_report_info -> show_report_info: boolean 'Display general information'
|
||||
SpaceConsole.show_report_operator -> show_report_operator: boolean 'Display the operator log'
|
||||
SpaceConsole.show_report_warn -> show_report_warning: boolean 'Display warnings'
|
||||
SpaceDopeSheetEditor.action -> action: pointer 'Action displayed and edited in this space'
|
||||
SpaceDopeSheetEditor.automerge_keyframes -> use_automerge_keyframes: boolean 'Automatically merge nearby keyframes'
|
||||
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'
|
||||
SpaceDopeSheetEditor.realtime_updates -> use_realtime_updates: boolean 'When transforming keyframes, changes to the animation data are flushed to other views'
|
||||
SpaceDopeSheetEditor.show_cframe_indicator -> show_frame_indicator: boolean 'Show frame number beside the current frame indicator line'
|
||||
SpaceDopeSheetEditor.show_seconds -> show_seconds: boolean, '(read-only) Show timing in seconds not frames'
|
||||
SpaceDopeSheetEditor.show_sliders -> show_sliders: boolean 'Show sliders beside F-Curve channels'
|
||||
SpaceDopeSheetEditor.use_marker_sync -> use_marker_sync: boolean 'Sync Markers with keyframe edits'
|
||||
SpaceFileBrowser.params -> params: pointer, '(read-only) Parameters and Settings for the Filebrowser'
|
||||
SpaceGraphEditor.automerge_keyframes -> use_automerge_keyframes: boolean 'Automatically merge nearby keyframes'
|
||||
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.has_ghost_curves -> has_ghost_curves: boolean 'Graph Editor instance has some ghost curves stored'
|
||||
SpaceGraphEditor.mode -> mode: enum 'Editing context being displayed'
|
||||
SpaceGraphEditor.only_selected_curves_handles -> use_only_selected_curves_handles: boolean 'Only keyframes of selected F-Curves are visible and editable'
|
||||
SpaceGraphEditor.only_selected_keyframe_handles -> use_only_selected_keyframe_handles: boolean 'Only show and edit handles of selected keyframes'
|
||||
SpaceGraphEditor.pivot_point -> pivot_point: enum 'Pivot center for rotation/scaling'
|
||||
SpaceGraphEditor.realtime_updates -> use_realtime_updates: boolean 'When transforming keyframes, changes to the animation data are flushed to other views'
|
||||
SpaceGraphEditor.show_cframe_indicator -> show_frame_indicator: boolean 'Show frame number beside the current frame indicator line'
|
||||
SpaceGraphEditor.show_cursor -> show_cursor: boolean 'Show 2D cursor'
|
||||
SpaceGraphEditor.show_handles -> show_handles: boolean 'Show handles of Bezier control points'
|
||||
SpaceGraphEditor.show_seconds -> show_seconds: boolean, '(read-only) Show timing in seconds not frames'
|
||||
SpaceGraphEditor.show_sliders -> show_sliders: boolean 'Show sliders beside F-Curve channels'
|
||||
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.draw_repeated -> show_repeated: boolean 'Draw the image repeated outside of the main view'
|
||||
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_painting -> use_image_paint: boolean 'Enable image painting mode'
|
||||
SpaceImageEditor.image_pin -> use_image_pin: boolean 'Display current image regardless of object selection'
|
||||
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.show_paint -> show_paint: boolean, '(read-only) Show paint related properties'
|
||||
SpaceImageEditor.show_render -> show_render: boolean, '(read-only) Show render related properties'
|
||||
SpaceImageEditor.show_uvedit -> show_uvedit: boolean, '(read-only) Show UV editing related properties'
|
||||
SpaceImageEditor.update_automatically -> use_realtime_updates: boolean 'Update other affected window spaces automatically to reflect changes during interactive operations such as transform'
|
||||
SpaceImageEditor.use_grease_pencil -> use_grease_pencil: boolean 'Display and edit the grease pencil freehand annotations overlay'
|
||||
SpaceImageEditor.uv_editor -> uv_editor: pointer, '(read-only) UV editor settings'
|
||||
SpaceLogicEditor.actuators_show_active_objects -> show_actuators_active_objects: boolean 'Show actuators of active object'
|
||||
SpaceLogicEditor.actuators_show_active_states -> show_actuators_active_states: boolean 'Show only actuators connected to active states'
|
||||
SpaceLogicEditor.actuators_show_linked_controller -> show_actuators_linked_controller: boolean 'Show linked objects to the actuator'
|
||||
SpaceLogicEditor.actuators_show_selected_objects -> show_actuators_selected_objects: boolean 'Show actuators of all selected objects'
|
||||
SpaceLogicEditor.controllers_show_active_objects -> show_controllers_active_objects: boolean 'Show controllers of active object'
|
||||
SpaceLogicEditor.controllers_show_linked_controller -> show_controllers_linked_controller: boolean 'Show linked objects to sensor/actuator'
|
||||
SpaceLogicEditor.controllers_show_selected_objects -> show_controllers_selected_objects: boolean 'Show controllers of all selected objects'
|
||||
SpaceLogicEditor.sensors_show_active_objects -> show_sensors_active_objects: boolean 'Show sensors of active object'
|
||||
SpaceLogicEditor.sensors_show_active_states -> show_sensors_active_states: boolean 'Show only sensors connected to active states'
|
||||
SpaceLogicEditor.sensors_show_linked_controller -> show_sensors_linked_controller: boolean 'Show linked objects to the controller'
|
||||
SpaceLogicEditor.sensors_show_selected_objects -> show_sensors_selected_objects: boolean 'Show sensors of all selected objects'
|
||||
SpaceNLA.autosnap -> autosnap: enum 'Automatic time snapping settings for transformations'
|
||||
SpaceNLA.dopesheet -> dopesheet: pointer, '(read-only) Settings for filtering animation data'
|
||||
SpaceNLA.realtime_updates -> use_realtime_updates: boolean 'When transforming strips, changes to the animation data are flushed to other views'
|
||||
SpaceNLA.show_cframe_indicator -> show_frame_indicator: boolean 'Show frame number beside the current frame indicator line'
|
||||
SpaceNLA.show_seconds -> show_seconds: boolean, '(read-only) Show timing in seconds not frames'
|
||||
SpaceNLA.show_strip_curves -> show_strip_curves: boolean 'Show influence curves on strips'
|
||||
SpaceNodeEditor.backdrop -> show_backdrop: boolean 'Use active Viewer Node output as backdrop for compositing nodes'
|
||||
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'
|
||||
SpaceOutliner.match_case_sensitive -> use_match_case_sensitive: boolean 'Only use case sensitive matches of search string'
|
||||
SpaceOutliner.match_complete -> use_match_complete: boolean 'Only use complete matches of search string'
|
||||
SpaceOutliner.show_restriction_columns -> show_restriction_columns: boolean 'Show column'
|
||||
SpaceProperties.align -> align: enum 'Arrangement of the panels'
|
||||
SpaceProperties.brush_texture -> show_brush_texture: boolean 'Show brush textures'
|
||||
SpaceProperties.context -> context: enum 'Type of active data to display and edit'
|
||||
SpaceProperties.pin_id -> pin_id: pointer 'NO DESCRIPTION'
|
||||
SpaceProperties.use_pin_id -> use_pin_id: boolean 'Use the pinned context'
|
||||
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_frames -> show_frames: boolean 'Draw frames rather than seconds'
|
||||
SpaceSequenceEditor.draw_overexposed -> draw_overexposed: int 'Show overexposed areas with zebra stripes'
|
||||
SpaceSequenceEditor.draw_safe_margin -> show_safe_margin: boolean 'Draw title safe margins in preview'
|
||||
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.separate_color_preview -> show_separate_color: boolean 'Separate color channels in preview'
|
||||
SpaceSequenceEditor.show_cframe_indicator -> show_frame_indicator: boolean 'Show frame number beside the current frame indicator line'
|
||||
SpaceSequenceEditor.use_grease_pencil -> use_grease_pencil: boolean 'Display and edit the grease pencil freehand annotations overlay'
|
||||
SpaceSequenceEditor.use_marker_sync -> use_marker_sync: boolean 'Transform markers as well as strips'
|
||||
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_all -> use_find_all: boolean 'Search in all text datablocks, instead of only the active one'
|
||||
SpaceTextEditor.find_text -> find_text: string 'Text to search for with the find tool'
|
||||
SpaceTextEditor.find_wrap -> use_find_wrap: boolean 'Search again from the start of the file when reaching the end'
|
||||
SpaceTextEditor.font_size -> font_size: int 'Font size to use for displaying the text'
|
||||
SpaceTextEditor.line_numbers -> show_line_numbers: boolean 'Show line numbers next to the text'
|
||||
SpaceTextEditor.live_edit -> use_live_edit: boolean 'Run python while editing'
|
||||
SpaceTextEditor.overwrite -> use_overwrite: boolean 'Overwrite characters when typing rather than inserting them'
|
||||
SpaceTextEditor.replace_text -> replace_text: string 'Text to replace selected text with using the replace tool'
|
||||
SpaceTextEditor.syntax_highlight -> show_syntax_highlight: boolean 'Syntax highlight for scripting'
|
||||
SpaceTextEditor.tab_width -> tab_width: int 'Number of spaces to display tabs with'
|
||||
SpaceTextEditor.text -> text: pointer 'Text displayed and edited in this space'
|
||||
SpaceTextEditor.word_wrap -> use_word_wrap: boolean 'Wrap words if there is not enough horizontal space'
|
||||
SpaceTimeline.cache_cloth -> cache_cloth: boolean "Show the active object's cloth point cache"
|
||||
SpaceTimeline.cache_particles -> cache_particles: boolean "Show the active object's particle point cache"
|
||||
SpaceTimeline.cache_smoke -> cache_smoke: boolean "Show the active object's smoke cache"
|
||||
SpaceTimeline.cache_softbody -> cache_softbody: boolean "Show the active object's softbody point cache"
|
||||
SpaceTimeline.only_selected -> show_only_selected: boolean 'Show keyframes for active Object and/or its selected channels only'
|
||||
SpaceTimeline.play_all_3d -> use_play_3d_editors: boolean 'NO DESCRIPTION'
|
||||
SpaceTimeline.play_anim -> use_play_animation_editors: boolean 'NO DESCRIPTION'
|
||||
SpaceTimeline.play_buttons -> use_play_properties_editors: boolean 'NO DESCRIPTION'
|
||||
SpaceTimeline.play_image -> use_play_image_editors: boolean 'NO DESCRIPTION'
|
||||
SpaceTimeline.play_nodes -> use_play_node_editors: boolean 'NO DESCRIPTION'
|
||||
SpaceTimeline.play_sequencer -> use_play_sequence_editors: boolean 'NO DESCRIPTION'
|
||||
SpaceTimeline.play_top_left -> use_play_top_left_3d_editor: boolean 'NO DESCRIPTION'
|
||||
SpaceTimeline.show_cache -> show_cache: boolean 'Show the status of cached frames in the timeline'
|
||||
SpaceTimeline.show_cframe_indicator -> show_frame_indicator: boolean 'Show frame number beside the current frame indicator line'
|
||||
SpaceUVEditor.constrain_to_image_bounds -> use_constrain_to_image_bounds: boolean 'Constraint to stay within the image bounds while editing'
|
||||
SpaceUVEditor.cursor_location -> cursor_location: float '2D cursor location for this view'
|
||||
SpaceUVEditor.draw_modified_edges -> show_modified_edges: boolean 'Draw edges after modifiers are applied'
|
||||
SpaceUVEditor.draw_other_objects -> show_other_objects: boolean 'Draw other selected objects that share the same image'
|
||||
SpaceUVEditor.draw_smooth_edges -> show_smooth_edges: boolean 'Draw UV edges anti-aliased'
|
||||
SpaceUVEditor.draw_stretch -> show_stretch: boolean 'Draw faces colored according to the difference in shape between UVs and their 3D coordinates (blue for low distortion, red for high distortion)'
|
||||
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.live_unwrap -> use_live_unwrap: boolean 'Continuously unwrap the selected UV island while transforming pinned vertices'
|
||||
SpaceUVEditor.normalized_coordinates -> show_normalized_coordinates: boolean 'Display UV coordinates from 0.0 to 1.0 rather than in pixels'
|
||||
SpaceUVEditor.pivot -> pivot: enum 'Rotation/Scaling Pivot'
|
||||
SpaceUVEditor.snap_to_pixels -> use_snap_to_pixels: boolean 'Snap UVs to pixel locations while editing'
|
||||
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.all_object_origins -> show_all_objects_origin: boolean 'Show the object origin center dot for all (selected and unselected) objects'
|
||||
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.display_background_images -> show_background_images: boolean 'Display reference images behind objects in the 3D View'
|
||||
SpaceView3D.display_floor -> show_floor: boolean 'Show the ground plane grid in perspective view'
|
||||
SpaceView3D.display_render_override -> show_only_render: boolean 'Display only objects which will be rendered'
|
||||
SpaceView3D.display_x_axis -> show_axis_x: boolean 'Show the X axis line in perspective view'
|
||||
SpaceView3D.display_y_axis -> show_axis_y: boolean 'Show the Y axis line in perspective view'
|
||||
SpaceView3D.display_z_axis -> show_axis_z: boolean 'Show the Z axis line in perspective view'
|
||||
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.layers -> layers: boolean 'Layers visible in this 3D View'
|
||||
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_camera_and_layers -> lock_camera_and_layers: boolean "Use the scene's active camera and layers in this view, rather than local layers"
|
||||
SpaceView3D.lock_object -> lock_object: pointer "3D View center is locked to this object's position"
|
||||
SpaceView3D.manipulator -> use_manipulator: boolean 'Use a 3D manipulator widget for controlling transforms'
|
||||
SpaceView3D.manipulator_rotate -> use_manipulator_rotate: boolean 'Use the manipulator for rotation transformations'
|
||||
SpaceView3D.manipulator_scale -> use_manipulator_scale: boolean 'Use the manipulator for scale transformations'
|
||||
SpaceView3D.manipulator_translate -> use_manipulator_translate: boolean 'Use the manipulator for movement transformations'
|
||||
SpaceView3D.occlude_geometry -> use_occlude_geometry: boolean 'Limit selection to visible (clipped with depth buffer)'
|
||||
SpaceView3D.outline_selected -> show_outline_selected: boolean 'Show an outline highlight around selected objects in non-wireframe views'
|
||||
SpaceView3D.pivot_point -> pivot_point: enum 'Pivot center for rotation/scaling'
|
||||
SpaceView3D.pivot_point_align -> use_pivot_point_align: boolean 'Manipulate object centers only'
|
||||
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.relationship_lines -> show_relationship_lines: boolean 'Show dashed lines indicating parent or constraint relationships'
|
||||
SpaceView3D.textured_solid -> show_textured_solid: boolean 'Display face-assigned textures in solid view'
|
||||
SpaceView3D.transform_orientation -> transform_orientation: enum 'Transformation orientation'
|
||||
SpaceView3D.used_layers -> layers_used: boolean, '(read-only) Layers that contain something'
|
||||
SpaceView3D.viewport_shading -> viewport_shade: enum 'Method to display/shade objects in the 3D View'
|
||||
SpeedControlSequence.curve_compress_y -> use_curve_compress_y: boolean 'Scale F-Curve value to get the target frame number, F-Curve value runs from 0.0 to 1.0'
|
||||
SpeedControlSequence.curve_velocity -> use_curve_velocity: boolean 'Interpret the F-Curve value as a velocity instead of a frame number'
|
||||
SpeedControlSequence.frame_blending -> use_frame_blend: boolean 'Blend two frames into the target for a smoother result'
|
||||
SpeedControlSequence.global_speed -> global_speed: float 'NO DESCRIPTION'
|
||||
Spline.bezier_points -> bezier_points: collection, '(read-only) Collection of points for bezier curves only'
|
||||
Spline.bezier_u -> use_bezier_u: boolean 'Make this nurbs curve or surface act like a bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled)'
|
||||
Spline.bezier_v -> use_bezier_v: boolean 'Make this nurbs surface act like a bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled)'
|
||||
Spline.character_index -> character_index: int, '(read-only) Location of this character in the text data (only for text curves)'
|
||||
Spline.cyclic_u -> use_cyclic_u: boolean 'Make this curve or surface a closed loop in the U direction'
|
||||
Spline.cyclic_v -> use_cyclic_v: boolean 'Make this surface a closed loop in the V direction'
|
||||
Spline.endpoint_u -> use_endpoint_u: boolean 'Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled)'
|
||||
Spline.endpoint_v -> use_endpoint_v: boolean 'Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)'
|
||||
Spline.hide -> hide: boolean 'Hide this curve in editmode'
|
||||
Spline.material_index -> material_index: int 'NO DESCRIPTION'
|
||||
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.smooth -> use_smooth: boolean 'Smooth the normals of the surface or beveled curve'
|
||||
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.chain_offset -> use_chain_offset: boolean 'Offset the entire chain relative to the root joint'
|
||||
SplineIKConstraint.even_divisions -> use_even_divisions: boolean 'Ignore the relative lengths of the bones when fitting to the curve'
|
||||
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.use_curve_radius -> use_curve_radius: boolean 'Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, on top of XZ Scale mode'
|
||||
SplineIKConstraint.xz_scaling_mode -> xz_scale_mode: enum 'Method used for determining the scaling of the X and Z axes of the bones'
|
||||
SplineIKConstraint.y_stretch -> use_y_stretch: boolean 'Stretch the Y axis of the bones to fit the curve'
|
||||
SplinePoint.co -> co: float 'Point coordinates'
|
||||
SplinePoint.hide -> hide: boolean 'Visibility status'
|
||||
SplinePoint.radius -> radius: float, '(read-only) Radius for bevelling'
|
||||
SplinePoint.select -> select: boolean 'Selection status'
|
||||
SplinePoint.tilt -> tilt: float 'Tilt in 3D View'
|
||||
SplinePoint.weight -> weight: float 'Nurbs weight'
|
||||
SplinePoint.weight_softbody -> weight_softbody: float 'Softbody goal weight'
|
||||
SpotLamp.auto_clip_end -> use_auto_clip_end: boolean 'Automatic calculation of clipping-end, based on visible vertices'
|
||||
SpotLamp.auto_clip_start -> use_auto_clip_start: boolean 'Automatic calculation of clipping-start, based on visible vertices'
|
||||
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 -> use_halo: boolean 'Renders spotlight with a volumetric halo (Buffer Shadows)'
|
||||
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.only_shadow -> use_only_shadow: boolean 'Causes light to cast shadows only without illuminating objects'
|
||||
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_layer -> use_shadow_layer: boolean 'Causes only objects on the same layer to cast 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_sample_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.show_cone -> show_cone: boolean 'Draw transparent cone in 3D view to visualize which objects are contained in it'
|
||||
SpotLamp.sphere -> use_sphere: boolean 'Sets light intensity to zero beyond lamp distance'
|
||||
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'
|
||||
SpotLamp.square -> use_square: boolean 'Casts a square spot light shape'
|
||||
StateActuator.operation -> operation: enum 'Select the bit operation on object state mask'
|
||||
StateActuator.state -> states: boolean 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 -> length_max: 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 'NO DESCRIPTION'
|
||||
StucciTexture.stype -> stype: enum 'NO DESCRIPTION'
|
||||
StucciTexture.turbulence -> turbulence: float 'Sets the turbulence of the bandnoise and ringnoise types'
|
||||
SubsurfModifier.levels -> levels: int 'Number of subdivisions to perform'
|
||||
SubsurfModifier.optimal_display -> show_only_control_edges: boolean 'Skip drawing/rendering of interior subdivided edges'
|
||||
SubsurfModifier.render_levels -> render_levels: int 'Number of subdivisions to perform when rendering'
|
||||
SubsurfModifier.subdivision_type -> subdivision_type: enum 'Selects type of subdivision algorithm'
|
||||
SubsurfModifier.subsurf_uv -> use_subsurf_uv: boolean 'Use subsurf to subdivide UVs'
|
||||
SunLamp.only_shadow -> use_only_shadow: boolean 'Causes light to cast shadows only without illuminating objects'
|
||||
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_layer -> use_shadow_layer: boolean 'Causes only objects on the same layer to cast shadows'
|
||||
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'
|
||||
SurfaceCurve.map_along_length -> use_map_along_length: boolean 'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'
|
||||
TexMapping.has_maximum -> use_max: boolean 'Whether to use maximum clipping value'
|
||||
TexMapping.has_minimum -> use_min: boolean 'Whether to use minimum clipping value'
|
||||
TexMapping.location -> location: float 'NO DESCRIPTION'
|
||||
TexMapping.maximum -> max: float 'Maximum value for clipping'
|
||||
TexMapping.minimum -> min: float 'Minimum value for clipping'
|
||||
TexMapping.rotation -> rotation: float 'NO DESCRIPTION'
|
||||
TexMapping.scale -> scale: float 'NO DESCRIPTION'
|
||||
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.dirty -> is_dirty: boolean, '(read-only) Text file has been edited since last save'
|
||||
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.memory -> is_in_memory: boolean, '(read-only) Text file is in memory, without a corresponding file on disk'
|
||||
Text.modified -> is_modified: boolean, '(read-only) Text file on disk is different than the one in memory'
|
||||
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'
|
||||
Text.tabs_as_spaces -> use_tabs_as_spaces: boolean 'Automatically converts all new tabs into spaces'
|
||||
Text.use_module -> use_module: boolean "Register this text as a module on loading, Text name must end with '.py'"
|
||||
TextBox.height -> height: float 'NO DESCRIPTION'
|
||||
TextBox.width -> width: float 'NO DESCRIPTION'
|
||||
TextBox.x -> x: float 'NO DESCRIPTION'
|
||||
TextBox.y -> y: float 'NO DESCRIPTION'
|
||||
TextCharacterFormat.bold -> use_bold: boolean 'NO DESCRIPTION'
|
||||
TextCharacterFormat.italic -> use_italic: boolean 'NO DESCRIPTION'
|
||||
TextCharacterFormat.underline -> use_underline: boolean 'NO DESCRIPTION'
|
||||
TextCharacterFormat.use_small_caps -> use_small_caps: boolean 'NO DESCRIPTION'
|
||||
TextCurve.active_textbox -> active_textbox: int 'NO DESCRIPTION'
|
||||
TextCurve.body -> body: string 'contents of this text object'
|
||||
TextCurve.body_format -> body_format: collection, '(read-only) Stores the style of each character'
|
||||
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.fast -> use_fast_editing: boolean "Don't fill polygons while editing"
|
||||
TextCurve.font -> font: pointer 'NO DESCRIPTION'
|
||||
TextCurve.line_dist -> line_distance: float 'NO DESCRIPTION'
|
||||
TextCurve.map_along_length -> use_map_along_length: boolean 'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'
|
||||
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.small_caps_scale -> small_caps_scale: float 'Scale of small capitals'
|
||||
TextCurve.spacemode -> spacemode: enum 'Text align from the object center'
|
||||
TextCurve.spacing -> spacing: float 'NO DESCRIPTION'
|
||||
TextCurve.text_on_curve -> text_on_curve: pointer 'Curve deforming text object'
|
||||
TextCurve.text_size -> text_size: float 'NO DESCRIPTION'
|
||||
TextCurve.textboxes -> textboxes: collection, '(read-only)'
|
||||
TextCurve.ul_height -> ul_height: float 'NO DESCRIPTION'
|
||||
TextCurve.ul_position -> ul_position: float 'Vertical position of underline'
|
||||
TextCurve.word_spacing -> word_spacing: float 'NO DESCRIPTION'
|
||||
TextLine.line -> line: string 'Text in the line'
|
||||
TextMarker.color -> color: float 'Color to display the marker with'
|
||||
TextMarker.edit_all -> use_edit_all: boolean, '(read-only) Edit all markers of the same group as one'
|
||||
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'
|
||||
TextMarker.temporary -> is_temporary: boolean, '(read-only) Marker is temporary'
|
||||
Texture.animation_data -> animation_data: pointer, '(read-only) Animation data for this datablock'
|
||||
Texture.brightness -> intensity: float 'NO DESCRIPTION'
|
||||
Texture.color_ramp -> color_ramp: pointer, '(read-only)'
|
||||
Texture.contrast -> contrast: float 'NO DESCRIPTION'
|
||||
Texture.factor_blue -> factor_blue: float 'NO DESCRIPTION'
|
||||
Texture.factor_green -> factor_green: float 'NO DESCRIPTION'
|
||||
Texture.factor_red -> factor_red: float 'NO DESCRIPTION'
|
||||
Texture.node_tree -> node_tree: pointer, '(read-only) Node tree for node-based textures'
|
||||
Texture.saturation -> saturation: float 'NO DESCRIPTION'
|
||||
Texture.type -> type: enum 'NO DESCRIPTION'
|
||||
Texture.use_color_ramp -> use_color_ramp: boolean 'Toggle color ramp operations'
|
||||
Texture.use_nodes -> use_nodes: boolean 'Make this a node-based texture'
|
||||
Texture.use_preview_alpha -> use_preview_alpha: boolean 'Show Alpha in Preview Render'
|
||||
TextureNode.type -> type: enum, '(read-only)'
|
||||
TextureNodeBricks.offset -> offset: float 'NO DESCRIPTION'
|
||||
TextureNodeBricks.offset_frequency -> offset_frequency: int 'Offset every N rows'
|
||||
TextureNodeBricks.squash -> squash: float 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
TextureNodeCurveTime.start -> start: int 'NO DESCRIPTION'
|
||||
TextureNodeImage.image -> image: pointer 'NO DESCRIPTION'
|
||||
TextureNodeMath.operation -> operation: enum 'NO DESCRIPTION'
|
||||
TextureNodeMixRGB.alpha -> use_alpha: boolean 'Include alpha of second input in this operation'
|
||||
TextureNodeMixRGB.blend_type -> blend_type: enum 'NO DESCRIPTION'
|
||||
TextureNodeOutput.output_name -> output_name: string 'NO DESCRIPTION'
|
||||
TextureNodeTexture.node_output -> node_output: int 'For node-based textures, which output node to use'
|
||||
TextureNodeTexture.texture -> texture: pointer 'NO DESCRIPTION'
|
||||
TextureNodeValToRGB.color_ramp -> color_ramp: pointer, '(read-only)'
|
||||
TextureSlot.blend_type -> blend_type: enum 'NO DESCRIPTION'
|
||||
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.negate -> invert: boolean 'Inverts the values of the texture to reverse its effect'
|
||||
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.rgb_to_intensity -> use_rgb_to_intensity: boolean 'Converts texture RGB values to intensity (gray) values'
|
||||
TextureSlot.size -> size: float "Sets scaling for the texture's X, Y and Z sizes"
|
||||
TextureSlot.stencil -> use_stencil: boolean 'Use this texture as a blending value on the next texture'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.frame_current -> frame_current: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.grid -> grid: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeAudioWindow.window_sliders -> window_sliders: float 'NO DESCRIPTION'
|
||||
ThemeBoneColorSet.active -> active: float 'Color used for active bones'
|
||||
ThemeBoneColorSet.colored_constraints -> show_colored_constraints: boolean 'Allow the use of colors indicating constraints/keyed status'
|
||||
ThemeBoneColorSet.normal -> normal: float 'Color used for the surface of bones'
|
||||
ThemeBoneColorSet.select -> select: float 'Color used for selected bones'
|
||||
ThemeConsole.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeConsole.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeConsole.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeConsole.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeConsole.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeConsole.cursor -> cursor: float 'NO DESCRIPTION'
|
||||
ThemeConsole.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeConsole.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeConsole.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeConsole.line_error -> line_error: float 'NO DESCRIPTION'
|
||||
ThemeConsole.line_info -> line_info: float 'NO DESCRIPTION'
|
||||
ThemeConsole.line_input -> line_input: float 'NO DESCRIPTION'
|
||||
ThemeConsole.line_output -> line_output: float 'NO DESCRIPTION'
|
||||
ThemeConsole.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeConsole.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeConsole.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.active_channels_group -> active_channels_group: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.channel_group -> channel_group: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.channels -> channels: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.channels_selected -> channels_selected: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.dopesheet_channel -> dopesheet_channel: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.dopesheet_subchannel -> dopesheet_subchannel: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.frame_current -> frame_current: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.grid -> grid: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.list -> list: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.list_text -> list_text: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.list_text_hi -> list_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.list_title -> list_title: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.long_key -> long_key: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.long_key_selected -> long_key_selected: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.value_sliders -> value_sliders: float 'NO DESCRIPTION'
|
||||
ThemeDopeSheet.view_sliders -> view_sliders: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.active_file -> active_file: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.active_file_text -> active_file_text: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.list -> list: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.list_text -> list_text: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.list_text_hi -> list_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.list_title -> list_title: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.scroll_handle -> scroll_handle: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.scrollbar -> scrollbar: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.selected_file -> selected_file: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.tiles -> tiles: float 'NO DESCRIPTION'
|
||||
ThemeFileBrowser.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeFontStyle.font_kerning_style -> font_kerning_style: enum 'Which style to use for font kerning'
|
||||
ThemeFontStyle.points -> points: int 'NO DESCRIPTION'
|
||||
ThemeFontStyle.shadow -> shadow: int 'Shadow size in pixels (0, 3 and 5 supported)'
|
||||
ThemeFontStyle.shadowalpha -> shadowalpha: float 'NO DESCRIPTION'
|
||||
ThemeFontStyle.shadowcolor -> shadowcolor: float 'Shadow color in grey value'
|
||||
ThemeFontStyle.shadx -> shadow_offset_x: int 'Shadow offset in pixels'
|
||||
ThemeFontStyle.shady -> shadow_offset_y: int 'Shadow offset in pixels'
|
||||
ThemeGraphEditor.active_channels_group -> active_channels_group: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.channel_group -> channel_group: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.channels_region -> channels_region: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.dopesheet_channel -> dopesheet_channel: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.dopesheet_subchannel -> dopesheet_subchannel: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.frame_current -> frame_current: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.grid -> grid: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_align -> handle_align: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_auto -> handle_auto: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_free -> handle_free: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_sel_align -> handle_sel_align: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_sel_auto -> handle_sel_auto: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_sel_free -> handle_sel_free: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_sel_vect -> handle_sel_vect: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_vect -> handle_vect: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_vertex -> handle_vertex: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_vertex_select -> handle_vertex_select: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.handle_vertex_size -> handle_vertex_size: int 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.lastsel_point -> lastsel_point: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.list -> list: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.list_text -> list_text: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.list_text_hi -> list_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.list_title -> list_title: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.panel -> panel: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.vertex -> vertex: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.vertex_select -> vertex_select: float 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.vertex_size -> vertex_size: int 'NO DESCRIPTION'
|
||||
ThemeGraphEditor.window_sliders -> window_sliders: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.editmesh_active -> editmesh_active: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.face -> face: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.face_dot -> face_dot: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.face_select -> face_select: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.facedot_size -> facedot_size: int 'NO DESCRIPTION'
|
||||
ThemeImageEditor.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.scope_back -> scope_back: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.vertex -> vertex: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.vertex_select -> vertex_select: float 'NO DESCRIPTION'
|
||||
ThemeImageEditor.vertex_size -> vertex_size: int 'NO DESCRIPTION'
|
||||
ThemeInfo.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeInfo.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeInfo.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeInfo.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeInfo.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeInfo.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeInfo.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeInfo.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeInfo.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeInfo.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeInfo.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.panel -> panel: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeLogicEditor.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.bars -> bars: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.bars_selected -> bars_selected: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.frame_current -> frame_current: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.grid -> grid: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.list -> list: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.list_text -> list_text: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.list_text_hi -> list_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.list_title -> list_title: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.strips -> strips: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.strips_selected -> strips_selected: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeNLAEditor.view_sliders -> view_sliders: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.converter_node -> converter_node: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.group_node -> group_node: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.in_out_node -> in_out_node: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.list -> list: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.list_text -> list_text: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.list_text_hi -> list_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.list_title -> list_title: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.node_backdrop -> node_backdrop: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.operator_node -> operator_node: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.selected_text -> selected_text: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.wire_select -> wire_select: float 'NO DESCRIPTION'
|
||||
ThemeNodeEditor.wires -> wires: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeOutliner.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeProperties.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeProperties.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeProperties.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeProperties.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeProperties.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeProperties.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeProperties.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeProperties.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeProperties.panel -> panel: float 'NO DESCRIPTION'
|
||||
ThemeProperties.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeProperties.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeProperties.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.audio_strip -> audio_strip: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.draw_action -> draw_action: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.effect_strip -> effect_strip: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.frame_current -> frame_current: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.grid -> grid: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.image_strip -> image_strip: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.keyframe -> keyframe: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.meta_strip -> meta_strip: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.movie_strip -> movie_strip: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.plugin_strip -> plugin_strip: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.scene_strip -> scene_strip: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.transition_strip -> transition_strip: float 'NO DESCRIPTION'
|
||||
ThemeSequenceEditor.window_sliders -> window_sliders: float 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
ThemeTextEditor.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.cursor -> cursor: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.line_numbers_background -> line_numbers_background: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.scroll_bar -> scroll_bar: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.selected_text -> selected_text: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.syntax_builtin -> syntax_builtin: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.syntax_comment -> syntax_comment: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.syntax_numbers -> syntax_numbers: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.syntax_special -> syntax_special: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.syntax_string -> syntax_string: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeTextEditor.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.frame_current -> frame_current: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.grid -> grid: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeTimeline.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeUserInterface.icon_file -> icon_file: string 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeUserPreferences.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeView3D.act_spline -> act_spline: float 'NO DESCRIPTION'
|
||||
ThemeView3D.back -> back: float 'NO DESCRIPTION'
|
||||
ThemeView3D.bone_pose -> bone_pose: float 'NO DESCRIPTION'
|
||||
ThemeView3D.bone_solid -> bone_solid: float 'NO DESCRIPTION'
|
||||
ThemeView3D.button -> button: float 'NO DESCRIPTION'
|
||||
ThemeView3D.button_text -> button_text: float 'NO DESCRIPTION'
|
||||
ThemeView3D.button_text_hi -> button_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeView3D.button_title -> button_title: float 'NO DESCRIPTION'
|
||||
ThemeView3D.edge_crease -> edge_crease: float 'NO DESCRIPTION'
|
||||
ThemeView3D.edge_facesel -> edge_facesel: float 'NO DESCRIPTION'
|
||||
ThemeView3D.edge_seam -> edge_seam: float 'NO DESCRIPTION'
|
||||
ThemeView3D.edge_select -> edge_select: float 'NO DESCRIPTION'
|
||||
ThemeView3D.edge_sharp -> edge_sharp: float 'NO DESCRIPTION'
|
||||
ThemeView3D.editmesh_active -> editmesh_active: float 'NO DESCRIPTION'
|
||||
ThemeView3D.face -> face: float 'NO DESCRIPTION'
|
||||
ThemeView3D.face_dot -> face_dot: float 'NO DESCRIPTION'
|
||||
ThemeView3D.face_select -> face_select: float 'NO DESCRIPTION'
|
||||
ThemeView3D.facedot_size -> facedot_size: int 'NO DESCRIPTION'
|
||||
ThemeView3D.frame_current -> frame_current: float 'NO DESCRIPTION'
|
||||
ThemeView3D.grid -> grid: float 'NO DESCRIPTION'
|
||||
ThemeView3D.handle_align -> handle_align: float 'NO DESCRIPTION'
|
||||
ThemeView3D.handle_auto -> handle_auto: float 'NO DESCRIPTION'
|
||||
ThemeView3D.handle_free -> handle_free: float 'NO DESCRIPTION'
|
||||
ThemeView3D.handle_sel_align -> handle_sel_align: float 'NO DESCRIPTION'
|
||||
ThemeView3D.handle_sel_auto -> handle_sel_auto: float 'NO DESCRIPTION'
|
||||
ThemeView3D.handle_sel_free -> handle_sel_free: float 'NO DESCRIPTION'
|
||||
ThemeView3D.handle_sel_vect -> handle_sel_vect: float 'NO DESCRIPTION'
|
||||
ThemeView3D.handle_vect -> handle_vect: float 'NO DESCRIPTION'
|
||||
ThemeView3D.header -> header: float 'NO DESCRIPTION'
|
||||
ThemeView3D.header_text -> header_text: float 'NO DESCRIPTION'
|
||||
ThemeView3D.header_text_hi -> header_text_hi: float 'NO DESCRIPTION'
|
||||
ThemeView3D.lamp -> lamp: float 'NO DESCRIPTION'
|
||||
ThemeView3D.lastsel_point -> lastsel_point: float 'NO DESCRIPTION'
|
||||
ThemeView3D.normal -> normal: float 'NO DESCRIPTION'
|
||||
ThemeView3D.nurb_sel_uline -> nurb_sel_uline: float 'NO DESCRIPTION'
|
||||
ThemeView3D.nurb_sel_vline -> nurb_sel_vline: float 'NO DESCRIPTION'
|
||||
ThemeView3D.nurb_uline -> nurb_uline: float 'NO DESCRIPTION'
|
||||
ThemeView3D.nurb_vline -> nurb_vline: float 'NO DESCRIPTION'
|
||||
ThemeView3D.object_active -> object_active: float 'NO DESCRIPTION'
|
||||
ThemeView3D.object_grouped -> object_grouped: float 'NO DESCRIPTION'
|
||||
ThemeView3D.object_grouped_active -> object_grouped_active: float 'NO DESCRIPTION'
|
||||
ThemeView3D.object_selected -> object_selected: float 'NO DESCRIPTION'
|
||||
ThemeView3D.panel -> panel: float 'NO DESCRIPTION'
|
||||
ThemeView3D.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeView3D.text_hi -> text_hi: float 'NO DESCRIPTION'
|
||||
ThemeView3D.title -> title: float 'NO DESCRIPTION'
|
||||
ThemeView3D.transform -> transform: float 'NO DESCRIPTION'
|
||||
ThemeView3D.vertex -> vertex: float 'NO DESCRIPTION'
|
||||
ThemeView3D.vertex_normal -> vertex_normal: float 'NO DESCRIPTION'
|
||||
ThemeView3D.vertex_select -> vertex_select: float 'NO DESCRIPTION'
|
||||
ThemeView3D.vertex_size -> vertex_size: int 'NO DESCRIPTION'
|
||||
ThemeView3D.wire -> wire: float 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.inner -> inner: float 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.inner_sel -> inner_sel: float 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.item -> item: float 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.outline -> outline: float 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.shaded -> show_shaded: boolean 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.shadedown -> shadedown: int 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.shadetop -> shadetop: int 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.text -> text: float 'NO DESCRIPTION'
|
||||
ThemeWidgetColors.text_sel -> text_sel: float 'NO DESCRIPTION'
|
||||
ThemeWidgetStateColors.blend -> blend: float 'NO DESCRIPTION'
|
||||
ThemeWidgetStateColors.inner_anim -> inner_anim: float 'NO DESCRIPTION'
|
||||
ThemeWidgetStateColors.inner_anim_sel -> inner_anim_sel: float 'NO DESCRIPTION'
|
||||
ThemeWidgetStateColors.inner_driven -> inner_driven: float 'NO DESCRIPTION'
|
||||
ThemeWidgetStateColors.inner_driven_sel -> inner_driven_sel: float 'NO DESCRIPTION'
|
||||
ThemeWidgetStateColors.inner_key -> inner_key: float 'NO DESCRIPTION'
|
||||
ThemeWidgetStateColors.inner_key_sel -> inner_key_sel: float 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
TimelineMarker.select -> select: boolean 'Marker selection state'
|
||||
ToolSettings.auto_normalize -> use_auto_normalize: boolean 'Ensure all bone-deforming vertex groups add up to 1.0 while weight painting'
|
||||
ToolSettings.autokey_mode -> autokey_mode: enum 'Mode of automatic keyframe insertion for Objects and Bones'
|
||||
ToolSettings.automerge_editing -> use_automerge_editing: boolean 'Automatically merge vertices moved to the same location'
|
||||
ToolSettings.bone_sketching -> use_bone_sketching: boolean 'DOC BROKEN'
|
||||
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_autoname -> use_etch_autoname: boolean 'DOC BROKEN'
|
||||
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_overdraw -> use_etch_overdraw: boolean 'DOC BROKEN'
|
||||
ToolSettings.etch_quick -> use_etch_quick: boolean '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.mesh_selection_mode -> mesh_selection_mode: boolean 'Which mesh elements selection works on'
|
||||
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_edit: enum 'Proportional editing mode'
|
||||
ToolSettings.proportional_editing_falloff -> proportional_edit_falloff: enum 'Falloff type for proportional editing mode'
|
||||
ToolSettings.proportional_editing_objects -> proportional_editing_objects: boolean 'Proportional editing object mode'
|
||||
ToolSettings.record_with_nla -> use_record_with_nla: boolean 'Add a new NLA Track + Strip for every loop/pass made over the animation to allow non-destructive tweaking'
|
||||
ToolSettings.sculpt -> sculpt: pointer, '(read-only)'
|
||||
ToolSettings.sculpt_paint_use_unified_size -> sculpt_paint_use_unified_size: boolean 'Instead of per brush radius, the radius is shared across brushes'
|
||||
ToolSettings.sculpt_paint_use_unified_strength -> sculpt_paint_use_unified_strength: boolean 'Instead of per brush strength, the strength is shared across brushes'
|
||||
ToolSettings.snap -> use_snap: boolean 'Snap during transform'
|
||||
ToolSettings.snap_align_rotation -> use_snap_align_rotation: boolean 'Align rotation with the snapping target'
|
||||
ToolSettings.snap_element -> snap_element: enum 'Type of element to snap to'
|
||||
ToolSettings.snap_peel_object -> use_snap_peel_object: boolean 'Consider objects as whole when finding volume center'
|
||||
ToolSettings.snap_project -> use_snap_project: boolean 'Project vertices on the surface of other objects'
|
||||
ToolSettings.snap_target -> snap_target: enum 'Which part to snap onto the target'
|
||||
ToolSettings.use_auto_keying -> use_keyframe_insert_auto: boolean 'Automatic keyframe insertion for Objects and Bones'
|
||||
ToolSettings.uv_local_view -> show_local_view: boolean 'Draw only faces with the currently displayed image assigned'
|
||||
ToolSettings.uv_selection_mode -> uv_selection_mode: enum 'UV selection and display mode'
|
||||
ToolSettings.uv_sync_selection -> use_uv_sync_selection: boolean 'Keep UV and edit mode mesh selection in sync'
|
||||
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 'NO DESCRIPTION'
|
||||
TrackToConstraint.target -> target: pointer 'Target Object'
|
||||
TrackToConstraint.target_z -> use_target_z: boolean "Target's Z axis, not World Z axis, will constraint the Up direction"
|
||||
TrackToConstraint.track -> track: enum 'Axis that points to the target object'
|
||||
TrackToConstraint.up -> up: enum 'Axis that points upward'
|
||||
TransformConstraint.extrapolate_motion -> use_motion_extrapolate: boolean 'Extrapolate ranges'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
TransformOrientation.name -> name: string 'NO DESCRIPTION'
|
||||
TransformSequence.interpolation -> interpolation: enum 'NO DESCRIPTION'
|
||||
TransformSequence.rotation_start -> rotation_start: float 'NO DESCRIPTION'
|
||||
TransformSequence.scale_start_x -> scale_start_x: float 'NO DESCRIPTION'
|
||||
TransformSequence.scale_start_y -> scale_start_y: float 'NO DESCRIPTION'
|
||||
TransformSequence.translate_start_x -> translate_start_x: float 'NO DESCRIPTION'
|
||||
TransformSequence.translate_start_y -> translate_start_y: float 'NO DESCRIPTION'
|
||||
TransformSequence.translation_unit -> translation_unit: enum 'NO DESCRIPTION'
|
||||
TransformSequence.uniform_scale -> use_uniform_scale: boolean 'Scale uniformly, preserving aspect ratio'
|
||||
UILayout.active -> show_active: boolean 'NO DESCRIPTION'
|
||||
UILayout.alignment -> alignment: enum 'NO DESCRIPTION'
|
||||
UILayout.enabled -> show_enabled: boolean 'NO DESCRIPTION'
|
||||
UILayout.operator_context -> operator_context: enum 'NO DESCRIPTION'
|
||||
UILayout.scale_x -> scale_x: float 'NO DESCRIPTION'
|
||||
UILayout.scale_y -> scale_y: float 'NO DESCRIPTION'
|
||||
UVProjectModifier.aspect_x -> aspect_x: float 'NO DESCRIPTION'
|
||||
UVProjectModifier.aspect_y -> aspect_y: float 'NO DESCRIPTION'
|
||||
UVProjectModifier.image -> image: pointer 'NO DESCRIPTION'
|
||||
UVProjectModifier.num_projectors -> num_projectors: int 'Number of projectors to use'
|
||||
UVProjectModifier.override_image -> use_image_override: boolean "Override faces' current images with the given image"
|
||||
UVProjectModifier.projectors -> projectors: collection, '(read-only)'
|
||||
UVProjectModifier.scale_x -> scale_x: float 'NO DESCRIPTION'
|
||||
UVProjectModifier.scale_y -> scale_y: float 'NO DESCRIPTION'
|
||||
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'
|
||||
UnitSettings.use_separate -> use_separate: boolean 'Display units in pairs'
|
||||
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_keyframe_insert_available -> use_keyframe_insert_available: boolean 'Automatic keyframe insertion in available curves'
|
||||
UserPreferencesEdit.auto_keyframe_insert_keyingset -> use_keyframe_insert_keyingset: boolean 'Automatic keyframe insertion using active Keying Set'
|
||||
UserPreferencesEdit.auto_keying_mode -> auto_keying_mode: enum 'Mode of automatic keyframe insertion for Objects and Bones'
|
||||
UserPreferencesEdit.drag_immediately -> use_drag_immediately: boolean 'Moving things with a mouse drag confirms when releasing the button'
|
||||
UserPreferencesEdit.duplicate_action -> use_duplicate_action: boolean 'Causes actions to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_armature -> use_duplicate_armature: boolean 'Causes armature data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_curve -> use_duplicate_curve: boolean 'Causes curve data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_fcurve -> use_duplicate_fcurve: boolean 'Causes F-curve data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_lamp -> use_duplicate_lamp: boolean 'Causes lamp data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_material -> use_duplicate_material: boolean 'Causes material data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_mesh -> use_duplicate_mesh: boolean 'Causes mesh data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_metaball -> use_duplicate_metaball: boolean 'Causes metaball data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_particle -> use_duplicate_particle: boolean 'Causes particle systems to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_surface -> use_duplicate_surface: boolean 'Causes surface data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_text -> use_duplicate_text: boolean 'Causes text data to be duplicated with the object'
|
||||
UserPreferencesEdit.duplicate_texture -> use_duplicate_texture: boolean 'Causes texture data to be duplicated with the object'
|
||||
UserPreferencesEdit.enter_edit_mode -> use_enter_edit_mode: boolean 'Enter Edit Mode automatically after adding a new object'
|
||||
UserPreferencesEdit.global_undo -> use_global_undo: boolean 'Global undo works by keeping a full copy of the file itself in memory, so takes extra memory'
|
||||
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.grease_pencil_simplify_stroke -> use_grease_pencil_simplify_stroke: boolean 'Simplify the final stroke'
|
||||
UserPreferencesEdit.grease_pencil_smooth_stroke -> use_grease_pencil_smooth_stroke: boolean 'Smooth the final stroke'
|
||||
UserPreferencesEdit.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb: boolean 'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
|
||||
UserPreferencesEdit.keyframe_insert_needed -> use_keyframe_insert_needed: boolean 'Keyframe insertion only when keyframe needed'
|
||||
UserPreferencesEdit.keyframe_new_handle_type -> keyframe_new_handle_type: enum 'NO DESCRIPTION'
|
||||
UserPreferencesEdit.keyframe_new_interpolation_type -> keyframe_new_interpolation_type: enum 'NO DESCRIPTION'
|
||||
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.sculpt_paint_overlay_col -> sculpt_paint_overlay_col: float 'Color of texture overlay'
|
||||
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)'
|
||||
UserPreferencesEdit.use_auto_keying -> use_auto_keying: boolean 'Automatic keyframe insertion for Objects and Bones'
|
||||
UserPreferencesEdit.use_negative_frames -> use_negative_frames: boolean 'Current frame number can be manually set to a negative value'
|
||||
UserPreferencesEdit.use_visual_keying -> use_visual_keying: boolean 'Use Visual keying automatically for constrained objects'
|
||||
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_temporary_files -> use_auto_save_temporary_files: boolean 'Automatic saving of temporary files'
|
||||
UserPreferencesFilePaths.auto_save_time -> auto_save_time: int 'The time (in minutes) to wait between automatic temporary saves'
|
||||
UserPreferencesFilePaths.compress_file -> use_file_compression: boolean 'Enable file compression when saving .blend files'
|
||||
UserPreferencesFilePaths.filter_file_extensions -> use_filter_files: boolean 'Display only files with extensions in the image select window'
|
||||
UserPreferencesFilePaths.fonts_directory -> fonts_directory: string 'The default directory to search for loading fonts'
|
||||
UserPreferencesFilePaths.hide_dot_files_datablocks -> show_hidden_files_datablocks: boolean 'Hide files/datablocks that start with a dot(.*)'
|
||||
UserPreferencesFilePaths.image_editor -> image_editor: string 'Path to an image editor'
|
||||
UserPreferencesFilePaths.load_ui -> use_load_ui: boolean 'Load user interface setup when loading .blend files'
|
||||
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_preview_images -> use_save_preview_images: boolean 'Enables automatic saving of preview images in the .blend file'
|
||||
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'
|
||||
UserPreferencesFilePaths.use_relative_paths -> use_relative_paths: boolean 'Default relative path option for the file selector'
|
||||
UserPreferencesInput.continuous_mouse -> use_continuous_mouse: boolean 'Allow moving the mouse outside the view on some manipulations (transform, ui control drag)'
|
||||
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.emulate_3_button_mouse -> use_emulate_3_button_mouse: boolean "Emulates Middle Mouse with Alt+LeftMouse (doesn't work with Left Mouse Select option)"
|
||||
UserPreferencesInput.emulate_numpad -> use_emulate_numpad: boolean 'Causes the 1 to 0 keys to act as the numpad (useful for laptops)'
|
||||
UserPreferencesInput.invert_zoom_direction -> invert_mouse_wheel_zoom: boolean 'Invert the axis of mouse movement for zooming'
|
||||
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.use_middle_mouse_paste -> use_mouse_mmb_paste: boolean 'In text window, paste with middle mouse button instead of panning'
|
||||
UserPreferencesInput.view_rotation -> view_rotation: enum 'Rotation style in the viewport'
|
||||
UserPreferencesInput.wheel_invert_zoom -> wheel_invert_zoom: boolean 'Swap the Mouse Wheel zoom direction'
|
||||
UserPreferencesInput.wheel_scroll_lines -> wheel_scroll_lines: int 'The number of lines scrolled at a time with the mouse wheel'
|
||||
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.auto_execute_scripts -> use_scripts_auto_execute: boolean 'Allow any .blend file to run scripts automatically (unsafe with blend files from an untrusted source)'
|
||||
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.enable_all_codecs -> use_preview_images: boolean 'Enables automatic saving of preview images in the .blend file (Windows only)'
|
||||
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.international_fonts -> use_international_fonts: boolean 'Use international fonts'
|
||||
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.tabs_as_spaces -> use_tabs_as_spaces: boolean 'Automatically converts all new tabs into spaces for new and loaded text files'
|
||||
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.translate_buttons -> use_translate_buttons: boolean 'Translate button labels'
|
||||
UserPreferencesSystem.translate_toolbox -> use_translate_toolbox: boolean 'Translate toolbox menu'
|
||||
UserPreferencesSystem.translate_tooltips -> use_translate_tooltips: boolean 'Translate Tooltips'
|
||||
UserPreferencesSystem.use_antialiasing -> use_antialiasing: boolean 'Use anti-aliasing for the 3D view (may impact redraw performance)'
|
||||
UserPreferencesSystem.use_mipmaps -> use_mipmaps: boolean 'Scale textures for the 3D View (looks nicer but uses more memory and slows image reloading)'
|
||||
UserPreferencesSystem.use_textured_fonts -> use_textured_fonts: boolean 'Use textures for drawing international fonts'
|
||||
UserPreferencesSystem.use_vbos -> use_vertex_buffer_objects: boolean 'Use Vertex Buffer Objects (or Vertex Arrays, if unsupported) for viewport rendering'
|
||||
UserPreferencesSystem.use_weight_color_range -> use_weight_color_range: boolean 'Enable color range used for weight visualization in weight painting mode'
|
||||
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.auto_depth -> use_mouse_auto_depth: boolean 'Use the depth under the mouse to improve view pan/rotate/zoom functionality'
|
||||
UserPreferencesView.auto_perspective -> use_auto_perspective: boolean 'Automatically switch between orthographic and perspective when changing from top/front/side views'
|
||||
UserPreferencesView.directional_menus -> use_directional_menus: boolean 'Otherwise menus, etc will always be top to bottom, left to right, no matter opening direction'
|
||||
UserPreferencesView.display_object_info -> show_object_info: boolean 'Display objects name and frame number in 3D view'
|
||||
UserPreferencesView.global_pivot -> use_global_pivot: boolean 'Lock the same rotation/scaling pivot in all 3D Views'
|
||||
UserPreferencesView.global_scene -> use_global_scene: boolean 'Forces the current Scene to be displayed in all Screens'
|
||||
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_mouse_over -> use_mouse_over_open: boolean 'Open menu buttons and pulldowns automatically when the mouse is hovering'
|
||||
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.rotate_around_selection -> use_rotate_around_selection: boolean 'Use selection as the pivot point'
|
||||
UserPreferencesView.rotation_angle -> rotation_angle: int 'The rotation step for numerical pad keys (2 4 6 8)'
|
||||
UserPreferencesView.show_mini_axis -> show_mini_axis: boolean 'Show a small rotating 3D axis in the bottom left corner of the 3D View'
|
||||
UserPreferencesView.show_playback_fps -> show_playback_fps: boolean 'Show the frames per second screen refresh rate, while animation is played back'
|
||||
UserPreferencesView.show_splash -> show_splash: boolean 'Display splash screen on startup'
|
||||
UserPreferencesView.show_view_name -> show_view_name: boolean "Show the name of the view's direction in each 3D View"
|
||||
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.tooltips -> show_tooltips: boolean 'Display tooltips'
|
||||
UserPreferencesView.use_column_layout -> show_column_layout: boolean 'Use a column layout for toolbox'
|
||||
UserPreferencesView.use_large_cursors -> show_large_cursors: boolean 'Use large mouse cursors when available'
|
||||
UserPreferencesView.use_manipulator -> show_manipulator: boolean 'Use 3D transform manipulator'
|
||||
UserPreferencesView.view2d_grid_minimum_spacing -> view2d_grid_spacing_min: int 'Minimum number of pixels between each gridline in 2D Viewports'
|
||||
UserPreferencesView.zoom_to_mouse -> use_zoom_to_mouse: boolean "Zoom in towards the mouse pointer's position in the 3D view, rather than the 2D window center"
|
||||
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.enabled -> use: boolean 'Enable this OpenGL light in solid draw mode'
|
||||
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'
|
||||
VertexPaint.all_faces -> use_all_faces: boolean 'Paint on all faces inside brush'
|
||||
VertexPaint.normals -> use_normal: boolean 'Applies the vertex normal before painting'
|
||||
VertexPaint.spray -> use_spray: boolean 'Keep applying paint effect while holding mouse'
|
||||
VisibilityActuator.children -> apply_to_children: boolean 'Set all the children of this object to the same visibility/occlusion recursively'
|
||||
VisibilityActuator.occlusion -> use_occlusion: boolean 'Set the object to occlude objects behind it. Initialized from the object type in physics button'
|
||||
VisibilityActuator.visible -> use_visible: boolean 'Set the objects visible. Initialized from the objects render restriction toggle (access in the outliner)'
|
||||
VoronoiTexture.coloring -> color_mode: enum 'NO DESCRIPTION'
|
||||
VoronoiTexture.distance_metric -> distance_metric: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 -> use_still_frame: boolean 'Always render a still frame from the voxel data sequence'
|
||||
VoxelData.still_frame_number -> still_frame_number: int 'The frame number to always use'
|
||||
VoxelDataTexture.image -> image: pointer 'NO DESCRIPTION'
|
||||
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.cyclic -> use_cyclic: boolean 'Cyclic wave effect'
|
||||
WaveModifier.damping_time -> damping_time: float 'NO DESCRIPTION'
|
||||
WaveModifier.falloff_radius -> falloff_radius: float 'NO DESCRIPTION'
|
||||
WaveModifier.height -> height: float 'NO DESCRIPTION'
|
||||
WaveModifier.lifetime -> lifetime: float 'NO DESCRIPTION'
|
||||
WaveModifier.narrowness -> narrowness: float 'NO DESCRIPTION'
|
||||
WaveModifier.normals -> use_normal: boolean 'Displace along normal'
|
||||
WaveModifier.speed -> speed: float 'NO DESCRIPTION'
|
||||
WaveModifier.start_position_object -> start_position_object: pointer 'NO DESCRIPTION'
|
||||
WaveModifier.start_position_x -> start_position_x: float 'NO DESCRIPTION'
|
||||
WaveModifier.start_position_y -> start_position_y: float 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
WaveModifier.x -> use_x: boolean 'X axis motion'
|
||||
WaveModifier.x_normal -> use_normal_x: boolean 'Enable displacement along the X normal'
|
||||
WaveModifier.y -> use_y: boolean 'Y axis motion'
|
||||
WaveModifier.y_normal -> use_normal_y: boolean 'Enable displacement along the Y normal'
|
||||
WaveModifier.z_normal -> use_normal_z: boolean 'Enable displacement along the Z normal'
|
||||
Window.screen -> screen: pointer 'Active screen showing in the window'
|
||||
WindowManager.active_keyconfig -> active_keyconfig: pointer 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
WoodTexture.noisebasis2 -> noisebasis2: enum 'NO DESCRIPTION'
|
||||
WoodTexture.stype -> stype: enum 'NO DESCRIPTION'
|
||||
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 'NO DESCRIPTION'
|
||||
World.animation_data -> animation_data: pointer, '(read-only) Animation data for this datablock'
|
||||
World.blend_sky -> use_sky_blend: boolean 'Render background with natural progression from horizon to zenith'
|
||||
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.paper_sky -> use_sky_paper: boolean 'Flatten blend or texture coordinates'
|
||||
World.range -> range: float 'The color range that will be mapped to 0-1'
|
||||
World.real_sky -> use_sky_real: boolean 'Render background with a real horizon, relative to the camera angle'
|
||||
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_type: 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 -> use_falloff: boolean 'NO DESCRIPTION'
|
||||
WorldLighting.falloff_strength -> falloff_strength: float "Distance attenuation factor, the higher, the 'shorter' the shadows"
|
||||
WorldLighting.gather_method -> gather_method: enum 'NO DESCRIPTION'
|
||||
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.pixel_cache -> use_cache: boolean 'Cache AO results in pixels and interpolate over neighbouring pixels for speedup (for Approximate)'
|
||||
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)'
|
||||
WorldLighting.use_ambient_occlusion -> use_ambient_occlusian: boolean 'Use Ambient Occlusion to add shadowing based on distance between objects'
|
||||
WorldLighting.use_environment_lighting -> use_environment_lighting: boolean 'Add light coming from the environment'
|
||||
WorldLighting.use_indirect_lighting -> use_indirect_lighting: boolean 'Add indirect light bouncing of surrounding objects'
|
||||
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'
|
||||
WorldMistSettings.use_mist -> use_mist: boolean 'Occlude objects with the environment color as they are further away'
|
||||
WorldStarsSettings.average_separation -> average_separation: float 'Average distance between any two stars'
|
||||
WorldStarsSettings.color_randomization -> color_randomization: float 'Randomize star colors'
|
||||
WorldStarsSettings.min_distance -> distance_min: float 'Minimum distance to the camera for stars'
|
||||
WorldStarsSettings.size -> size: float 'Average screen dimension of stars'
|
||||
WorldStarsSettings.use_stars -> use_stars: boolean 'Enable starfield generation'
|
||||
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.map_blend -> use_map_blend: boolean 'Affect the color progression of the background'
|
||||
WorldTextureSlot.map_horizon -> use_map_horizon: boolean 'Affect the color of the horizon'
|
||||
WorldTextureSlot.map_zenith_down -> use_map_zenith_down: boolean 'Affect the color of the zenith below'
|
||||
WorldTextureSlot.map_zenith_up -> use_map_zenith_up: boolean 'Affect the color of the zenith above'
|
||||
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'
|
||||
+ * 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 "'NO DESCRIPTION'"
|
||||
+ * ActionActuator.blendin -> frame_blend_in: int "'Number of frames of motion blending'"
|
||||
+ * ActionActuator.continue_last_frame -> use_continue_last_frame: boolean "'Restore last frame when switching on/off, otherwise play from the start each time'"
|
||||
+ * ActionActuator.frame_end -> frame_end: int "'NO DESCRIPTION'"
|
||||
+ * ActionActuator.frame_property -> frame_property: string '"Assign the action\'s current frame number to this property"'
|
||||
+ * ActionActuator.frame_start -> frame_start: int "'NO DESCRIPTION'"
|
||||
+ * ActionActuator.mode -> play_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 "'NO DESCRIPTION'"
|
||||
+ * 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 -> max: float "'Maximum value for target channel range'"
|
||||
+ * ActionConstraint.minimum -> min: float "'Minimum value for target channel range'"
|
||||
+ * ActionConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
+ * 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.expanded -> show_expanded: boolean "'Action Group is expanded'"
|
||||
+ * ActionGroup.lock -> lock: boolean "'Action Group is locked'"
|
||||
+ * ActionGroup.name -> name: string "'NO DESCRIPTION'"
|
||||
+ * ActionGroup.select -> select: boolean "'Action Group is selected'"
|
||||
+ * Actuator.expanded -> show_expanded: boolean "'Set actuator expanded in the user interface'"
|
||||
+ * Actuator.name -> name: string "'NO DESCRIPTION'"
|
||||
+ * Actuator.pinned -> pinned: boolean "'Display when not linked to a visible states controller'"
|
||||
+ * Actuator.type -> type: enum "'NO DESCRIPTION'"
|
||||
+ * 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_blend_type: 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_enabled -> use_nla: boolean "'NLA stack is evaluated when evaluating this block'"
|
||||
+ * AnimData.nla_tracks -> nla_tracks: collection, "'(read-only) NLA Tracks (i.e. Animation Layers)'"
|
||||
+ * AnimViz.motion_paths -> motion_path: pointer, "'(read-only) Motion Path settings for visualisation'"
|
||||
+ * AnimViz.onion_skinning -> onion_skin_frames: pointer, "'(read-only) Onion Skinning (ghosting) settings for visualisation'"
|
||||
+ * AnimVizMotionPaths.after_current -> frame_after: 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 -> frame_before: 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.highlight_keyframes -> show_keyframe_highlight: boolean "'Emphasize position of keyframes on Motion Paths'"
|
||||
+ * AnimVizMotionPaths.search_all_action_keyframes -> show_keyframe_action_all: boolean "'For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)'"
|
||||
+ * AnimVizMotionPaths.show_frame_numbers -> show_frame_numbers: boolean "'Show frame numbers on Motion Paths'"
|
||||
+ * AnimVizMotionPaths.show_keyframe_numbers -> show_keyframe_numbers: boolean "'Show frame numbers of Keyframes on Motion Paths'"
|
||||
+ * AnimVizMotionPaths.type -> type: enum "'Type of range to show for Motion Paths'"
|
||||
+ * AnimVizOnionSkinning.after_current -> frame_after: int '"Number of frames to show after the current frame (only for \'Around Current Frame\' Onion-skinning method)"'
|
||||
+ * AnimVizOnionSkinning.before_current -> frame_before: 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.only_selected -> show_only_selected: boolean "'For Pose-Mode drawing, only draw ghosts for selected bones'"
|
||||
+ * AnimVizOnionSkinning.type -> type: enum "'Method used for determining what ghosts get drawn'"
|
||||
*convert to spaces.active* * 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.show_menus -> show_menus: boolean "'Show menus in the header'"
|
||||
+ * Area.spaces -> spaces: collection, "'(read-only) Spaces contained in this area, the first space is active'"
|
||||
+ * Area.type -> type: enum "'Space type'"
|
||||
+ * AreaLamp.dither -> use_dither: boolean "'Use 2x2 dithering for sampling (Constant Jittered sampling)'"
|
||||
+ * AreaLamp.gamma -> gamma: float "'Light gamma correction value'"
|
||||
+ * AreaLamp.jitter -> use_jitter: boolean "'Use noise for sampling (Constant Jittered sampling)'"
|
||||
+ * AreaLamp.only_shadow -> use_only_shadow: boolean "'Causes light to cast shadows only without illuminating objects'"
|
||||
+ * 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_layer -> use_shadow_layer: boolean "'Causes only objects on the same layer to cast shadows'"
|
||||
+ * 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_sample_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'"
|
||||
+ * AreaLamp.umbra -> use_umbra: boolean "'Emphasize parts that are fully shadowed (Constant Jittered sampling)'"
|
||||
+ * Armature.animation_data -> animation_data: pointer, "'(read-only) Animation data for this datablock'"
|
||||
+ * Armature.auto_ik -> use_auto_ik: boolean "'Add temporaral IK constraints while grabbing bones in Pose Mode'"
|
||||
+ * Armature.bones -> bones: collection, "'(read-only)'"
|
||||
+ * Armature.deform_envelope -> use_deform_envelopes: boolean "'Enable Bone Envelopes when defining deform'"
|
||||
+ * Armature.deform_quaternion -> use_deform_preserve_volume: boolean "'Deform rotation interpolation with quaternions'"
|
||||
+ * Armature.deform_vertexgroups -> use_deform_vertex_groups: boolean "'Enable Vertex Groups when defining deform'"
|
||||
+ * Armature.delay_deform -> use_deform_delay: boolean '"Don\'t deform children when manipulating bones in Pose Mode"'
|
||||
+ * Armature.draw_axes -> show_axes: boolean "'Draw bone axes'"
|
||||
+ * Armature.draw_custom_bone_shapes -> show_bone_custom_shapes: boolean "'Draw bones with their custom shapes'"
|
||||
+ * Armature.draw_group_colors -> show_group_colors: boolean "'Draw bone group colors'"
|
||||
+ * Armature.draw_names -> show_names: boolean "'Draw bone names'"
|
||||
+ * Armature.drawtype -> draw_type: enum "'NO DESCRIPTION'"
|
||||
+ * 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_only_selected -> show_only_ghost_selected: boolean "'NO DESCRIPTION'"
|
||||
+ * 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.layer -> layers: boolean "'Armature layer visibility'"
|
||||
+ * Armature.layer_protection -> layers_protected: boolean "'Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo'"
|
||||
+ * Armature.pose_position -> pose_position: enum "'Show armature in binding pose or final posed state'"
|
||||
+ * Armature.x_axis_mirror -> use_mirror_x: boolean "'Apply changes to matching bone on opposite side of X-Axis'"
|
||||
+ * 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 "'NO DESCRIPTION'"
|
||||
+ * 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.invert -> invert_vertex_group: boolean "'Invert vertex group influence'"
|
||||
+ * ArmatureModifier.multi_modifier -> use_multi_modifier: boolean "'Use same input as previous modifier, and mix results using overall vgroup'"
|
||||
+ * ArmatureModifier.object -> object: pointer "'Armature object to deform with'"
|
||||
+ * ArmatureModifier.quaternion -> use_deform_preserve_volume: boolean "'Deform rotation interpolation with quaternions'"
|
||||
+ * ArmatureModifier.use_bone_envelopes -> use_bone_envelopes: boolean "'NO DESCRIPTION'"
|
||||
+ * ArmatureModifier.use_vertex_groups -> use_vertex_groups: boolean "'NO DESCRIPTION'"
|
||||
+ * 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.add_offset_object -> use_object_offset: boolean '"Add another object\'s transformation to the total offset"'
|
||||
+ * ArrayModifier.constant_offset -> use_constant_offset: boolean "'Add a constant offset'"
|
||||
+ * ArrayModifier.constant_offset_displacement -> constant_offset_displace: float "'NO DESCRIPTION'"
|
||||
*CHECK THIS WITH SIMILAR* * 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 -> fit_length: float "'Length to fit array within'"
|
||||
+ * ArrayModifier.merge_adjacent_vertices -> use_merge_vertices: boolean "'Merge vertices in adjacent duplicates'"
|
||||
+ * ArrayModifier.merge_distance -> merge_threshold: float "'Limit below which to merge vertices'"
|
||||
+ * ArrayModifier.merge_end_vertices -> use_merge_vertices_cap: boolean "'Merge vertices in first and last duplicates'"
|
||||
+ * ArrayModifier.offset_object -> offset_object: pointer "'NO DESCRIPTION'"
|
||||
+ * ArrayModifier.relative_offset -> use_relative_offset: boolean '"Add an offset relative to the object\'s bounding box"'
|
||||
+ * ArrayModifier.relative_offset_displacement -> relative_offset_displace: float "'NO DESCRIPTION'"
|
||||
+ * 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.show_expanded -> show_expanded: boolean "'Show the expanded in the user interface'"
|
||||
+ * 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_limit: 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 "'NO DESCRIPTION'"
|
||||
+ * BevelModifier.only_vertices -> use_only_vertices: boolean "'Bevel verts/corners, not edges'"
|
||||
+ * BevelModifier.width -> width: float "'Bevel value/amount'"
|
||||
+ * BezierSplinePoint.co -> co: float "'Coordinates of the control point'"
|
||||
+ * BezierSplinePoint.handle1 -> handle_left: float "'Coordinates of the first handle'"
|
||||
+ * BezierSplinePoint.handle1_type -> handle_left_type: enum "'Handle types'"
|
||||
+ * BezierSplinePoint.handle2 -> handle_right: float "'Coordinates of the second handle'"
|
||||
+ * BezierSplinePoint.handle2_type -> handle_right_type: enum "'Handle types'"
|
||||
+ * BezierSplinePoint.hide -> hide: boolean "'Visibility status'"
|
||||
+ * BezierSplinePoint.radius -> radius: float, "'(read-only) Radius for bevelling'"
|
||||
+ * BezierSplinePoint.select_control_point -> select_control_point: boolean "'Control point selection status'"
|
||||
+ * BezierSplinePoint.select_left_handle -> select_left_handle: boolean "'Handle 1 selection status'"
|
||||
+ * BezierSplinePoint.select_right_handle -> select_right_handle: boolean "'Handle 2 selection status'"
|
||||
+ * 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.in_air -> use_in_air: boolean "'Use rule when boid is flying'"
|
||||
+ * BoidRule.name -> name: string "'Boid rule name'"
|
||||
+ * BoidRule.on_land -> use_on_land: boolean "'Use rule when boid is on land'"
|
||||
+ * 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'"
|
||||
+ * BoidRuleAvoid.predict -> use_predict: boolean "'Predict target movement'"
|
||||
+ * BoidRuleAvoidCollision.boids -> use_avoid: boolean "'Avoid collision with other boids'"
|
||||
+ * BoidRuleAvoidCollision.deflectors -> use_avoid_collision: boolean "'Avoid collision with deflector objects'"
|
||||
+ * 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.line -> use_line: boolean "'Follow leader in a line'"
|
||||
+ * BoidRuleFollowLeader.object -> object: pointer "'Follow this object instead of a boid'"
|
||||
+ * BoidRuleFollowLeader.queue_size -> queue_count: int "'How many boids in a line'"
|
||||
+ * BoidRuleGoal.object -> object: pointer "'Goal object'"
|
||||
+ * BoidRuleGoal.predict -> use_predict: boolean "'Predict target movement'"
|
||||
+ * 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 "'NO DESCRIPTION'"
|
||||
+ * BoidSettings.aggression -> aggression: float "'Boid will fight this times stronger enemy'"
|
||||
+ * BoidSettings.air_max_acc -> air_acc_max: float "'Maximum acceleration in air (relative to maximum speed)'"
|
||||
+ * BoidSettings.air_max_ave -> air_ave_max: float "'Maximum angular velocity in air (relative to 180 degrees)'"
|
||||
+ * BoidSettings.air_max_speed -> air_speed_max: float "'Maximum speed in air'"
|
||||
+ * BoidSettings.air_min_speed -> air_speed_min: 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.allow_climb -> use_climb: boolean "'Allow boids to climb goal objects'"
|
||||
+ * BoidSettings.allow_flight -> use_flight: boolean "'Allow boids to move in air'"
|
||||
+ * BoidSettings.allow_land -> use_land: boolean "'Allow boids to move on land'"
|
||||
+ * BoidSettings.banking -> bank: 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_acc_max: float "'Maximum acceleration on land (relative to maximum speed)'"
|
||||
+ * BoidSettings.land_max_ave -> land_ave_max: float "'Maximum angular velocity on land (relative to 180 degrees)'"
|
||||
+ * BoidSettings.land_max_speed -> land_speed_max: 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 -> land_smooth: 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 "'NO DESCRIPTION'"
|
||||
+ * BoidState.falloff -> falloff: float "'NO DESCRIPTION'"
|
||||
+ * BoidState.name -> name: string "'Boid state name'"
|
||||
+ * BoidState.rule_fuzziness -> rule_fuzzy: float "'NO DESCRIPTION'"
|
||||
+ * BoidState.rules -> rules: collection, "'(read-only)'"
|
||||
+ * BoidState.ruleset_type -> ruleset_type: enum "'How the rules in the list are evaluated'"
|
||||
+ * BoidState.volume -> volume: float "'NO DESCRIPTION'"
|
||||
+ * 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.connected -> use_connect: boolean, '"(read-only) When bone has a parent, bone\'s head is struck to the parent\'s tail"'
|
||||
+ * Bone.cyclic_offset -> use_cyclic_offset: boolean '"When bone doesn\'t have a parent, it receives cyclic offset effects"'
|
||||
+ * Bone.deform -> use_deform: boolean "'Bone does not deform any geometry'"
|
||||
+ * Bone.draw_wire -> show_wire: boolean "'Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes'"
|
||||
+ * 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.hide -> hide: boolean "'Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)'"
|
||||
+ * Bone.hide_select -> hide_select: boolean "'Bone is able to be selected'"
|
||||
+ * Bone.hinge -> use_hinge: boolean "'Bone inherits rotation or scale from parent bone'"
|
||||
+ * Bone.inherit_scale -> use_inherit_scale: boolean "'Bone inherits scaling from parent bone'"
|
||||
+ * Bone.layer -> layers: boolean "'Layers bone exists in'"
|
||||
+ * Bone.local_location -> use_local_location: boolean "'Bone location is set in local space'"
|
||||
+ * Bone.matrix -> matrix: float "'3x3 bone matrix'"
|
||||
+ * Bone.matrix_local -> matrix_local: float "'4x4 bone matrix relative to armature'"
|
||||
+ * Bone.multiply_vertexgroup_with_envelope -> use_envelope_multiply: boolean "'When deforming bone, multiply effects of Vertex Group weights with Envelope influence'"
|
||||
+ * Bone.name -> name: string "'NO DESCRIPTION'"
|
||||
+ * Bone.parent -> parent: pointer, "'(read-only) Parent bone (in same Armature)'"
|
||||
+ * Bone.select -> select: boolean "'NO DESCRIPTION'"
|
||||
+ * 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 "'NO DESCRIPTION'"
|
||||
+ * BooleanModifier.object -> object: pointer "'Mesh object to use for Boolean operation'"
|
||||
+ * BooleanModifier.operation -> operation: enum "'NO DESCRIPTION'"
|
||||
+ * BooleanProperty.array_length -> array_length: int, "'(read-only) Maximum length of the array, 0 means unlimited'"
|
||||
+ * BooleanProperty.default -> default: boolean, "'(read-only) Default value for this number'"
|
||||
+ * BooleanProperty.default_array -> default_array: boolean, "'(read-only) Default value for this array'"
|
||||
+ * Brush.add_col -> cursor_color_add: float "'Color of cursor when adding'"
|
||||
+ * Brush.autosmooth_factor -> autosmooth_factor: float "'Amount of smoothing to automatically apply to each stroke'"
|
||||
+ * 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 "'NO DESCRIPTION'"
|
||||
+ * Brush.color -> color: float "'NO DESCRIPTION'"
|
||||
+ * Brush.crease_pinch_factor -> crease_pinch_factor: float "'How much the crease brush pinches'"
|
||||
+ * 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.edge_to_edge -> use_edge_to_edge: boolean "'Drag anchor brush from edge-to-edge'"
|
||||
+ * Brush.icon_filepath -> icon_filepath: string "'File path to brush icon'"
|
||||
+ * Brush.imagepaint_tool -> imagepaint_tool: enum "'NO DESCRIPTION'"
|
||||
+ * Brush.jitter -> jitter: float "'Jitter the position of the brush while painting'"
|
||||
+ * Brush.normal_weight -> normal_weight: float "'How much grab will pull vertexes out of surface during a grab'"
|
||||
+ * Brush.plane_offset -> plane_offset: float "'Adjusts plane on which the brush acts towards or away from the object surface'"
|
||||
+ * Brush.plane_trim -> plane_trim: float "'If a vertex is further from offset plane than this then it is not affected'"
|
||||
+ * Brush.rate -> rate: float "'Interval between paints for Airbrush'"
|
||||
+ * Brush.restore_mesh -> use_restore_mesh: boolean "'Allows a single dot to be carefully positioned'"
|
||||
+ * Brush.sculpt_plane -> sculpt_plane: enum "'NO DESCRIPTION'"
|
||||
+ * Brush.sculpt_tool -> sculpt_tool: enum "'NO DESCRIPTION'"
|
||||
+ * 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.stroke_method -> stroke_method: enum "'NO DESCRIPTION'"
|
||||
+ * Brush.sub_col -> cursor_color_subtract: float "'Color of cursor when subtracting'"
|
||||
+ * Brush.texture -> texture: pointer "'NO DESCRIPTION'"
|
||||
+ * Brush.texture_angle_source -> texture_angle_source: enum "'NO DESCRIPTION'"
|
||||
*THIS NAMES ODD, CHANGE IT?* * Brush.texture_angle_source_no_random -> texture_angle_source_no_random: enum "'NO DESCRIPTION'"
|
||||
+ * Brush.texture_overlay_alpha -> texture_overlay_alpha: int "'NO DESCRIPTION'"
|
||||
+ * Brush.texture_sample_bias -> texture_sample_bias: float "'Value added to texture samples'"
|
||||
+ * Brush.texture_slot -> texture_slot: pointer, "'(read-only)'"
|
||||
+ * Brush.unprojected_radius -> unprojected_radius: float "'Radius of brush in Blender units'"
|
||||
+ * Brush.use_accumulate -> use_accumulate: boolean "'Accumulate stroke dabs on top of each other'"
|
||||
+ * Brush.use_adaptive_space -> use_adaptive_space: boolean "'Space daubs according to surface orientation instead of screen space'"
|
||||
+ * Brush.use_airbrush -> use_airbrush: boolean "'Keep applying paint effect while holding mouse (spray)'"
|
||||
+ * Brush.use_alpha -> use_alpha: boolean "'When this is disabled, lock alpha while painting'"
|
||||
+ * Brush.use_anchor -> use_anchor: boolean "'Keep the brush anchored to the initial location'"
|
||||
+ * Brush.use_custom_icon -> use_custom_icon: boolean "'Set the brush icon from an image file'"
|
||||
+ * Brush.use_frontface -> use_frontface: boolean "'Brush only affects vertexes that face the viewer'"
|
||||
+ * Brush.use_inverse_smooth_pressure -> use_inverse_smooth_pressure: boolean "'Lighter pressure causes more smoothing to be applied'"
|
||||
+ * Brush.use_jitter_pressure -> use_pressure_jitter: boolean "'Enable tablet pressure sensitivity for jitter'"
|
||||
+ * Brush.use_locked_size -> use_locked_size: boolean "'When locked brush stays same size relative to object; when unlocked brush size is given in pixels'"
|
||||
+ * Brush.use_offset_pressure -> use_offset_pressure: boolean "'Enable tablet pressure sensitivity for offset'"
|
||||
+ * Brush.use_original_normal -> use_original_normal: boolean "'When locked keep using normal of surface where stroke was initiated'"
|
||||
+ * Brush.use_paint_sculpt -> use_paint_sculpt: boolean "'Use this brush in sculpt mode'"
|
||||
+ * Brush.use_paint_texture -> use_paint_texture: boolean "'Use this brush in texture paint mode'"
|
||||
+ * Brush.use_paint_vertex -> use_paint_vertex: boolean "'Use this brush in vertex paint mode'"
|
||||
+ * Brush.use_paint_weight -> use_paint_weight: boolean "'Use this brush in weight paint mode'"
|
||||
+ * Brush.use_persistent -> use_persistent: boolean "'Sculpts on a persistent layer of the mesh'"
|
||||
+ * Brush.use_plane_trim -> use_plane_trim: boolean "'Enable Plane Trim'"
|
||||
+ * Brush.use_rake -> use_rake: boolean "'Rotate the brush texture to match the stroke direction'"
|
||||
+ * Brush.use_random_rotation -> use_random_rotation: boolean "'Rotate the brush texture at random'"
|
||||
+ * Brush.use_size_pressure -> use_pressure_size: boolean "'Enable tablet pressure sensitivity for size'"
|
||||
+ * Brush.use_smooth_stroke -> use_smooth_stroke: boolean "'Brush lags behind mouse and follows a smoother path'"
|
||||
+ * Brush.use_space -> use_space: boolean "'Limit brush application to the distance specified by spacing'"
|
||||
+ * Brush.use_space_atten -> use_space_atten: boolean "'Automatically adjusts strength to give consistent results for different spacings'"
|
||||
+ * Brush.use_spacing_pressure -> use_pressure_spacing: boolean "'Enable tablet pressure sensitivity for spacing'"
|
||||
+ * Brush.use_strength_pressure -> use_pressure_strength: boolean "'Enable tablet pressure sensitivity for strength'"
|
||||
+ * Brush.use_texture_overlay -> use_texture_overlay: boolean "'Show texture in viewport'"
|
||||
+ * Brush.use_wrap -> use_wrap: boolean "'Enable torus wrapping while painting'"
|
||||
+ * Brush.vertexpaint_tool -> vertexpaint_tool: enum "'NO DESCRIPTION'"
|
||||
+ * BrushTextureSlot.angle -> angle: float "'Defines brush texture rotation'"
|
||||
+ * BrushTextureSlot.map_mode -> map_mode: enum "'NO DESCRIPTION'"
|
||||
+ * BuildModifier.frame_start -> frame_start: float "'Specify the start frame of the effect'"
|
||||
+ * BuildModifier.length -> frame_length: float "'Specify the total time the build effect requires'"
|
||||
+ * BuildModifier.randomize -> use_random_order: boolean "'Randomize the faces or edges during build'"
|
||||
+ * 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.panorama -> use_panorama: boolean "'Render the scene with a cylindrical camera for pseudo-fisheye lens effects'"
|
||||
+ * 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.show_limits -> show_limits: boolean "'Draw the clipping range and focus point on the camera'"
|
||||
+ * Camera.show_mist -> show_mist: boolean "'Draw a line from the Camera to indicate the mist area'"
|
||||
+ * Camera.show_name -> show_name: boolean '"Show the active Camera\'s name in Camera view"'
|
||||
+ * Camera.show_passepartout -> show_passepartout: boolean "'Show a darkened overlay outside the image area in Camera view'"
|
||||
+ * Camera.show_title_safe -> show_title_safe: boolean "'Show indicators for the title safe zone in Camera view'"
|
||||
+ * Camera.type -> type: enum "'Camera types'"
|
||||
+ * CameraActuator.axis -> axis: enum "'Specify the axis the Camera will try to get behind'"
|
||||
+ * CameraActuator.height -> height: float "'NO DESCRIPTION'"
|
||||
+ * CameraActuator.max -> max: float "'NO DESCRIPTION'"
|
||||
+ * CameraActuator.min -> min: float "'NO DESCRIPTION'"
|
||||
+ * CameraActuator.object -> object: pointer "'Look at this Object'"
|
||||
+ * CastModifier.cast_type -> cast_type: enum "'NO DESCRIPTION'"
|
||||
+ * CastModifier.factor -> factor: float "'NO DESCRIPTION'"
|
||||
+ * CastModifier.from_radius -> use_radius_as_size: boolean "'Use radius as size of projection shape (0 = auto)'"
|
||||
+ * 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.use_transform -> use_transform: boolean "'Use object transform to control projection shape'"
|
||||
+ * CastModifier.vertex_group -> vertex_group: string "'Vertex group name'"
|
||||
+ * CastModifier.x -> use_x: boolean "'NO DESCRIPTION'"
|
||||
+ * CastModifier.y -> use_y: boolean "'NO DESCRIPTION'"
|
||||
+ * CastModifier.z -> use_z: boolean "'NO DESCRIPTION'"
|
||||
+ * ChildOfConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
+ * ChildOfConstraint.target -> target: pointer "'Target Object'"
|
||||
+ * ChildOfConstraint.use_location_x -> use_location_x: boolean "'Use X Location of Parent'"
|
||||
+ * ChildOfConstraint.use_location_y -> use_location_y: boolean "'Use Y Location of Parent'"
|
||||
+ * ChildOfConstraint.use_location_z -> use_location_z: boolean "'Use Z Location of Parent'"
|
||||
+ * ChildOfConstraint.use_rotation_x -> use_rotation_x: boolean "'Use X Rotation of Parent'"
|
||||
+ * ChildOfConstraint.use_rotation_y -> use_rotation_y: boolean "'Use Y Rotation of Parent'"
|
||||
+ * ChildOfConstraint.use_rotation_z -> use_rotation_z: boolean "'Use Z Rotation of Parent'"
|
||||
+ * ChildOfConstraint.use_scale_x -> use_scale_x: boolean "'Use X Scale of Parent'"
|
||||
+ * ChildOfConstraint.use_scale_y -> use_scale_y: boolean "'Use Y Scale of Parent'"
|
||||
+ * ChildOfConstraint.use_scale_z -> use_scale_z: boolean "'Use Z Scale of Parent'"
|
||||
+ * ClampToConstraint.cyclic -> use_cyclic: boolean "'Treat curve as cyclic curve (no clamping to curve bounding box'"
|
||||
+ * 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.enable_collision -> use_collision: boolean "'Enable collisions with other objects'"
|
||||
+ * ClothCollisionSettings.enable_self_collision -> use_self_collision: boolean "'Enable self collisions'"
|
||||
+ * 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 -> distance_min: 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_distance_min: 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 "'NO DESCRIPTION'"
|
||||
+ * 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 "'NO DESCRIPTION'"
|
||||
+ * ClothSettings.mass -> mass: float "'Mass of cloth material'"
|
||||
+ * ClothSettings.mass_vertex_group -> mass_vertex_group: string "'Vertex Group for pinning of vertices'"
|
||||
+ * ClothSettings.pin_cloth -> use_pin_cloth: boolean "'Enable pinning of cloth vertices to other objects/positions'"
|
||||
+ * 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.stiffness_scaling -> use_stiffness_scale: boolean "'If enabled, stiffness can be scaled along a weight painted vertex group'"
|
||||
+ * 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 "'NO DESCRIPTION'"
|
||||
*TODO* * CloudsTexture.stype -> stype: enum "'NO DESCRIPTION'"
|
||||
+ * CollectionProperty.fixed_type -> fixed_type: pointer, "'(read-only) Fixed pointer type, empty if variable type'"
|
||||
+ * CollisionModifier.settings -> settings: pointer, "'(read-only)'"
|
||||
+ * CollisionSensor.collision_type -> use_material: boolean "'Use material instead of property'"
|
||||
+ * CollisionSensor.material -> material: string "'Only look for Objects with this material'"
|
||||
+ * CollisionSensor.property -> property: string "'Only look for Objects with this property'"
|
||||
+ * CollisionSensor.pulse -> use_pulse: boolean "'Changes to the set of colliding objects generates pulse'"
|
||||
+ * 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.enabled -> use: boolean "'Enable this objects as a collider for physics systems'"
|
||||
+ * CollisionSettings.friction_factor -> friction_factor: float "'Amount of friction during particle collision'"
|
||||
+ * CollisionSettings.inner_thickness -> thickness_inner: float "'Inner face thickness'"
|
||||
+ * CollisionSettings.kill_particles -> use_particle_kill: boolean "'Kill colliding particles'"
|
||||
+ * CollisionSettings.outer_thickness -> thickness_outer: 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 "'NO DESCRIPTION'"
|
||||
+ * ColorRamp.total -> count: int, "'(read-only) Total number of elements'"
|
||||
+ * ColorRampElement.color -> color: float "'NO DESCRIPTION'"
|
||||
+ * ColorRampElement.position -> position: float "'NO DESCRIPTION'"
|
||||
+ * ColorSequence.color -> color: float "'NO DESCRIPTION'"
|
||||
+ * CompositorNode.type -> type: enum, "'(read-only)'"
|
||||
+ * CompositorNodeAlphaOver.convert_premul -> use_premultiply: boolean "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeAlphaOver.premul -> premul: float "'Mix Factor'"
|
||||
+ * CompositorNodeBilateralblur.iterations -> iterations: int "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBilateralblur.sigma_color -> sigma_color: float "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBilateralblur.sigma_space -> sigma_space: float "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.bokeh -> use_bokeh: boolean "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.factor -> factor: float "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.factor_x -> factor_x: float "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.factor_y -> factor_y: float "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.filter_type -> filter_type: enum "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.gamma -> use_gamma_correction: boolean "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.relative -> use_relative: boolean "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.sizex -> size_x: int "'NO DESCRIPTION'"
|
||||
+ * CompositorNodeBlur.sizey -> size_y: int "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
CompositorNodeColorSpill.channel -> channel: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeColorSpill.limit_channel -> limit_channel: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeColorSpill.ratio -> ratio: float "'Scale limit by value'"
|
||||
CompositorNodeColorSpill.unspill -> use_unspill: boolean "'Compensate all channels (diffenrently) by hand'"
|
||||
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.crop_size -> use_crop_size: boolean "'Whether to crop the size of the input image'"
|
||||
CompositorNodeCrop.x1 -> x1: int "'NO DESCRIPTION'"
|
||||
CompositorNodeCrop.x2 -> x2: int "'NO DESCRIPTION'"
|
||||
CompositorNodeCrop.y1 -> y1: int "'NO DESCRIPTION'"
|
||||
CompositorNodeCrop.y2 -> y2: int "'NO DESCRIPTION'"
|
||||
CompositorNodeCurveRGB.mapping -> mapping: pointer, "'(read-only)'"
|
||||
CompositorNodeCurveVec.mapping -> mapping: pointer, "'(read-only)'"
|
||||
CompositorNodeDBlur.angle -> angle: float "'NO DESCRIPTION'"
|
||||
CompositorNodeDBlur.center_x -> center_x: float "'NO DESCRIPTION'"
|
||||
CompositorNodeDBlur.center_y -> center_y: float "'NO DESCRIPTION'"
|
||||
CompositorNodeDBlur.distance -> distance: float "'NO DESCRIPTION'"
|
||||
CompositorNodeDBlur.iterations -> iterations: int "'NO DESCRIPTION'"
|
||||
CompositorNodeDBlur.spin -> spin: float "'NO DESCRIPTION'"
|
||||
CompositorNodeDBlur.wrap -> use_wrap: boolean "'NO DESCRIPTION'"
|
||||
CompositorNodeDBlur.zoom -> zoom: float "'NO DESCRIPTION'"
|
||||
CompositorNodeDefocus.angle -> angle: int "'Bokeh shape rotation offset in degrees'"
|
||||
CompositorNodeDefocus.bokeh -> bokeh: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeDefocus.f_stop -> f_stop: float "'Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius'"
|
||||
CompositorNodeDefocus.gamma_correction -> use_gamma_correction: boolean "'Enable gamma correction before and after main process'"
|
||||
CompositorNodeDefocus.max_blur -> blur_max: float "'blur limit, maximum CoC radius, 0=no limit'"
|
||||
CompositorNodeDefocus.preview -> use_preview: boolean "'Enable sampling mode, useful for preview when using low samplecounts'"
|
||||
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.use_zbuffer -> use_zbuffer: boolean "'Disable when using an image as input instead of actual zbuffer (auto enabled if node not image based, eg. time node)'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
CompositorNodeFlip.axis -> axis: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
CompositorNodeGlare.iterations -> iterations: int "'NO DESCRIPTION'"
|
||||
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.rotate_45 -> use_rotate_45: boolean "'Simple star filter: add 45 degree rotation offset'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
CompositorNodeHueSat.sat -> sat: float "'NO DESCRIPTION'"
|
||||
CompositorNodeHueSat.val -> val: float "'NO DESCRIPTION'"
|
||||
CompositorNodeIDMask.index -> index: int "'Pass index number to convert to alpha'"
|
||||
CompositorNodeImage.auto_refresh -> use_auto_refresh: boolean "'NO DESCRIPTION'"
|
||||
CompositorNodeImage.cyclic -> use_cyclic: boolean "'NO DESCRIPTION'"
|
||||
CompositorNodeImage.frames -> frames: int "'Number of images used in animation'"
|
||||
CompositorNodeImage.image -> image: pointer "'NO DESCRIPTION'"
|
||||
CompositorNodeImage.layer -> layer: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeImage.offset -> offset: int "'Offsets the number of the frame to use in the animation'"
|
||||
CompositorNodeImage.start -> start: int "'NO DESCRIPTION'"
|
||||
CompositorNodeInvert.alpha -> invert_alpha: boolean "'NO DESCRIPTION'"
|
||||
CompositorNodeInvert.rgb -> invert_rgb: boolean "'NO DESCRIPTION'"
|
||||
CompositorNodeLensdist.fit -> use_fit: boolean "'For positive distortion factor only: scale image such that black areas are not visible'"
|
||||
CompositorNodeLensdist.jitter -> use_jitter: boolean "'Enable/disable jittering; faster, but also noisier'"
|
||||
CompositorNodeLensdist.projector -> use_projector: boolean "'Enable/disable projector mode. Effect is applied in horizontal direction only'"
|
||||
CompositorNodeLevels.channel -> channel: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
CompositorNodeMapValue.max -> max: float "'NO DESCRIPTION'"
|
||||
CompositorNodeMapValue.min -> min: float "'NO DESCRIPTION'"
|
||||
CompositorNodeMapValue.offset -> offset: float "'NO DESCRIPTION'"
|
||||
CompositorNodeMapValue.size -> size: float "'NO DESCRIPTION'"
|
||||
CompositorNodeMapValue.use_max -> use_max: boolean "'NO DESCRIPTION'"
|
||||
CompositorNodeMapValue.use_min -> use_min: boolean "'NO DESCRIPTION'"
|
||||
CompositorNodeMath.operation -> operation: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeMixRGB.alpha -> use_alpha: boolean "'Include alpha of second input in this operation'"
|
||||
CompositorNodeMixRGB.blend_type -> blend_type: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeOutputFile.exr_codec -> exr_codec: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeOutputFile.exr_half -> use_exr_half: boolean "'NO DESCRIPTION'"
|
||||
CompositorNodeOutputFile.filepath -> filepath: string "'Output path for the image, same functionality as render output.'"
|
||||
CompositorNodeOutputFile.frame_end -> frame_end: int "'NO DESCRIPTION'"
|
||||
CompositorNodeOutputFile.frame_start -> frame_start: int "'NO DESCRIPTION'"
|
||||
CompositorNodeOutputFile.image_type -> image_type: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeOutputFile.quality -> quality: int "'NO DESCRIPTION'"
|
||||
CompositorNodePremulKey.mapping -> mapping: enum "'Conversion between premultiplied alpha and key alpha'"
|
||||
CompositorNodeRLayers.layer -> layer: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeRLayers.scene -> scene: pointer "'NO DESCRIPTION'"
|
||||
CompositorNodeRotate.filter -> filter: enum "'Method to use to filter rotation'"
|
||||
CompositorNodeScale.space -> space: enum "'Coordinate space to scale relative to'"
|
||||
CompositorNodeSplitViewer.axis -> axis: enum "'NO DESCRIPTION'"
|
||||
CompositorNodeSplitViewer.factor -> factor: int "'NO DESCRIPTION'"
|
||||
CompositorNodeTexture.node_output -> node_output: int "'For node-based textures, which output node to use'"
|
||||
CompositorNodeTexture.texture -> texture: pointer "'NO DESCRIPTION'"
|
||||
CompositorNodeTime.curve -> curve: pointer, "'(read-only)'"
|
||||
CompositorNodeTime.end -> end: int "'NO DESCRIPTION'"
|
||||
CompositorNodeTime.start -> start: int "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
CompositorNodeValToRGB.color_ramp -> color_ramp: pointer, "'(read-only)'"
|
||||
CompositorNodeVecBlur.curved -> use_curved: boolean "'Interpolate between frames in a bezier curve, rather than linearly'"
|
||||
CompositorNodeVecBlur.factor -> factor: float '"Scaling factor for motion vectors; actually \'shutter speed\' in frames"'
|
||||
CompositorNodeVecBlur.max_speed -> speed_max: int "'Maximum speed, or zero for none'"
|
||||
CompositorNodeVecBlur.min_speed -> speed_min: int "'Minimum speed for a pixel to be blurred; used to separate background from foreground'"
|
||||
CompositorNodeVecBlur.samples -> samples: int "'NO DESCRIPTION'"
|
||||
ConsoleLine.current_character -> current_character: int "'NO DESCRIPTION'"
|
||||
ConsoleLine.line -> line: string "'Text in the line'"
|
||||
Constraint.active -> active: boolean "'Constraint is the one being edited'"
|
||||
Constraint.disabled -> is_valid: boolean, "'(read-only) Constraint has invalid settings and will not be evaluated'"
|
||||
Constraint.enabled -> enabled: boolean "'Enable/Disable Constraint'"
|
||||
Constraint.expanded -> show_expanded: boolean '"Constraint\'s panel is expanded in UI"'
|
||||
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.proxy_local -> is_proxy_local: boolean "'Constraint was added in this proxy instance (i.e. did not belong to source Armature)'"
|
||||
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.detect_material -> use_material_detect: boolean "'Detect material instead of property'"
|
||||
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.fh_normal -> use_fh_normal: boolean "'Add a horizontal spring force on slopes'"
|
||||
ConstraintActuator.fh_paralel_axis -> use_fh_paralel_axis: boolean "'Keep object axis parallel to normal'"
|
||||
ConstraintActuator.force_distance -> use_force_distance: boolean "'Force distance of object to point of impact of ray'"
|
||||
ConstraintActuator.limit -> limit: enum "'NO DESCRIPTION'"
|
||||
ConstraintActuator.limit_max -> limit_max: float "'NO DESCRIPTION'"
|
||||
ConstraintActuator.limit_min -> limit_min: float "'NO DESCRIPTION'"
|
||||
ConstraintActuator.local -> use_local: boolean '"Set ray along object\'s axis or global axis"'
|
||||
ConstraintActuator.material -> material: string "'Ray detects only Objects with this material'"
|
||||
ConstraintActuator.max_angle -> angle_max: 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 -> rotation_max: float "'Reference Direction'"
|
||||
ConstraintActuator.min_angle -> angle_min: 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.normal -> use_normal: boolean "'Set object axis along (local axis) or parallel (global axis) to the normal at hit position'"
|
||||
ConstraintActuator.persistent -> use_persistent: boolean "'Persistent actuator: stays active even if ray does not reach target'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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.region_data -> region_data: 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.active -> use: boolean "'Object contributes to the fluid simulation'"
|
||||
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.reverse_frames -> use_reverse_frames: boolean "'Reverse control object movement'"
|
||||
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.expanded -> show_expanded: boolean "'Set controller expanded in the user interface'"
|
||||
Controller.name -> name: string "'NO DESCRIPTION'"
|
||||
Controller.priority -> use_priority: boolean "'Mark controller for execution before all non-marked controllers (good for startup scripts)'"
|
||||
Controller.state -> states: boolean, "'(read-only) Set Controller state index (1 to 30)'"
|
||||
Controller.type -> type: enum "'NO DESCRIPTION'"
|
||||
CopyLocationConstraint.head_tail -> head_tail: float "'Target along length of bone: Head=0, Tail=1'"
|
||||
CopyLocationConstraint.invert_x -> invert_x: boolean "'Invert the X location'"
|
||||
CopyLocationConstraint.invert_y -> invert_y: boolean "'Invert the Y location'"
|
||||
CopyLocationConstraint.invert_z -> invert_z: boolean "'Invert the Z location'"
|
||||
CopyLocationConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
CopyLocationConstraint.target -> target: pointer "'Target Object'"
|
||||
CopyLocationConstraint.use_offset -> use_offset: boolean "'Add original location into copied location'"
|
||||
CopyLocationConstraint.use_x -> use_x: boolean '"Copy the target\'s X location"'
|
||||
CopyLocationConstraint.use_y -> use_y: boolean '"Copy the target\'s Y location"'
|
||||
CopyLocationConstraint.use_z -> use_z: boolean '"Copy the target\'s Z location"'
|
||||
CopyRotationConstraint.invert_x -> invert_x: boolean "'Invert the X rotation'"
|
||||
CopyRotationConstraint.invert_y -> invert_y: boolean "'Invert the Y rotation'"
|
||||
CopyRotationConstraint.invert_z -> invert_z: boolean "'Invert the Z rotation'"
|
||||
CopyRotationConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
CopyRotationConstraint.target -> target: pointer "'Target Object'"
|
||||
CopyRotationConstraint.use_offset -> use_offset: boolean "'Add original rotation into copied rotation'"
|
||||
CopyRotationConstraint.use_x -> use_x: boolean '"Copy the target\'s X rotation"'
|
||||
CopyRotationConstraint.use_y -> use_y: boolean '"Copy the target\'s Y rotation"'
|
||||
CopyRotationConstraint.use_z -> use_z: boolean '"Copy the target\'s Z rotation"'
|
||||
CopyScaleConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
CopyScaleConstraint.target -> target: pointer "'Target Object'"
|
||||
CopyScaleConstraint.use_offset -> use_offset: boolean "'Add original scale into copied scale'"
|
||||
CopyScaleConstraint.use_x -> use_x: boolean '"Copy the target\'s X scale"'
|
||||
CopyScaleConstraint.use_y -> use_y: boolean '"Copy the target\'s Y scale"'
|
||||
CopyScaleConstraint.use_z -> use_z: boolean '"Copy the target\'s Z scale"'
|
||||
CopyTransformsConstraint.head_tail -> head_tail: float "'Target along length of bone: Head=0, Tail=1'"
|
||||
CopyTransformsConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
CopyTransformsConstraint.target -> target: pointer "'Target Object'"
|
||||
Curve.animation_data -> animation_data: pointer, "'(read-only) Animation data for this datablock'"
|
||||
Curve.auto_texspace -> use_auto_texspace: boolean '"Adjusts active object\'s texture space automatically when transforming object"'
|
||||
Curve.back -> use_fill_back: boolean "'Draw filled back for extruded/beveled curves'"
|
||||
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.draw_handles -> show_handles: boolean "'Display bezier handles in editmode'"
|
||||
Curve.draw_normals -> show_normals: boolean "'Display 3D curve normals in editmode'"
|
||||
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.front -> use_fill_front: boolean "'Draw filled front for extruded/beveled curves'"
|
||||
Curve.map_along_length -> use_map_along_length: boolean "'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'"
|
||||
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.use_deform_bounds -> use_deform_bounds: boolean "'Use the mesh bounds to clamp the deformation'"
|
||||
Curve.use_deform_fill -> use_fill_deform: boolean "'Fill curve after applying deformation'"
|
||||
Curve.use_path -> use_path: boolean "'Enable the curve to become a translation path'"
|
||||
Curve.use_path_follow -> use_path_follow: boolean "'Make curve path children to rotate along the path'"
|
||||
Curve.use_radius -> use_radius: boolean "'Option for paths: apply the curve radius with path following it and deforming'"
|
||||
Curve.use_stretch -> use_stretch: boolean "'Option for curve-deform: makes deformed child to stretch along entire path'"
|
||||
Curve.use_time_offset -> use_time_offset: boolean "'Children will use Time Offset value as path distance offset'"
|
||||
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'"
|
||||
CurveMapPoint.select -> select: boolean "'Selection state of the curve point'"
|
||||
CurveMapping.black_level -> black_level: float "'For RGB curves, the color that black is mapped to'"
|
||||
CurveMapping.clip -> use_clip: boolean "'Force the curve view to fit a defined boundary'"
|
||||
CurveMapping.clip_max_x -> clip_max_x: float "'NO DESCRIPTION'"
|
||||
CurveMapping.clip_max_y -> clip_max_y: float "'NO DESCRIPTION'"
|
||||
CurveMapping.clip_min_x -> clip_min_x: float "'NO DESCRIPTION'"
|
||||
CurveMapping.clip_min_y -> clip_min_y: float "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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'"
|
||||
DelaySensor.repeat -> use_repeat: boolean "'Toggle repeat option. If selected, the sensor restarts after Delay+Dur logic tics'"
|
||||
DisplaceModifier.direction -> direction: enum "'NO DESCRIPTION'"
|
||||
DisplaceModifier.midlevel -> midlevel: float "'Material value that gives no displacement'"
|
||||
DisplaceModifier.strength -> strength: float "'NO DESCRIPTION'"
|
||||
DisplaceModifier.texture -> texture: pointer "'NO DESCRIPTION'"
|
||||
DisplaceModifier.texture_coordinate_object -> texture_coordinate_object: pointer "'NO DESCRIPTION'"
|
||||
DisplaceModifier.texture_coordinates -> texture_coordinates: enum "'NO DESCRIPTION'"
|
||||
DisplaceModifier.uv_layer -> uv_layer: string "'UV layer name'"
|
||||
DisplaceModifier.vertex_group -> vertex_group: string "'Vertex group name'"
|
||||
DistortedNoiseTexture.distortion -> distortion: float "'NO DESCRIPTION'"
|
||||
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.generate_speed_vectors -> use_speed_vectors: boolean "'Generate speed vectors for vector blur'"
|
||||
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.override_time -> use_time_override: boolean '"Use a custom start and end time (in seconds) instead of the scene\'s timeline"'
|
||||
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.reverse_frames -> use_reverse_frames: boolean "'Reverse fluid frames'"
|
||||
DomainFluidSettings.slip_type -> slip_type: enum "'NO DESCRIPTION'"
|
||||
DomainFluidSettings.start_time -> start_time: float "'Simulation time of the first blender frame'"
|
||||
DomainFluidSettings.surface_smoothing -> surface_smooth: 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'"
|
||||
NEGATE * DopeSheet.collapse_summary -> show_expanded_summary: boolean "'Collapse summary when shown, so all other channels get hidden. (DopeSheet Editors Only)'"
|
||||
DopeSheet.display_armature -> show_armatures: boolean "'Include visualization of Armature related Animation data'"
|
||||
DopeSheet.display_camera -> show_cameras: boolean "'Include visualization of Camera related Animation data'"
|
||||
DopeSheet.display_curve -> show_curves: boolean "'Include visualization of Curve related Animation data'"
|
||||
DopeSheet.display_hidden -> display_hidden: boolean '"Include channels from objects/bone that aren\'t visible"'
|
||||
DopeSheet.display_lamp -> show_lamps: boolean "'Include visualization of Lamp related Animation data'"
|
||||
DopeSheet.display_material -> show_materials: boolean "'Include visualization of Material related Animation data'"
|
||||
DopeSheet.display_mesh -> show_meshes: boolean "'Include visualization of Mesh related Animation data'"
|
||||
DopeSheet.display_metaball -> show_metaballs: boolean "'Include visualization of Metaball related Animation data'"
|
||||
DopeSheet.display_node -> show_nodes: boolean "'Include visualization of Node related Animation data'"
|
||||
DopeSheet.display_particle -> show_particles: boolean "'Include visualization of Particle related Animation data'"
|
||||
DopeSheet.display_scene -> show_scenes: boolean "'Include visualization of Scene related Animation data'"
|
||||
DopeSheet.display_shapekeys -> show_shapekeys: boolean "'Include visualization of ShapeKey related Animation data'"
|
||||
DopeSheet.display_summary -> show_summary: boolean '"Display an additional \'summary\' line. (DopeSheet Editors only)"'
|
||||
DopeSheet.display_texture -> show_textures: boolean "'Include visualization of Texture related Animation data'"
|
||||
DopeSheet.display_transforms -> show_transforms: boolean "'Include visualization of Object-level Animation data (mostly Transforms)'"
|
||||
DopeSheet.display_world -> show_worlds: boolean "'Include visualization of World related Animation data'"
|
||||
DopeSheet.filtering_group -> filtering_group: pointer "'Group that included Object should be a member of'"
|
||||
DopeSheet.include_missing_nla -> show_missing_nla: boolean "'Include Animation Data blocks with no NLA data. (NLA Editor only)'"
|
||||
DopeSheet.only_group_objects -> show_only_group_objects: boolean "'Only include channels from Objects in the specified Group'"
|
||||
DopeSheet.only_selected -> show_only_selected: boolean "'Only include channels relating to selected objects and data'"
|
||||
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.invalid -> is_valid: boolean "'Driver could not be evaluated in past, so should be skipped'"
|
||||
Driver.show_debug_info -> show_debug_info: boolean "'Show intermediate values for the driver calculations to allow debugging of drivers'"
|
||||
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'"
|
||||
DriverTarget.use_local_space_transforms -> use_local_space_transform: boolean "'Use transforms in Local Space (as opposed to the worldspace default)'"
|
||||
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'"
|
||||
EdgeSplitModifier.use_edge_angle -> use_edge_angle: boolean "'Split edges with high angle between faces'"
|
||||
EdgeSplitModifier.use_sharp -> use_edge_sharp: boolean "'Split edges that are marked as sharp'"
|
||||
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.connected -> use_connect: boolean '"When bone has a parent, bone\'s head is struck to the parent\'s tail"'
|
||||
EditBone.cyclic_offset -> use_cyclic_offset: boolean '"When bone doesn\'t have a parent, it receives cyclic offset effects"'
|
||||
EditBone.deform -> use_deform: boolean "'Bone does not deform any geometry'"
|
||||
EditBone.draw_wire -> show_wire: boolean "'Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes'"
|
||||
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.hide -> hide: boolean "'Bone is not visible when in Edit Mode'"
|
||||
EditBone.hide_select -> hide_select: boolean "'Bone is able to be selected'"
|
||||
EditBone.hinge -> use_hinge: boolean "'Bone inherits rotation or scale from parent bone'"
|
||||
EditBone.inherit_scale -> use_inherit_scale: boolean "'Bone inherits scaling from parent bone'"
|
||||
EditBone.layer -> layers: boolean "'Layers bone exists in'"
|
||||
EditBone.local_location -> use_local_location: boolean "'Bone location is set in local space'"
|
||||
EditBone.lock -> lock: boolean "'Bone is not able to be transformed when in Edit Mode'"
|
||||
EditBone.matrix -> matrix: float, "'(read-only) Read-only matrix calculated from the roll (armature space)'"
|
||||
EditBone.multiply_vertexgroup_with_envelope -> use_envelope_multiply: boolean "'When deforming bone, multiply effects of Vertex Group weights with Envelope influence'"
|
||||
EditBone.name -> name: string "'NO DESCRIPTION'"
|
||||
EditBone.parent -> parent: pointer "'Parent edit bone (in same Armature)'"
|
||||
EditBone.roll -> roll: float "'Bone rotation around head-tail axis'"
|
||||
EditBone.select -> select: boolean "'NO DESCRIPTION'"
|
||||
EditBone.select_head -> select_head: boolean "'NO DESCRIPTION'"
|
||||
EditBone.select_tail -> select_tail: boolean "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
EditObjectActuator.enable_3d_tracking -> use_3d_tracking: boolean "'Enable 3D tracking'"
|
||||
EditObjectActuator.linear_velocity -> linear_velocity: float "'Velocity upon creation'"
|
||||
EditObjectActuator.local_angular_velocity -> use_local_angular_velocity: boolean "'Apply the rotation locally'"
|
||||
EditObjectActuator.local_linear_velocity -> use_local_linear_velocity: boolean "'Apply the transformation locally'"
|
||||
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.replace_display_mesh -> use_replace_display_mesh: boolean "'Replace the display mesh'"
|
||||
EditObjectActuator.replace_physics_mesh -> use_replace_physics_mesh: boolean "'Replace the physics mesh (triangle bounds only - compound shapes not supported)'"
|
||||
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.color_saturation -> color_saturation: float "'NO DESCRIPTION'"
|
||||
EffectSequence.convert_float -> use_float: boolean "'Convert input to float data'"
|
||||
EffectSequence.crop -> crop: pointer, "'(read-only)'"
|
||||
EffectSequence.de_interlace -> use_deinterlace: boolean "'For video movies to remove fields'"
|
||||
EffectSequence.flip_x -> use_flip_x: boolean "'Flip on the X axis'"
|
||||
EffectSequence.flip_y -> use_flip_y: boolean "'Flip on the Y axis'"
|
||||
EffectSequence.multiply_colors -> color_multiply: float "'NO DESCRIPTION'"
|
||||
EffectSequence.premultiply -> use_premultiply: boolean "'Convert RGB from key alpha to premultiplied alpha'"
|
||||
EffectSequence.proxy -> proxy: pointer, "'(read-only)'"
|
||||
EffectSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean "'Use a custom directory to store data'"
|
||||
EffectSequence.proxy_custom_file -> use_proxy_custom_file: boolean "'Use a custom file to read proxy data from'"
|
||||
EffectSequence.reverse_frames -> use_reverse_frames: boolean "'Reverse frame order'"
|
||||
EffectSequence.strobe -> strobe: float "'Only display every nth frame'"
|
||||
EffectSequence.transform -> transform: pointer, "'(read-only)'"
|
||||
EffectSequence.use_color_balance -> use_color_balance: boolean "'(3-Way color correction) on input'"
|
||||
EffectSequence.use_crop -> use_crop: boolean "'Crop image before processing'"
|
||||
EffectSequence.use_proxy -> use_proxy: boolean "'Use a preview proxy for this strip'"
|
||||
EffectSequence.use_translation -> use_translation: boolean "'Translate image before processing'"
|
||||
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.do_growing_hair -> apply_to_hair_growing: boolean "'Use force fields when growing hair'"
|
||||
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.ignore_layers -> layers_ignore: boolean "'Hide objects on these layers when generating the Environment Map'"
|
||||
EnvironmentMap.mapping -> mapping: enum "'NO DESCRIPTION'"
|
||||
EnvironmentMap.resolution -> resolution: int "'Pixel resolution of the rendered environment map'"
|
||||
EnvironmentMap.source -> source: enum "'NO DESCRIPTION'"
|
||||
EnvironmentMap.viewpoint_object -> viewpoint_object: pointer '"Object to use as the environment map\'s viewpoint location"'
|
||||
EnvironmentMap.zoom -> zoom: float "'NO DESCRIPTION'"
|
||||
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.filter_size_minimum -> use_filter_size_min: boolean "'Use Filter Size as a minimal filter value in pixels'"
|
||||
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'"
|
||||
EnvironmentMapTexture.mipmap -> use_mipmap: boolean "'Uses auto-generated MIP maps for the image'"
|
||||
EnvironmentMapTexture.mipmap_gauss -> use_mipmap_gauss: boolean "'Uses Gauss filter to sample down MIP maps'"
|
||||
Event.alt -> is_pressed_alt: boolean, "'(read-only) True when the Alt/Option key is held'"
|
||||
Event.ascii -> ascii: string, "'(read-only) Single ASCII character for this event'"
|
||||
Event.ctrl -> is_pressed_ctrl: boolean, "'(read-only) True when the Ctrl key is held'"
|
||||
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.oskey -> is_pressed_cmd: boolean, "'(read-only) True when the Cmd key is held'"
|
||||
Event.shift -> is_pressed_shift: boolean, "'(read-only) True when the Shift key is held'"
|
||||
Event.type -> type: enum, "'(read-only)'"
|
||||
Event.value -> value: enum, "'(read-only) The type of event, only applies to some'"
|
||||
ExplodeModifier.alive -> show_alive: boolean "'Show mesh when particles are alive'"
|
||||
ExplodeModifier.dead -> show_dead: boolean "'Show mesh when particles are dead'"
|
||||
ExplodeModifier.protect -> protect: float "'Clean vertex group edges'"
|
||||
ExplodeModifier.size -> use_size: boolean "'Use particle size for the shrapnel'"
|
||||
ExplodeModifier.split_edges -> use_edge_split: boolean "'Split face edges for nicer shrapnel'"
|
||||
ExplodeModifier.unborn -> show_unborn: boolean "'Show mesh when particles are unborn'"
|
||||
ExplodeModifier.vertex_group -> vertex_group: string "'NO DESCRIPTION'"
|
||||
ExpressionController.expression -> expression: string "'NO DESCRIPTION'"
|
||||
FCurve.array_index -> array_index: int "'Index to the specific property affected by F-Curve if applicable'"
|
||||
FCurve.auto_clamped_handles -> use_auto_handle_clamp: boolean "'All auto-handles for F-Curve are clamped'"
|
||||
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.enabled -> enabled: boolean "'False when F-Curve could not be evaluated in past, so should be skipped when evaluating'"
|
||||
FCurve.extrapolation -> extrapolation: enum "'NO DESCRIPTION'"
|
||||
FCurve.group -> group: pointer "'Action Group that this F-Curve belongs to'"
|
||||
FCurve.hide -> hide: boolean "'F-Curve and its keyframes are hidden in the Graph Editor graphs'"
|
||||
FCurve.keyframe_points -> keyframe_points: collection, "'(read-only) User-editable keyframes'"
|
||||
FCurve.lock -> lock: boolean '"F-Curve\'s settings cannot be edited"'
|
||||
FCurve.modifiers -> modifiers: collection, "'(read-only) Modifiers affecting the shape of the F-Curve'"
|
||||
FCurve.mute -> mute: boolean "'F-Curve is not evaluated'"
|
||||
FCurve.sampled_points -> sampled_points: collection, "'(read-only) Sampled animation data'"
|
||||
FCurve.select -> select: boolean "'F-Curve is selected for editing'"
|
||||
FCurveModifiers.active -> active: pointer "'Active F-Curve Modifier'"
|
||||
FCurveSample.co -> co: float "'Point coordinates'"
|
||||
FCurveSample.select -> select: boolean "'Selection status'"
|
||||
FModifier.active -> active: boolean "'F-Curve Modifier is the one being edited'"
|
||||
NEGATE * FModifier.disabled -> use: boolean, "'(read-only) F-Curve Modifier has invalid settings and will not be evaluated'"
|
||||
FModifier.expanded -> show_expanded: boolean '"F-Curve Modifier\'s panel is expanded in UI"'
|
||||
FModifier.mute -> mute: boolean "'F-Curve Modifier will not be evaluated'"
|
||||
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_max: float "'Upper distance from Reference Value for 1:1 default influence'"
|
||||
FModifierEnvelope.default_minimum -> default_min: 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 -> max: float "'Upper bound of envelope at this control-point'"
|
||||
FModifierEnvelopeControlPoint.minimum -> min: float "'Lower bound of envelope at this control-point'"
|
||||
FModifierFunctionGenerator.additive -> use_additive: boolean "'Values generated by this modifier are applied on top of the existing values instead of overwriting them'"
|
||||
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.additive -> use_additive: boolean "'Values generated by this modifier are applied on top of the existing values instead of overwriting them'"
|
||||
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 -> max_x: float "'Highest X value to allow'"
|
||||
FModifierLimits.maximum_y -> max_y: float "'Highest Y value to allow'"
|
||||
FModifierLimits.minimum_x -> min_x: float "'Lowest X value to allow'"
|
||||
FModifierLimits.minimum_y -> min_y: float "'Lowest Y value to allow'"
|
||||
FModifierLimits.use_maximum_x -> use_max_x: boolean "'Use the maximum X value'"
|
||||
FModifierLimits.use_maximum_y -> use_max_y: boolean "'Use the maximum Y value'"
|
||||
FModifierLimits.use_minimum_x -> use_min_x: boolean "'Use the minimum X value'"
|
||||
FModifierLimits.use_minimum_y -> use_min_y: boolean "'Use the minimum Y value'"
|
||||
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'"
|
||||
FModifierStepped.use_frame_end -> use_frame_end: boolean '"Restrict modifier to only act before its \'end\' frame"'
|
||||
FModifierStepped.use_frame_start -> use_frame_start: boolean '"Restrict modifier to only act after its \'start\' frame"'
|
||||
FcurveActuator.add -> use_add: boolean "'F-Curve is added to the current loc/rot/scale in global or local coordinate according to Local flag'"
|
||||
FcurveActuator.child -> apply_to_children: boolean "'Update F-Curve on all children Objects as well'"
|
||||
FcurveActuator.force -> use_force: boolean "'Apply F-Curve as a global or local force depending on the local option (dynamic objects only)'"
|
||||
FcurveActuator.frame_end -> frame_end: int "'NO DESCRIPTION'"
|
||||
FcurveActuator.frame_property -> frame_property: string '"Assign the action\'s current frame number to this property"'
|
||||
FcurveActuator.frame_start -> frame_start: int "'NO DESCRIPTION'"
|
||||
FcurveActuator.local -> use_local: boolean "'Let the F-Curve act in local coordinates, used in Force and Add mode'"
|
||||
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.do_absorption -> use_absorption: boolean "'Force gets absorbed by collision objects'"
|
||||
FieldSettings.do_location -> apply_to_location: boolean '"Effect particles\' location"'
|
||||
FieldSettings.do_rotation -> apply_to_rotation: boolean '"Effect particles\' dynamic rotation"'
|
||||
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.force_2d -> use_2d_force: boolean "'Apply force only in 2d'"
|
||||
FieldSettings.global_coordinates -> use_global_coordinates: boolean "'Use effector/global coordinates for turbulence'"
|
||||
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.guide_path_add -> use_guide_path_add: boolean "'Based on distance/falloff it adds a portion of the entire path'"
|
||||
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 -> distance_max: float "'Maximum distance for the field to work'"
|
||||
FieldSettings.minimum_distance -> distance_min: float '"Minimum distance for the field\'s fall-off"'
|
||||
FieldSettings.multiple_springs -> use_multiple_springs: boolean "'Every point is effected by multiple springs'"
|
||||
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_max: float "'Maximum radial distance for the field to work'"
|
||||
FieldSettings.radial_minimum -> radial_min: float '"Minimum radial distance for the field\'s fall-off"'
|
||||
FieldSettings.rest_length -> rest_length: float "'Rest length of the harmonic force'"
|
||||
FieldSettings.root_coordinates -> use_root_coordinates: boolean "'Texture coordinates from root particle locations'"
|
||||
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.use_coordinates -> use_object_coordinates: boolean "'Use object/global coordinates for texture'"
|
||||
FieldSettings.use_guide_path_weight -> use_guide_path_weight: boolean "'Use curve weights to influence the particle influence along the curve'"
|
||||
FieldSettings.use_max_distance -> use_max_distance: boolean "'Use a maximum distance for the field to work'"
|
||||
FieldSettings.use_min_distance -> use_min_distance: boolean '"Use a minimum distance for the field\'s fall-off"'
|
||||
FieldSettings.use_radial_max -> use_radial_max: boolean "'Use a maximum radial distance for the field to work'"
|
||||
FieldSettings.use_radial_min -> use_radial_min: boolean '"Use a minimum radial distance for the field\'s fall-off"'
|
||||
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.do_filter -> use_filter: boolean "'Enable filtering of files'"
|
||||
FileSelectParams.file -> file: string "'Active file in the file browser'"
|
||||
FileSelectParams.filter_blender -> use_filter_blender: boolean "'Show .blend files'"
|
||||
FileSelectParams.filter_folder -> use_filter_folder: boolean "'Show folders'"
|
||||
FileSelectParams.filter_font -> use_filter_font: boolean "'Show font files'"
|
||||
FileSelectParams.filter_image -> use_filter_image: boolean "'Show image files'"
|
||||
FileSelectParams.filter_movie -> use_filter_movie: boolean "'Show movie files'"
|
||||
FileSelectParams.filter_script -> use_filter_script: boolean "'Show script files'"
|
||||
FileSelectParams.filter_sound -> use_filter_sound: boolean "'Show sound files'"
|
||||
FileSelectParams.filter_text -> use_filter_text: boolean "'Show text files'"
|
||||
NEGATE * FileSelectParams.hide_dot -> show_hidden: boolean "'Hide hidden dot files'"
|
||||
FileSelectParams.sort -> sort: enum "'NO DESCRIPTION'"
|
||||
FileSelectParams.title -> title: string, "'(read-only) Title for the file browser'"
|
||||
Filter2DActuator.enable_motion_blur -> use_motion_blur: boolean "'Enable/Disable Motion Blur'"
|
||||
Filter2DActuator.filter_pass -> filter_pass: int "'Set filter order'"
|
||||
Filter2DActuator.glsl_shader -> glsl_shader: pointer "'NO DESCRIPTION'"
|
||||
Filter2DActuator.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
Filter2DActuator.motion_blur_factor -> motion_blur_factor: float "'Set motion blur factor'"
|
||||
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.sticky -> use_sticky: boolean "'Immobilize object while constrained'"
|
||||
FloorConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
FloorConstraint.target -> target: pointer "'Target Object'"
|
||||
FloorConstraint.use_rotation -> use_rotation: boolean '"Use the target\'s rotation to determine floor"'
|
||||
FluidFluidSettings.active -> use: boolean "'Object contributes to the fluid simulation'"
|
||||
FluidFluidSettings.export_animated_mesh -> use_animated_mesh: boolean "'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'"
|
||||
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'"
|
||||
FollowPathConstraint.use_curve_follow -> use_curve_follow: boolean "'Object will follow the heading and banking of the curve'"
|
||||
FollowPathConstraint.use_curve_radius -> use_curve_radius: boolean "'Objects scale by the curve radius'"
|
||||
FollowPathConstraint.use_fixed_position -> use_fixed_location: boolean "'Object will stay locked to a single point somewhere along the length of the curve regardless of time'"
|
||||
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'"
|
||||
Function.registered -> is_registered: boolean, "'(read-only) Function is registered as callback as part of type registration'"
|
||||
Function.registered_optional -> is_registered_optional: boolean, "'(read-only) Function is optionally registered as callback part of type registration'"
|
||||
GPencilFrame.frame_number -> frame_number: int "'The frame on which this sketch appears'"
|
||||
GPencilFrame.paint_lock -> is_edited: boolean "'Frame is being edited (painted on)'"
|
||||
GPencilFrame.select -> select: boolean "'Frame is selected for editing in the DopeSheet'"
|
||||
GPencilFrame.strokes -> strokes: collection, "'(read-only) Freehand curves defining the sketch on this frame'"
|
||||
GPencilLayer.active -> active: boolean "'Set active layer for editing'"
|
||||
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.frame_lock -> lock_frame: boolean "'Lock current frame displayed by layer'"
|
||||
GPencilLayer.frames -> frames: collection, "'(read-only) Sketches for this layer on different frames'"
|
||||
GPencilLayer.hide -> hide: boolean "'Set layer Visibility'"
|
||||
GPencilLayer.info -> info: string "'Layer name'"
|
||||
GPencilLayer.line_thickness -> line_width: int "'Thickness of strokes (in pixels)'"
|
||||
GPencilLayer.lock -> lock: boolean "'Protect layer from further editing and/or frame changes'"
|
||||
GPencilLayer.max_ghost_range -> ghost_range_max: 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'"
|
||||
GPencilLayer.select -> select: boolean "'Layer is selected for editing in the DopeSheet'"
|
||||
GPencilLayer.show_points -> show_points: boolean "'Draw the points which make up the strokes (for debugging purposes)'"
|
||||
GPencilLayer.use_onion_skinning -> use_onion_skinning: boolean "'Ghost frames on either side of frame'"
|
||||
GPencilStroke.points -> points: collection, "'(read-only) Stroke data points'"
|
||||
GPencilStrokePoint.co -> co: float "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
GameBooleanProperty.value -> value: boolean "'Property value'"
|
||||
GameFloatProperty.value -> value: float "'Property value'"
|
||||
GameIntProperty.value -> value: int "'Property value'"
|
||||
GameObjectSettings.actor -> use_actor: boolean "'Object is detected by the Near and Radar sensor'"
|
||||
GameObjectSettings.actuators -> actuators: collection, "'(read-only) Game engine actuators to act on events'"
|
||||
GameObjectSettings.all_states -> use_all_states: boolean "'Set all state bits'"
|
||||
GameObjectSettings.anisotropic_friction -> use_anisotropic_friction: boolean "'Enable anisotropic friction'"
|
||||
GameObjectSettings.collision_bounds -> collision_bounds: enum "'Selects the collision type'"
|
||||
GameObjectSettings.collision_compound -> use_collision_compound: boolean "'Add children to form a compound collision object'"
|
||||
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.debug_state -> show_debug_state: boolean "'Print state debug info in the game engine'"
|
||||
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.ghost -> use_ghost: boolean "'Object does not restitute collisions, like a ghost'"
|
||||
GameObjectSettings.initial_state -> states_initial: boolean "'Initial state when the game starts'"
|
||||
GameObjectSettings.lock_x_axis -> lock_location_x: boolean "'Disable simulation of linear motion along the X axis'"
|
||||
GameObjectSettings.lock_x_rot_axis -> lock_rotation_x: boolean "'Disable simulation of angular motion along the X axis'"
|
||||
GameObjectSettings.lock_y_axis -> lock_location_y: boolean "'Disable simulation of linear motion along the Y axis'"
|
||||
GameObjectSettings.lock_y_rot_axis -> lock_rotation_y: boolean "'Disable simulation of angular motion along the Y axis'"
|
||||
GameObjectSettings.lock_z_axis -> lock_location_z: boolean "'Disable simulation of linear motion along the Z axis'"
|
||||
GameObjectSettings.lock_z_rot_axis -> lock_rotation_z: boolean "'Disable simulation of angular motion along the Z axis'"
|
||||
GameObjectSettings.mass -> mass: float "'Mass of the object'"
|
||||
GameObjectSettings.material_physics -> use_material_physics: boolean "'Use physics settings in materials'"
|
||||
GameObjectSettings.maximum_velocity -> velocity_max: float "'Clamp velocity to this maximum speed'"
|
||||
GameObjectSettings.minimum_velocity -> velocity_min: float "'Clamp velocity to this minimum speed (except when totally still)'"
|
||||
NEGATE * GameObjectSettings.no_sleeping -> use_sleep: boolean "'Disable auto (de)activation in physics simulation'"
|
||||
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.rotate_from_normal -> use_rotate_from_normal: boolean "'Use face normal to rotate object, so that it points away from the surface'"
|
||||
GameObjectSettings.rotation_damping -> rotation_damping: float "'General rotation damping'"
|
||||
GameObjectSettings.sensors -> sensors: collection, "'(read-only) Game engine sensor to detect events'"
|
||||
GameObjectSettings.show_actuators -> show_actuators: boolean "'Shows actuators for this object in the user interface'"
|
||||
GameObjectSettings.show_controllers -> show_controllers: boolean "'Shows controllers for this object in the user interface'"
|
||||
GameObjectSettings.show_sensors -> show_sensors: boolean "'Shows sensors for this object in the user interface'"
|
||||
GameObjectSettings.show_state_panel -> show_state_panel: boolean "'Show state panel'"
|
||||
GameObjectSettings.soft_body -> soft_body: pointer, "'(read-only) Settings for Bullet soft body simulation'"
|
||||
GameObjectSettings.use_activity_culling -> use_activity_culling: boolean "'Disable simulation of angular motion along the Z axis'"
|
||||
GameObjectSettings.use_collision_bounds -> use_collision_bounds: boolean "'Specify a collision bounds type other than the default'"
|
||||
GameObjectSettings.used_state -> states_used: boolean, "'(read-only) States which are being used by controllers'"
|
||||
GameObjectSettings.visible_state -> states_visible: boolean "'State determining which controllers are displayed'"
|
||||
GameProperty.debug -> show_debug: boolean "'Print debug information for this property'"
|
||||
GameProperty.name -> name: string '"Available as GameObject attributes in the game engine\'s python API"'
|
||||
GameProperty.type -> type: enum "'NO DESCRIPTION'"
|
||||
GameSoftBodySettings.bending_const -> use_bending_constraints: boolean "'Enable bending constraints'"
|
||||
GameSoftBodySettings.cluster_iterations -> cluster_iterations: int "'Specify the number of cluster iterations'"
|
||||
GameSoftBodySettings.cluster_rigid_to_softbody -> use_cluster_rigid_to_softbody: boolean "'Enable cluster collision between soft and rigid body'"
|
||||
GameSoftBodySettings.cluster_soft_to_softbody -> use_cluster_soft_to_softbody: boolean "'Enable cluster collision between soft and soft body'"
|
||||
GameSoftBodySettings.dynamic_friction -> dynamic_friction: float "'Dynamic Friction'"
|
||||
GameSoftBodySettings.linstiff -> linear_stiffness: 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.shape_match -> use_shape_match: boolean "'Enable soft body shape matching goal'"
|
||||
GameSoftBodySettings.threshold -> threshold: float "'Shape matching threshold'"
|
||||
GameSoftBodySettings.welding -> weld_threshold: 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.only_boost -> use_only_boost: boolean "'Show the glow buffer only'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
GreasePencil.layers -> layers: collection, "'(read-only)'"
|
||||
GreasePencil.use_stroke_endpoints -> use_stroke_endpoints: boolean "'Only use the first and last parts of the stroke for snapping'"
|
||||
Group.dupli_offset -> dupli_offset: float "'Offset from the origin to use when instancing as DupliGroup'"
|
||||
Group.layer -> layers: boolean "'Layers visible when this groups is instanced as a dupli'"
|
||||
Group.objects -> objects: collection, "'(read-only) A collection of this groups objects'"
|
||||
Header.bl_idname -> bl_idname: string "'NO DESCRIPTION'"
|
||||
Header.bl_space_type -> bl_space_type: enum "'NO DESCRIPTION'"
|
||||
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.fake_user -> use_fake_user: boolean "'Saves this datablock even if it has no users'"
|
||||
ID.library -> library: pointer, "'(read-only) Library file the datablock is linked from'"
|
||||
ID.name -> name: string "'Unique datablock ID name'"
|
||||
ID.tag -> tag: boolean "'Tools can use this to tag data, (initial state is undefined)'"
|
||||
ID.users -> users: int, "'(read-only) Number of times this datablock is referenced'"
|
||||
IDProperty.collection -> collection: collection, "'(read-only)'"
|
||||
IDProperty.double -> double: float "'NO DESCRIPTION'"
|
||||
IDProperty.double_array -> double_array: float "'NO DESCRIPTION'"
|
||||
IDProperty.float -> float: float "'NO DESCRIPTION'"
|
||||
IDProperty.float_array -> float_array: float "'NO DESCRIPTION'"
|
||||
IDProperty.group -> group: pointer, "'(read-only)'"
|
||||
IDProperty.int -> int: int "'NO DESCRIPTION'"
|
||||
IDProperty.int_array -> int_array: int "'NO DESCRIPTION'"
|
||||
IDProperty.string -> string: string "'NO DESCRIPTION'"
|
||||
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.animated -> use_animation: boolean "'Use as animated texture in the game engine'"
|
||||
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.clamp_x -> use_clamp_x: boolean "'Disable texture repeating horizontally'"
|
||||
Image.clamp_y -> use_clamp_y: boolean "'Disable texture repeating vertically'"
|
||||
Image.depth -> depth: int, "'(read-only) Image bit depth'"
|
||||
Image.dirty -> is_dirty: boolean, "'(read-only) Image has changed and is not saved'"
|
||||
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.fields -> use_fields: boolean "'Use fields of the image'"
|
||||
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.has_data -> has_data: boolean, "'(read-only) True if this image has data'"
|
||||
Image.mapping -> mapping: enum "'Mapping type to use for this image in the game engine'"
|
||||
Image.packed_file -> packed_file: pointer, "'(read-only)'"
|
||||
Image.premultiply -> use_premultiply: boolean "'Convert RGB from key alpha to premultiplied alpha'"
|
||||
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 -> use_tiles: boolean "'Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)'"
|
||||
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.invert_stencil -> invert_stencil: boolean "'Invert the stencil layer'"
|
||||
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)'"
|
||||
ImagePaint.show_brush -> show_brush: boolean "'Enables brush shape while not drawing'"
|
||||
ImagePaint.show_brush_draw -> show_brush_draw: boolean "'Enables brush shape while drawing'"
|
||||
ImagePaint.use_backface_cull -> use_backface_culling: boolean "'Ignore faces pointing away from the view (faster)'"
|
||||
ImagePaint.use_clone_layer -> use_clone_layer: boolean "'Use another UV layer as clone source, otherwise use 3D the cursor as the source'"
|
||||
ImagePaint.use_normal_falloff -> use_normal_falloff: boolean "'Paint most on faces pointing towards the view'"
|
||||
ImagePaint.use_occlude -> use_occlude: boolean "'Only paint onto the faces directly under the brush (slower)'"
|
||||
ImagePaint.use_projection -> use_projection: boolean "'Use projection painting for improved consistency in the brush strokes'"
|
||||
ImagePaint.use_stencil_layer -> use_stencil_layer: boolean "'Set the mask layer from the UV layer buttons'"
|
||||
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.color_saturation -> color_saturation: float "'NO DESCRIPTION'"
|
||||
ImageSequence.convert_float -> use_float: boolean "'Convert input to float data'"
|
||||
ImageSequence.crop -> crop: pointer, "'(read-only)'"
|
||||
ImageSequence.de_interlace -> use_deinterlace: boolean "'For video movies to remove fields'"
|
||||
ImageSequence.directory -> directory: string "'NO DESCRIPTION'"
|
||||
ImageSequence.elements -> elements: collection, "'(read-only)'"
|
||||
ImageSequence.flip_x -> use_flip_x: boolean "'Flip on the X axis'"
|
||||
ImageSequence.flip_y -> use_flip_y: boolean "'Flip on the Y axis'"
|
||||
ImageSequence.multiply_colors -> multiply_colors: float "'NO DESCRIPTION'"
|
||||
ImageSequence.premultiply -> use_premultiply: boolean "'Convert RGB from key alpha to premultiplied alpha'"
|
||||
ImageSequence.proxy -> proxy: pointer, "'(read-only)'"
|
||||
ImageSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean "'Use a custom directory to store data'"
|
||||
ImageSequence.proxy_custom_file -> use_proxy_custom_file: boolean "'Use a custom file to read proxy data from'"
|
||||
ImageSequence.reverse_frames -> use_reverse_frames: boolean "'Reverse frame order'"
|
||||
ImageSequence.strobe -> strobe: float "'Only display every nth frame'"
|
||||
ImageSequence.transform -> transform: pointer, "'(read-only)'"
|
||||
ImageSequence.use_color_balance -> use_color_balance: boolean "'(3-Way color correction) on input'"
|
||||
ImageSequence.use_crop -> use_crop: boolean "'Crop image before processing'"
|
||||
ImageSequence.use_proxy -> use_proxy: boolean "'Use a preview proxy for this strip'"
|
||||
ImageSequence.use_translation -> use_translation: boolean "'Translate image before processing'"
|
||||
ImageTexture.calculate_alpha -> use_calculate_alpha: boolean "'Calculates an alpha channel based on RGB values in the image'"
|
||||
ImageTexture.checker_distance -> checker_distance: float "'Sets distance between checker tiles'"
|
||||
ImageTexture.checker_even -> use_checker_even: boolean "'Sets even checker tiles'"
|
||||
ImageTexture.checker_odd -> use_checker_odd: boolean "'Sets odd 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.filter_size_minimum -> use_minimum_filter_size: boolean "'Use Filter Size as a minimal filter value in pixels'"
|
||||
ImageTexture.flip_axis -> use_flip_axis: boolean '"Flips the texture\'s X and Y axis"'
|
||||
ImageTexture.image -> image: pointer "'NO DESCRIPTION'"
|
||||
ImageTexture.image_user -> image_user: pointer, "'(read-only) Parameters defining which layer, pass and frame of the image is displayed'"
|
||||
ImageTexture.interpolation -> use_interpolation: boolean "'Interpolates pixels using Area filter'"
|
||||
ImageTexture.invert_alpha -> invert_alpha: boolean "'Inverts all the alpha values in the image'"
|
||||
ImageTexture.mipmap -> use_mipmap: boolean "'Uses auto-generated MIP maps for the image'"
|
||||
ImageTexture.mipmap_gauss -> use_mipmap_gauss: boolean "'Uses Gauss filter to sample down MIP maps'"
|
||||
ImageTexture.mirror_x -> use_mirror_x: boolean "'Mirrors the image repetition on the X direction'"
|
||||
ImageTexture.mirror_y -> use_mirror_y: boolean "'Mirrors the image repetition on the Y direction'"
|
||||
ImageTexture.normal_map -> use_normal_map: boolean "'Uses image RGB values for normal mapping'"
|
||||
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'"
|
||||
ImageTexture.use_alpha -> use_alpha: boolean "'Uses the alpha channel information in the image'"
|
||||
ImageUser.auto_refresh -> use_auto_refresh: boolean "'Always refresh image on frame changes'"
|
||||
ImageUser.cyclic -> use_cyclic: boolean "'Cycle the images in the movie'"
|
||||
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.active -> use: boolean "'Object contributes to the fluid simulation'"
|
||||
InflowFluidSettings.export_animated_mesh -> use_animated_mesh: boolean "'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'"
|
||||
InflowFluidSettings.inflow_velocity -> inflow_velocity: float "'Initial velocity of fluid'"
|
||||
InflowFluidSettings.local_coordinates -> use_local_coordinates: boolean "'Use local coordinates for inflow. (e.g. for rotating objects)'"
|
||||
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.auto_step -> use_auto_step: boolean "'Automatically determine the optimal number of steps for best performance/accuracy trade off'"
|
||||
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 -> step_max: float "'Higher bound for timestep in second in case of automatic substeps'"
|
||||
Itasc.max_velocity -> velocity_max: float "'Maximum joint velocity in rad/s. Default=50'"
|
||||
Itasc.min_step -> step_min: float "'Lower bound for timestep in second in case of automatic substeps'"
|
||||
Itasc.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
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.all_events -> use_all_events: boolean "'Triggered by all events on this joysticks current type (axis/button/hat)'"
|
||||
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.relative -> use_relative: boolean "'Makes shape keys relative'"
|
||||
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'"
|
||||
KeyConfig.user_defined -> is_user_defined: boolean, "'(read-only) Indicates that a keyconfig was defined by the user'"
|
||||
KeyMap.children_expanded -> show_expanded_children: boolean "'Children expanded in the user interface'"
|
||||
KeyMap.items -> items: collection, "'(read-only) Items in the keymap, linking an operator to an input event'"
|
||||
KeyMap.items_expanded -> show_expanded_items: boolean "'Expanded in the user interface'"
|
||||
KeyMap.modal -> is_modal: boolean, "'(read-only) Indicates that a keymap is used for translate modal events for an operator'"
|
||||
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'"
|
||||
KeyMap.user_defined -> is_user_defined: boolean "'Keymap is defined by the user'"
|
||||
KeyMapItem.active -> active: boolean "'Activate or deactivate item'"
|
||||
KeyMapItem.alt -> pressed_alt: boolean "'Alt key pressed'"
|
||||
KeyMapItem.any -> pressed_any: boolean "'Any modifier keys pressed'"
|
||||
KeyMapItem.ctrl -> pressed_ctrl: boolean "'Control key pressed'"
|
||||
KeyMapItem.expanded -> show_expanded: boolean "'Show key map event and property details in the user interface'"
|
||||
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.oskey -> pressed_cmd: boolean "'Operating system key pressed'"
|
||||
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.shift -> pressed_shift: boolean "'Shift key pressed'"
|
||||
KeyMapItem.type -> type: enum "'Type of event'"
|
||||
KeyMapItem.value -> value: enum "'NO DESCRIPTION'"
|
||||
KeyboardSensor.all_keys -> use_all_keys: boolean "'Trigger this sensor on any keystroke'"
|
||||
KeyboardSensor.key -> key: enum "'NO DESCRIPTION'"
|
||||
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 -> handle_left: float "'Coordinates of the first handle'"
|
||||
Keyframe.handle1_type -> handle_left_type: enum "'Handle types'"
|
||||
Keyframe.handle2 -> handle_right: float "'Coordinates of the second handle'"
|
||||
Keyframe.handle2_type -> handle_right_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.select_control_point -> select_control_point: boolean "'Control point selection status'"
|
||||
Keyframe.select_left_handle -> select_left_handle: boolean "'Handle 1 selection status'"
|
||||
Keyframe.select_right_handle -> select_right_handle: boolean "'Handle 2 selection status'"
|
||||
Keyframe.type -> type: enum "'The type of keyframe'"
|
||||
KeyingSet.absolute -> use_absolute: boolean "'Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)'"
|
||||
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.insertkey_needed -> use_insertkey_needed: boolean '"Only insert keyframes where they\'re needed in the relevant F-Curves"'
|
||||
KeyingSet.insertkey_visual -> use_insertkey_visual: boolean '"Insert keyframes based on \'visual transforms\'"'
|
||||
KeyingSet.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb: boolean "'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'"
|
||||
KeyingSet.name -> name: string "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
KeyingSetInfo.bl_label -> bl_label: string "'NO DESCRIPTION'"
|
||||
KeyingSetInfo.insertkey_needed -> use_insertkey_needed: boolean '"Only insert keyframes where they\'re needed in the relevant F-Curves"'
|
||||
KeyingSetInfo.insertkey_visual -> use_insertkey_visual: boolean '"Insert keyframes based on \'visual transforms\'"'
|
||||
KeyingSetInfo.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb: boolean "'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'"
|
||||
KeyingSetPath.array_index -> array_index: int "'Index to the specific setting if applicable'"
|
||||
KeyingSetPath.data_path -> data_path: string "'Path to property setting'"
|
||||
KeyingSetPath.entire_array -> use_entire_array: boolean '"When an \'array/vector\' type is chosen (Location, Rotation, Color, etc.), entire array is to be used"'
|
||||
KeyingSetPath.group -> group: string "'Name of Action Group to assign setting(s) for this path to'"
|
||||
KeyingSetPath.grouping -> group_method: 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'"
|
||||
KeyingSetPath.insertkey_needed -> use_insertkey_needed: boolean '"Only insert keyframes where they\'re needed in the relevant F-Curves"'
|
||||
KeyingSetPath.insertkey_visual -> use_insertkey_visual: boolean '"Insert keyframes based on \'visual transforms\'"'
|
||||
KeyingSetPath.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb: boolean "'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
KinematicConstraint.pole_target -> pole_target: pointer "'Object for pole rotation'"
|
||||
KinematicConstraint.pos_lock_x -> lock_location_x: boolean "'Constraint position along X axis'"
|
||||
KinematicConstraint.pos_lock_y -> lock_location_y: boolean "'Constraint position along Y axis'"
|
||||
KinematicConstraint.pos_lock_z -> lock_location_z: boolean "'Constraint position along Z axis'"
|
||||
KinematicConstraint.rot_lock_x -> lock_rotation_x: boolean "'Constraint rotation along X axis'"
|
||||
KinematicConstraint.rot_lock_y -> lock_rotation_y: boolean "'Constraint rotation along Y axis'"
|
||||
KinematicConstraint.rot_lock_z -> lock_rotation_z: boolean "'Constraint rotation along Z axis'"
|
||||
KinematicConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
KinematicConstraint.target -> target: pointer "'Target Object'"
|
||||
KinematicConstraint.use_position -> use_location: boolean "'Chain follows position of target'"
|
||||
KinematicConstraint.use_rotation -> use_rotation: boolean "'Chain follows rotation of target'"
|
||||
KinematicConstraint.use_stretch -> use_stretch: boolean "'Enable IK Stretching'"
|
||||
KinematicConstraint.use_tail -> use_tail: boolean '"Include bone\'s tail as last element in chain"'
|
||||
KinematicConstraint.use_target -> use_target: boolean "'Disable for targetless IK'"
|
||||
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.diffuse -> use_diffuse: boolean "'Lamp does diffuse shading'"
|
||||
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.layer -> use_own_layer: boolean "'Illuminates objects only on the same layer the lamp is on'"
|
||||
Lamp.negative -> use_negative: boolean "'Lamp casts negative light'"
|
||||
Lamp.specular -> use_specular: boolean "'Lamp creates specular highlights'"
|
||||
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_intensity: 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_intensity: float "'Sun brightness'"
|
||||
LampSkySettings.sun_intensity -> sun_intensity: float "'Sun intensity'"
|
||||
LampSkySettings.sun_size -> sun_size: float "'Sun size'"
|
||||
LampSkySettings.use_atmosphere -> use_atmosphere: boolean "'Apply sun effect on atmosphere'"
|
||||
LampSkySettings.use_sky -> use_sky: boolean "'Apply sun effect on sky'"
|
||||
LampTextureSlot.color_factor -> color_factor: float "'Amount texture affects color values'"
|
||||
LampTextureSlot.map_color -> use_map_color: boolean "'Lets the texture affect the basic color of the lamp'"
|
||||
LampTextureSlot.map_shadow -> use_map_shadow: boolean "'Lets the texture affect the shadow color of the lamp'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
Lattice.interpolation_type_u -> interpolation_type_u: enum "'NO DESCRIPTION'"
|
||||
Lattice.interpolation_type_v -> interpolation_type_v: enum "'NO DESCRIPTION'"
|
||||
Lattice.interpolation_type_w -> interpolation_type_w: enum "'NO DESCRIPTION'"
|
||||
Lattice.outside -> use_outside: boolean "'Only draw, and take into account, the outer vertices'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
LimitDistanceConstraint.target -> target: pointer "'Target Object'"
|
||||
LimitLocationConstraint.limit_transform -> limit_transform: boolean "'Transforms are affected by this constraint as well'"
|
||||
LimitLocationConstraint.maximum_x -> max_x: float "'Highest X value to allow'"
|
||||
LimitLocationConstraint.maximum_y -> max_y: float "'Highest Y value to allow'"
|
||||
LimitLocationConstraint.maximum_z -> max_z: float "'Highest Z value to allow'"
|
||||
LimitLocationConstraint.minimum_x -> min_x: float "'Lowest X value to allow'"
|
||||
LimitLocationConstraint.minimum_y -> min_y: float "'Lowest Y value to allow'"
|
||||
LimitLocationConstraint.minimum_z -> min_z: float "'Lowest Z value to allow'"
|
||||
LimitLocationConstraint.use_maximum_x -> use_max_x: boolean "'Use the maximum X value'"
|
||||
LimitLocationConstraint.use_maximum_y -> use_max_y: boolean "'Use the maximum Y value'"
|
||||
LimitLocationConstraint.use_maximum_z -> use_max_z: boolean "'Use the maximum Z value'"
|
||||
LimitLocationConstraint.use_minimum_x -> use_min_x: boolean "'Use the minimum X value'"
|
||||
LimitLocationConstraint.use_minimum_y -> use_min_y: boolean "'Use the minimum Y value'"
|
||||
LimitLocationConstraint.use_minimum_z -> use_min_z: boolean "'Use the minimum Z value'"
|
||||
LimitRotationConstraint.limit_transform -> limit_transform: boolean "'Transforms are affected by this constraint as well'"
|
||||
LimitRotationConstraint.maximum_x -> max_x: float "'Highest X value to allow'"
|
||||
LimitRotationConstraint.maximum_y -> max_y: float "'Highest Y value to allow'"
|
||||
LimitRotationConstraint.maximum_z -> max_z: float "'Highest Z value to allow'"
|
||||
LimitRotationConstraint.minimum_x -> min_x: float "'Lowest X value to allow'"
|
||||
LimitRotationConstraint.minimum_y -> min_y: float "'Lowest Y value to allow'"
|
||||
LimitRotationConstraint.minimum_z -> min_z: float "'Lowest Z value to allow'"
|
||||
LimitRotationConstraint.use_limit_x -> use_limit_x: boolean "'Use the minimum X value'"
|
||||
LimitRotationConstraint.use_limit_y -> use_limit_y: boolean "'Use the minimum Y value'"
|
||||
LimitRotationConstraint.use_limit_z -> use_limit_z: boolean "'Use the minimum Z value'"
|
||||
LimitScaleConstraint.limit_transform -> limit_transform: boolean "'Transforms are affected by this constraint as well'"
|
||||
LimitScaleConstraint.maximum_x -> max_x: float "'Highest X value to allow'"
|
||||
LimitScaleConstraint.maximum_y -> max_y: float "'Highest Y value to allow'"
|
||||
LimitScaleConstraint.maximum_z -> max_z: float "'Highest Z value to allow'"
|
||||
LimitScaleConstraint.minimum_x -> min_x: float "'Lowest X value to allow'"
|
||||
LimitScaleConstraint.minimum_y -> min_y: float "'Lowest Y value to allow'"
|
||||
LimitScaleConstraint.minimum_z -> min_z: float "'Lowest Z value to allow'"
|
||||
LimitScaleConstraint.use_maximum_x -> use_max_x: boolean "'Use the maximum X value'"
|
||||
LimitScaleConstraint.use_maximum_y -> use_max_y: boolean "'Use the maximum Y value'"
|
||||
LimitScaleConstraint.use_maximum_z -> use_max_z: boolean "'Use the maximum Z value'"
|
||||
LimitScaleConstraint.use_minimum_x -> use_min_x: boolean "'Use the minimum X value'"
|
||||
LimitScaleConstraint.use_minimum_y -> use_min_y: boolean "'Use the minimum Y value'"
|
||||
LimitScaleConstraint.use_minimum_z -> use_min_z: boolean "'Use the minimum Z value'"
|
||||
LockedTrackConstraint.lock -> lock: enum "'Axis that points upward'"
|
||||
LockedTrackConstraint.subtarget -> subtarget: string "'NO DESCRIPTION'"
|
||||
LockedTrackConstraint.target -> target: pointer "'Target Object'"
|
||||
LockedTrackConstraint.track -> track: enum "'Axis that points to the target object'"
|
||||
Macro.bl_description -> bl_description: string "'NO DESCRIPTION'"
|
||||
Macro.bl_idname -> bl_idname: string "'NO DESCRIPTION'"
|
||||
Macro.bl_label -> bl_label: string "'NO DESCRIPTION'"
|
||||
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.debug -> show_debug: boolean "'Print debugging information in console'"
|
||||
Main.file_is_saved -> is_saved: boolean, "'(read-only) Has the current session been saved to disk as a .blend file'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
MarbleTexture.noisebasis2 -> noisebasis2: enum "'NO DESCRIPTION'"
|
||||
MarbleTexture.stype -> stype: enum "'NO DESCRIPTION'"
|
||||
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.invert -> invert_vertex_group: boolean "'Use vertices that are not part of region defined'"
|
||||
MaskModifier.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
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.cast_approximate -> use_cast_approximate: boolean "'Allow this material to cast shadows when using approximate ambient occlusion.'"
|
||||
Material.cast_buffer_shadows -> use_cast_buffer_shadows: boolean "'Allow this material to cast shadows from shadow buffer lamps'"
|
||||
Material.cast_shadows_only -> use_cast_shadows_only: boolean "'Makes objects with this material appear invisible, only casting shadows (not rendered)'"
|
||||
Material.cubic -> use_cubic: boolean "'Use cubic interpolation for diffuse values, for smoother transitions'"
|
||||
Material.darkness -> darkness: float "'Minnaert darkness'"
|
||||
Material.diffuse_color -> diffuse_color: float "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
Material.diffuse_ramp_factor -> diffuse_ramp_factor: float "'Blending factor (also uses alpha in Colorband)'"
|
||||
Material.diffuse_ramp_input -> diffuse_ramp_input: enum "'NO DESCRIPTION'"
|
||||
Material.diffuse_shader -> diffuse_shader: enum "'NO DESCRIPTION'"
|
||||
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'"
|
||||
NEGATE * Material.exclude_mist -> use_mist: boolean "'Excludes this material from mist effects (in world settings)'"
|
||||
Material.face_texture -> use_face_texture: boolean '"Replaces the object\'s base color with color from face assigned image textures"'
|
||||
Material.face_texture_alpha -> use_face_texture_alpha: boolean '"Replaces the object\'s base alpha value with alpha from face assigned image textures"'
|
||||
Material.full_oversampling -> use_full_oversampling: boolean "'Force this material to render full shading/textures for all anti-aliasing samples'"
|
||||
Material.halo -> halo: pointer, "'(read-only) Halo settings for the material'"
|
||||
Material.invert_z -> invert_z: boolean '"Renders material\'s faces with an inverted Z buffer (scanline only)"'
|
||||
Material.light_group -> light_group: pointer "'Limit lighting to lamps in this Group'"
|
||||
Material.light_group_exclusive -> use_light_group_exclusive: boolean "'Material uses the light group exclusively - these lamps are excluded from other scene lighting'"
|
||||
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.object_color -> use_object_color: boolean "'Modulate the result with a per-object color'"
|
||||
Material.only_shadow -> use_only_shadow: boolean '"Renders shadows as the material\'s alpha value, making materials transparent except for shadowed areas"'
|
||||
Material.physics -> physics: pointer, "'(read-only) Game physics settings'"
|
||||
Material.preview_render_type -> preview_render_type: enum "'Type of preview render'"
|
||||
Material.ray_shadow_bias -> use_ray_shadow_bias: boolean "'Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)'"
|
||||
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.receive_transparent_shadows -> use_transparent_shadows: boolean "'Allow this object to receive transparent shadows casted through other objects'"
|
||||
Material.roughness -> rough: float "'Oren-Nayar Roughness'"
|
||||
Material.shadeless -> use_shadeless: boolean "'Makes this material insensitive to light or shadow'"
|
||||
Material.shadow_buffer_bias -> shadow_buffer_bias: float "'Factor to multiply shadow buffer bias with (0 is ignore.)'"
|
||||
Material.shadow_casting_alpha -> shadow_cast_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.shadows -> use_shadows: boolean "'Allows this material to receive shadows'"
|
||||
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_hard: int "'NO DESCRIPTION'"
|
||||
Material.specular_intensity -> specular_intensity: float "'NO DESCRIPTION'"
|
||||
Material.specular_ior -> specular_ior: float "'NO DESCRIPTION'"
|
||||
Material.specular_ramp -> specular_ramp: pointer, "'(read-only) Color ramp used to affect specular shading'"
|
||||
Material.specular_ramp_blend -> specular_ramp_blend: enum "'NO DESCRIPTION'"
|
||||
Material.specular_ramp_factor -> specular_ramp_factor: float "'Blending factor (also uses alpha in Colorband)'"
|
||||
Material.specular_ramp_input -> specular_ramp_input: enum "'NO DESCRIPTION'"
|
||||
Material.specular_shader -> specular_shader: enum "'NO DESCRIPTION'"
|
||||
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.tangent_shading -> use_tangent_shading: boolean '"Use the material\'s tangent vector instead of the normal for shading - for anisotropic shading effects"'
|
||||
Material.texture_slots -> texture_slots: collection, "'(read-only) Texture slots defining the mapping and influence of textures'"
|
||||
Material.traceable -> use_traceable: boolean "'Include this material and geometry that uses it in ray tracing calculations'"
|
||||
Material.translucency -> translucency: float "'Amount of diffuse shading on the back side'"
|
||||
Material.transparency -> use_transparency: boolean "'Render material as transparent'"
|
||||
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.use_diffuse_ramp -> use_diffuse_ramp: boolean "'Toggle diffuse ramp operations'"
|
||||
Material.use_nodes -> use_nodes: boolean "'Use shader nodes to render the material'"
|
||||
Material.use_sky -> use_sky: boolean "'Renders this material with zero alpha, with sky background in place (scanline only)'"
|
||||
Material.use_specular_ramp -> use_specular_ramp: boolean "'Toggle specular ramp operations'"
|
||||
Material.use_textures -> use_textures: boolean "'Enable/Disable each texture'"
|
||||
Material.vertex_color_light -> use_vertex_color_light: boolean "'Add vertex colors as additional lighting'"
|
||||
Material.vertex_color_paint -> use_vertex_color_paint: boolean '"Replaces object base color with vertex colors (multiplies with \'texture face\' face assigned textures)"'
|
||||
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_mode -> use_flare_mode: boolean "'Renders halo as a lensflare'"
|
||||
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 -> hard: 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.lines -> use_lines: boolean "'Renders star shaped lines over halo'"
|
||||
MaterialHalo.ring -> use_ring: boolean "'Renders rings over 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.shaded -> use_shading: boolean "'Lets halo receive light and shadows from external objects'"
|
||||
MaterialHalo.size -> size: float "'Sets the dimension of the halo'"
|
||||
MaterialHalo.soft -> use_soft: boolean "'Softens the edges of halos at intersections with other geometry'"
|
||||
MaterialHalo.star -> use_star: boolean "'Renders halo as a star'"
|
||||
MaterialHalo.star_tips -> star_tips: int "'Sets the number of points on the star shaped halo'"
|
||||
MaterialHalo.texture -> use_texture: boolean "'Gives halo a texture'"
|
||||
MaterialHalo.vertex_normal -> use_vertex_normal: boolean "'Uses the vertex normal to specify the dimension of the halo'"
|
||||
MaterialHalo.xalpha -> use_extreme_alpha: boolean "'Uses extreme alpha'"
|
||||
MaterialPhysics.align_to_normal -> use_align_to_normal: boolean "'Align dynamic game objects along the surface normal, when inside the physics distance area'"
|
||||
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.enabled -> use: boolean "'Enable raytraced reflections'"
|
||||
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.blender_units -> use_blender_units: boolean "'Use Blender units for widths instead of pixels'"
|
||||
MaterialStrand.min_size -> size_min: 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.surface_diffuse -> use_surface_diffuse: boolean "'Make diffuse shading more similar to shading the surface'"
|
||||
MaterialStrand.tangent_shading -> use_tangent_shading: boolean "'Uses direction of strands as normal for tangent-shading'"
|
||||
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.enabled -> use: boolean "'Enable diffuse subsurface scatting effects in a material'"
|
||||
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.enabled -> use: boolean "'Enable this material texture slot'"
|
||||
MaterialTextureSlot.from_dupli -> use_from_dupli: boolean '"Dupli\'s instanced from verts, faces or particles, inherit texture coordinate from their parent"'
|
||||
MaterialTextureSlot.from_original -> use_from_original: boolean '"Dupli\'s derive their object coordinates from the original objects transformation"'
|
||||
MaterialTextureSlot.hardness_factor -> hard_factor: float "'Amount texture affects hardness'"
|
||||
MaterialTextureSlot.map_alpha -> use_map_alpha: boolean "'Causes the texture to affect the alpha value'"
|
||||
MaterialTextureSlot.map_ambient -> use_map_ambient: boolean "'Causes the texture to affect the value of ambient'"
|
||||
MaterialTextureSlot.map_colordiff -> use_map_colordiff: boolean "'Causes the texture to affect basic color of the material'"
|
||||
MaterialTextureSlot.map_coloremission -> use_map_coloremission: boolean "'Causes the texture to affect the color of emission'"
|
||||
MaterialTextureSlot.map_colorreflection -> use_map_colorreflection: boolean "'Causes the texture to affect the color of scattered light'"
|
||||
MaterialTextureSlot.map_colorspec -> use_map_colorspec: boolean "'Causes the texture to affect the specularity color'"
|
||||
MaterialTextureSlot.map_colortransmission -> use_map_colortransmission: boolean "'Causes the texture to affect the result color after other light has been scattered/absorbed'"
|
||||
MaterialTextureSlot.map_density -> use_map_density: boolean '"Causes the texture to affect the volume\'s density"'
|
||||
MaterialTextureSlot.map_diffuse -> use_map_diffuse: boolean "'Causes the texture to affect the value of the materials diffuse reflectivity'"
|
||||
MaterialTextureSlot.map_displacement -> use_map_displacement: boolean "'Let the texture displace the surface'"
|
||||
MaterialTextureSlot.map_emission -> use_map_emission: boolean '"Causes the texture to affect the volume\'s emission"'
|
||||
MaterialTextureSlot.map_emit -> use_map_emit: boolean "'Causes the texture to affect the emit value'"
|
||||
MaterialTextureSlot.map_hardness -> use_map_hardness: boolean "'Causes the texture to affect the hardness value'"
|
||||
MaterialTextureSlot.map_mirror -> use_map_mirror: boolean "'Causes the texture to affect the mirror color'"
|
||||
MaterialTextureSlot.map_normal -> use_map_normal: boolean "'Causes the texture to affect the rendered normal'"
|
||||
MaterialTextureSlot.map_raymir -> use_map_raymir: boolean "'Causes the texture to affect the ray-mirror value'"
|
||||
MaterialTextureSlot.map_reflection -> use_map_reflect: boolean '"Causes the texture to affect the reflected light\'s brightness"'
|
||||
MaterialTextureSlot.map_scattering -> use_map_scatter: boolean '"Causes the texture to affect the volume\'s scattering"'
|
||||
MaterialTextureSlot.map_specular -> use_map_specular: boolean "'Causes the texture to affect the value of specular reflectivity'"
|
||||
MaterialTextureSlot.map_translucency -> use_map_translucency: boolean "'Causes the texture to affect the translucency value'"
|
||||
MaterialTextureSlot.map_warp -> use_map_warp: boolean "'Let the texture warp texture coordinates of next channels'"
|
||||
MaterialTextureSlot.mapping -> mapping: enum "'NO DESCRIPTION'"
|
||||
MaterialTextureSlot.mirror_factor -> mirror_factor: float "'Amount texture affects mirror color'"
|
||||
MaterialTextureSlot.new_bump -> use_new_bump: boolean "'Use new, corrected bump mapping code (backwards compatibility option)'"
|
||||
MaterialTextureSlot.normal_factor -> normal_factor: float "'Amount texture affects normal values'"
|
||||
MaterialTextureSlot.normal_map_space -> normal_map_space: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
MaterialTextureSlot.y_mapping -> y_mapping: enum "'NO DESCRIPTION'"
|
||||
MaterialTextureSlot.z_mapping -> z_mapping: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
MaterialVolume.external_shadows -> use_external_shadows: boolean "'Receive shadows from sources outside the volume (temporary)'"
|
||||
MaterialVolume.light_cache -> use_light_cache: boolean "'Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy'"
|
||||
MaterialVolume.lighting_mode -> light_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 "'NO DESCRIPTION'"
|
||||
Menu.bl_label -> bl_label: string "'NO DESCRIPTION'"
|
||||
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.all_edges -> show_all_edges: boolean "'Displays all edges for wireframe in all view modes in the 3D view'"
|
||||
Mesh.animation_data -> animation_data: pointer, "'(read-only) Animation data for this datablock'"
|
||||
Mesh.auto_texspace -> use_auto_texspace: boolean '"Adjusts active object\'s texture space automatically when transforming object"'
|
||||
Mesh.autosmooth -> use_autosmooth: boolean '"Treats all set-smoothed faces with angles less than the specified angle as \'smooth\' during render"'
|
||||
Mesh.autosmooth_angle -> autosmooth_angle: int '"Defines maximum angle between face normals that \'Auto Smooth\' will operate on"'
|
||||
Mesh.double_sided -> show_double_sided: boolean "'Render/display the mesh with double or single sided lighting'"
|
||||
Mesh.draw_bevel_weights -> show_bevel_weights: boolean "'Displays weights created for the Bevel modifier'"
|
||||
Mesh.draw_creases -> show_creases: boolean "'Displays creases created for subsurf weighting'"
|
||||
Mesh.draw_edge_angle -> show_edge_angle: boolean "'Displays the angles in the selected edges in degrees'"
|
||||
Mesh.draw_edge_length -> show_edge_length: boolean "'Displays selected edge lengths, Using global values when set in the transform panel'"
|
||||
Mesh.draw_edges -> show_edges: boolean "'Displays selected edges using highlights in the 3D view and UV editor'"
|
||||
Mesh.draw_face_area -> show_face_area: boolean "'Displays the area of selected faces'"
|
||||
Mesh.draw_faces -> show_faces: boolean "'Displays all faces as shades in the 3D view and UV editor'"
|
||||
Mesh.draw_normals -> show_normals: boolean "'Displays face normals as lines'"
|
||||
Mesh.draw_seams -> show_seams: boolean "'Displays UV unwrapping seams'"
|
||||
Mesh.draw_sharp -> show_sharp: boolean "'Displays sharp edges, used with the EdgeSplit modifier'"
|
||||
Mesh.draw_vertex_normals -> show_vertex_normals: boolean "'Displays vertex normals as lines'"
|
||||
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.use_mirror_topology -> use_mirror_topology: boolean "'Use topology based mirroring'"
|
||||
Mesh.use_mirror_x -> use_mirror_x: boolean "'X Axis mirror editing'"
|
||||
Mesh.use_paint_mask -> use_paint_mask: boolean "'Face selection masking for painting'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
MeshColor.color2 -> color2: float "'NO DESCRIPTION'"
|
||||
MeshColor.color3 -> color3: float "'NO DESCRIPTION'"
|
||||
MeshColor.color4 -> color4: float "'NO DESCRIPTION'"
|
||||
MeshColorLayer.active -> active: boolean "'Sets the layer as active for display and editing'"
|
||||
MeshColorLayer.active_render -> active_render: boolean "'Sets the layer as active for rendering'"
|
||||
MeshColorLayer.data -> data: collection, "'(read-only)'"
|
||||
MeshColorLayer.name -> name: string "'NO DESCRIPTION'"
|
||||
MeshDeformModifier.dynamic -> use_dynamic_bind: boolean "'Recompute binding dynamically on top of other deformers (slower and more memory consuming.)'"
|
||||
MeshDeformModifier.invert -> invert_vertex_group: boolean "'Invert vertex group influence'"
|
||||
MeshDeformModifier.is_bound -> is_bound: boolean, "'(read-only) Whether geometry has been bound to control cage'"
|
||||
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.fgon -> is_fgon: boolean, "'(read-only) Fgon edge'"
|
||||
MeshEdge.hide -> hide: boolean "'NO DESCRIPTION'"
|
||||
MeshEdge.index -> index: int, "'(read-only) Index number of the vertex'"
|
||||
MeshEdge.loose -> is_loose: boolean, "'(read-only) Loose edge'"
|
||||
MeshEdge.seam -> use_seam: boolean "'Seam edge for UV unwrapping'"
|
||||
MeshEdge.select -> select: boolean "'NO DESCRIPTION'"
|
||||
MeshEdge.sharp -> use_sharp: boolean "'Sharp edge for the EdgeSplit modifier'"
|
||||
MeshEdge.verts -> verts: int "'Vertex indices'"
|
||||
MeshFace.area -> area: float, "'(read-only) read only area of the face'"
|
||||
MeshFace.hide -> hide: boolean "'NO DESCRIPTION'"
|
||||
MeshFace.index -> index: int, "'(read-only) Index number of the vertex'"
|
||||
MeshFace.material_index -> material_index: int "'NO DESCRIPTION'"
|
||||
MeshFace.normal -> normal: float, "'(read-only) local space unit length normal vector for this face'"
|
||||
MeshFace.select -> select: boolean "'NO DESCRIPTION'"
|
||||
MeshFace.smooth -> use_smooth: boolean "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
MeshFloatPropertyLayer.data -> data: collection, "'(read-only)'"
|
||||
MeshFloatPropertyLayer.name -> name: string "'NO DESCRIPTION'"
|
||||
MeshIntProperty.value -> value: int "'NO DESCRIPTION'"
|
||||
MeshIntPropertyLayer.data -> data: collection, "'(read-only)'"
|
||||
MeshIntPropertyLayer.name -> name: string "'NO DESCRIPTION'"
|
||||
MeshSticky.co -> co: float "'Sticky texture coordinate location'"
|
||||
MeshStringProperty.value -> value: string "'NO DESCRIPTION'"
|
||||
MeshStringPropertyLayer.data -> data: collection, "'(read-only)'"
|
||||
MeshStringPropertyLayer.name -> name: string "'NO DESCRIPTION'"
|
||||
MeshTextureFace.alpha_sort -> use_alpha_sort: boolean "'Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)'"
|
||||
MeshTextureFace.billboard -> use_billboard: boolean "'Billboard with Z-axis constraint'"
|
||||
MeshTextureFace.collision -> use_collision: boolean "'Use face for collision and ray-sensor detection'"
|
||||
MeshTextureFace.halo -> use_halo: boolean "'Screen aligned billboard'"
|
||||
MeshTextureFace.image -> image: pointer "'NO DESCRIPTION'"
|
||||
MeshTextureFace.invisible -> hide: boolean "'Make face invisible'"
|
||||
MeshTextureFace.light -> use_light: boolean "'Use light for face'"
|
||||
MeshTextureFace.object_color -> use_object_color: boolean "'Use ObColor instead of vertex colors'"
|
||||
MeshTextureFace.select_uv -> select_uv: boolean "'NO DESCRIPTION'"
|
||||
MeshTextureFace.shadow -> use_shadow_face: boolean "'Face is used for shadow'"
|
||||
MeshTextureFace.shared -> use_blend_shared: boolean "'Blend vertex colors across face when vertices are shared'"
|
||||
MeshTextureFace.tex -> use_texture: boolean "'Render face with texture'"
|
||||
MeshTextureFace.text -> use_bitmap_text: boolean "'Enable bitmap text on face'"
|
||||
MeshTextureFace.transp -> transp: enum "'Transparency blending mode'"
|
||||
MeshTextureFace.twoside -> use_twoside: boolean "'Render face two-sided'"
|
||||
MeshTextureFace.uv -> uv: float "'NO DESCRIPTION'"
|
||||
MeshTextureFace.uv1 -> uv1: float "'NO DESCRIPTION'"
|
||||
MeshTextureFace.uv2 -> uv2: float "'NO DESCRIPTION'"
|
||||
MeshTextureFace.uv3 -> uv3: float "'NO DESCRIPTION'"
|
||||
MeshTextureFace.uv4 -> uv4: float "'NO DESCRIPTION'"
|
||||
MeshTextureFace.uv_pinned -> pin_uv: boolean "'NO DESCRIPTION'"
|
||||
MeshTextureFace.uv_raw -> uv_raw: float "'Fixed size UV coordinates array'"
|
||||
MeshTextureFaceLayer.active -> active: boolean "'Sets the layer as active for display and editing'"
|
||||
MeshTextureFaceLayer.active_clone -> active_clone: boolean "'Sets the layer as active for cloning'"
|
||||
MeshTextureFaceLayer.active_render -> active_render: boolean "'Sets the layer as active for rendering'"
|
||||
MeshTextureFaceLayer.data -> data: collection, "'(read-only)'"
|
||||
MeshTextureFaceLayer.name -> name: string "'NO DESCRIPTION'"
|
||||
MeshVertex.bevel_weight -> bevel_weight: float '"Weight used by the Bevel modifier \'Only Vertices\' option"'
|
||||
MeshVertex.co -> co: float "'NO DESCRIPTION'"
|
||||
MeshVertex.groups -> groups: collection, "'(read-only) Weights for the vertex groups this vertex is member of'"
|
||||
MeshVertex.hide -> hide: boolean "'NO DESCRIPTION'"
|
||||
MeshVertex.index -> index: int, "'(read-only) Index number of the vertex'"
|
||||
MeshVertex.normal -> normal: float "'Vertex Normal'"
|
||||
MeshVertex.select -> select: boolean "'NO DESCRIPTION'"
|
||||
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.auto_texspace -> use_auto_texspace: boolean '"Adjusts active object\'s texture space automatically when transforming object"'
|
||||
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.hide -> hide: boolean "'Hide element'"
|
||||
MetaElement.location -> location: float "'NO DESCRIPTION'"
|
||||
MetaElement.negative -> use_negative: boolean "'Set metaball as negative one'"
|
||||
MetaElement.radius -> radius: float "'NO DESCRIPTION'"
|
||||
MetaElement.rotation -> rotation: float "'NO DESCRIPTION'"
|
||||
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.color_saturation -> color_saturation: float "'NO DESCRIPTION'"
|
||||
MetaSequence.convert_float -> use_float: boolean "'Convert input to float data'"
|
||||
MetaSequence.crop -> crop: pointer, "'(read-only)'"
|
||||
MetaSequence.de_interlace -> use_deinterlace: boolean "'For video movies to remove fields'"
|
||||
MetaSequence.flip_x -> use_flip_x: boolean "'Flip on the X axis'"
|
||||
MetaSequence.flip_y -> use_flip_y: boolean "'Flip on the Y axis'"
|
||||
MetaSequence.multiply_colors -> multiply_colors: float "'NO DESCRIPTION'"
|
||||
MetaSequence.premultiply -> use_premultiply: boolean "'Convert RGB from key alpha to premultiplied alpha'"
|
||||
MetaSequence.proxy -> proxy: pointer, "'(read-only)'"
|
||||
MetaSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean "'Use a custom directory to store data'"
|
||||
MetaSequence.proxy_custom_file -> use_proxy_custom_file: boolean "'Use a custom file to read proxy data from'"
|
||||
MetaSequence.reverse_frames -> use_reverse_frames: boolean "'Reverse frame order'"
|
||||
MetaSequence.sequences -> sequences: collection, "'(read-only)'"
|
||||
MetaSequence.strobe -> strobe: float "'Only display every nth frame'"
|
||||
MetaSequence.transform -> transform: pointer, "'(read-only)'"
|
||||
MetaSequence.use_color_balance -> use_color_balance: boolean "'(3-Way color correction) on input'"
|
||||
MetaSequence.use_crop -> use_crop: boolean "'Crop image before processing'"
|
||||
MetaSequence.use_proxy -> use_proxy: boolean "'Use a preview proxy for this strip'"
|
||||
MetaSequence.use_translation -> use_translation: boolean "'Translate image before processing'"
|
||||
MirrorModifier.clip -> use_clip: boolean "'Prevents vertices from going through the mirror during transform'"
|
||||
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'"
|
||||
MirrorModifier.mirror_u -> use_mirror_u: boolean "'Mirror the U texture coordinate around the 0.5 point'"
|
||||
MirrorModifier.mirror_v -> use_mirror_v: boolean "'Mirror the V texture coordinate around the 0.5 point'"
|
||||
MirrorModifier.mirror_vertex_groups -> use_mirror_vertex_groups: boolean "'Mirror vertex groups (e.g. .R->.L)'"
|
||||
MirrorModifier.x -> use_x: boolean "'Enable X axis mirror'"
|
||||
MirrorModifier.y -> use_y: boolean "'Enable Y axis mirror'"
|
||||
MirrorModifier.z -> use_z: boolean "'Enable Z axis mirror'"
|
||||
Modifier.editmode -> show_in_editmode: boolean "'Use modifier while in the edit mode'"
|
||||
Modifier.expanded -> show_expanded: boolean "'Set modifier expanded in the user interface'"
|
||||
Modifier.name -> name: string "'Modifier name'"
|
||||
Modifier.on_cage -> show_on_cage: boolean "'Enable direct editing of modifier control cage'"
|
||||
Modifier.realtime -> show_realtime: boolean "'Realtime display of a modifier'"
|
||||
Modifier.render -> use_render: boolean "'Use modifier during rendering'"
|
||||
Modifier.type -> type: enum, "'(read-only)'"
|
||||
MotionPath.editing -> is_edited: boolean "'Path is being edited'"
|
||||
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'"
|
||||
MotionPath.use_bone_head -> use_bone_head: boolean, "'(read-only) For PoseBone paths, use the bone head location when calculating this path'"
|
||||
MotionPathVert.co -> co: float "'NO DESCRIPTION'"
|
||||
MotionPathVert.select -> select: boolean "'Path point is selected for editing'"
|
||||
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.color_saturation -> color_saturation: float "'NO DESCRIPTION'"
|
||||
MovieSequence.convert_float -> use_float: boolean "'Convert input to float data'"
|
||||
MovieSequence.crop -> crop: pointer, "'(read-only)'"
|
||||
MovieSequence.de_interlace -> use_deinterlace: boolean "'For video movies to remove fields'"
|
||||
MovieSequence.filepath -> filepath: string "'NO DESCRIPTION'"
|
||||
MovieSequence.flip_x -> use_flip_x: boolean "'Flip on the X axis'"
|
||||
MovieSequence.flip_y -> use_flip_y: boolean "'Flip on the Y axis'"
|
||||
MovieSequence.mpeg_preseek -> mpeg_preseek: int "'For MPEG movies, preseek this many frames'"
|
||||
MovieSequence.multiply_colors -> multiply_colors: float "'NO DESCRIPTION'"
|
||||
MovieSequence.premultiply -> use_premultiply: boolean "'Convert RGB from key alpha to premultiplied alpha'"
|
||||
MovieSequence.proxy -> proxy: pointer, "'(read-only)'"
|
||||
MovieSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean "'Use a custom directory to store data'"
|
||||
MovieSequence.proxy_custom_file -> use_proxy_custom_file: boolean "'Use a custom file to read proxy data from'"
|
||||
MovieSequence.reverse_frames -> use_reverse_frames: boolean "'Reverse frame order'"
|
||||
MovieSequence.strobe -> strobe: float "'Only display every nth frame'"
|
||||
MovieSequence.transform -> transform: pointer, "'(read-only)'"
|
||||
MovieSequence.use_color_balance -> use_color_balance: boolean "'(3-Way color correction) on input'"
|
||||
MovieSequence.use_crop -> use_crop: boolean "'Crop image before processing'"
|
||||
MovieSequence.use_proxy -> use_proxy: boolean "'Use a preview proxy for this strip'"
|
||||
MovieSequence.use_translation -> use_translation: boolean "'Translate image before processing'"
|
||||
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.color_saturation -> color_saturation: float "'NO DESCRIPTION'"
|
||||
MulticamSequence.convert_float -> use_float: boolean "'Convert input to float data'"
|
||||
MulticamSequence.crop -> crop: pointer, "'(read-only)'"
|
||||
MulticamSequence.de_interlace -> use_deinterlace: boolean "'For video movies to remove fields'"
|
||||
MulticamSequence.flip_x -> use_flip_x: boolean "'Flip on the X axis'"
|
||||
MulticamSequence.flip_y -> use_flip_y: boolean "'Flip on the Y axis'"
|
||||
MulticamSequence.multicam_source -> multicam_source: int "'NO DESCRIPTION'"
|
||||
MulticamSequence.multiply_colors -> multiply_colors: float "'NO DESCRIPTION'"
|
||||
MulticamSequence.premultiply -> use_premultiply: boolean "'Convert RGB from key alpha to premultiplied alpha'"
|
||||
MulticamSequence.proxy -> proxy: pointer, "'(read-only)'"
|
||||
MulticamSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean "'Use a custom directory to store data'"
|
||||
MulticamSequence.proxy_custom_file -> use_proxy_custom_file: boolean "'Use a custom file to read proxy data from'"
|
||||
MulticamSequence.reverse_frames -> use_reverse_frames: boolean "'Reverse frame order'"
|
||||
MulticamSequence.strobe -> strobe: float "'Only display every nth frame'"
|
||||
MulticamSequence.transform -> transform: pointer, "'(read-only)'"
|
||||
MulticamSequence.use_color_balance -> use_color_balance: boolean "'(3-Way color correction) on input'"
|
||||
MulticamSequence.use_crop -> use_crop: boolean "'Crop image before processing'"
|
||||
MulticamSequence.use_proxy -> use_proxy: boolean "'Use a preview proxy for this strip'"
|
||||
MulticamSequence.use_translation -> use_translation: boolean "'Translate image before processing'"
|
||||
MultiresModifier.external -> is_external: boolean, "'(read-only) Store multires displacements outside the .blend file, to save memory'"
|
||||
MultiresModifier.filepath -> filepath: string "'Path to external displacements file'"
|
||||
MultiresModifier.levels -> levels: int "'Number of subdivisions to use in the viewport'"
|
||||
MultiresModifier.optimal_display -> show_only_control_edges: boolean "'Skip drawing/rendering of interior subdivided edges'"
|
||||
MultiresModifier.render_levels -> render_levels: int "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
NetRenderJob.name -> name: string "'NO DESCRIPTION'"
|
||||
NetRenderSettings.active_blacklisted_slave_index -> active_blacklisted_slave_index: int "'NO DESCRIPTION'"
|
||||
NetRenderSettings.active_job_index -> active_job_index: int "'NO DESCRIPTION'"
|
||||
NetRenderSettings.active_slave_index -> active_slave_index: int "'NO DESCRIPTION'"
|
||||
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.master_broadcast -> use_master_broadcast: boolean "'broadcast master server address on local network'"
|
||||
NetRenderSettings.master_clear -> use_master_clear: boolean "'delete saved files on exit'"
|
||||
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.slave_clear -> use_slave_clear: boolean "'delete downloaded files on exit'"
|
||||
NetRenderSettings.slave_outputlog -> use_slave_output_log: boolean "'Output render text log to console as well as sending it to the master'"
|
||||
NetRenderSettings.slave_thumb -> use_slave_thumb: boolean "'Generate thumbnails on slaves instead of master'"
|
||||
NetRenderSettings.slaves -> slaves: collection, "'(read-only)'"
|
||||
NetRenderSettings.slaves_blacklist -> slaves_blacklist: collection, "'(read-only)'"
|
||||
NetRenderSlave.name -> name: string "'NO DESCRIPTION'"
|
||||
NlaStrip.action -> action: pointer "'Action referenced by this strip'"
|
||||
NlaStrip.action_frame_end -> action_frame_end: float "'NO DESCRIPTION'"
|
||||
NlaStrip.action_frame_start -> action_frame_start: float "'NO DESCRIPTION'"
|
||||
NlaStrip.active -> active: boolean, "'(read-only) NLA Strip is active'"
|
||||
NlaStrip.animated_influence -> use_animated_influence: boolean "'Influence setting is controlled by an F-Curve rather than automatically determined'"
|
||||
NlaStrip.animated_time -> use_animated_time: boolean "'Strip time is controlled by an F-Curve rather than automatically determined'"
|
||||
NlaStrip.animated_time_cyclic -> use_animated_time_cyclic: boolean "'Cycle the animated time within the action start & end'"
|
||||
NlaStrip.auto_blending -> use_auto_blend: boolean "'Number of frames for Blending In/Out is automatically determined from overlapping strips'"
|
||||
NlaStrip.blend_in -> blend_in: float "'Number of frames at start of strip to fade in influence'"
|
||||
NlaStrip.blend_out -> blend_out: float "'NO DESCRIPTION'"
|
||||
NlaStrip.blending -> blend_type: 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 "'NO DESCRIPTION'"
|
||||
NlaStrip.frame_start -> frame_start: float "'NO DESCRIPTION'"
|
||||
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.mute -> mute: boolean "'NLA Strip is not evaluated'"
|
||||
NlaStrip.name -> name: string "'NO DESCRIPTION'"
|
||||
NlaStrip.repeat -> repeat: float "'Number of times to repeat the action range'"
|
||||
NlaStrip.reversed -> use_reverse: boolean "'NLA Strip is played back in reverse order (only when timing is automatically determined)'"
|
||||
NlaStrip.scale -> scale: float "'Scaling factor for action'"
|
||||
NlaStrip.select -> select: boolean "'NLA Strip is selected'"
|
||||
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.active -> active: boolean, "'(read-only) NLA Track is active'"
|
||||
NlaTrack.lock -> lock: boolean "'NLA Track is locked'"
|
||||
NlaTrack.mute -> mute: boolean "'NLA Track is not evaluated'"
|
||||
NlaTrack.name -> name: string "'NO DESCRIPTION'"
|
||||
NlaTrack.select -> select: boolean "'NLA Track is selected'"
|
||||
NlaTrack.solo -> is_solo: boolean, "'(read-only) NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)'"
|
||||
NlaTrack.strips -> strips: collection, "'(read-only) NLA Strips on this NLA-track'"
|
||||
Node.inputs -> inputs: collection, "'(read-only)'"
|
||||
Node.location -> location: float "'NO DESCRIPTION'"
|
||||
Node.name -> name: string "'Node name'"
|
||||
Node.outputs -> outputs: collection, "'(read-only)'"
|
||||
NodeGroup.nodetree -> nodetree: pointer "'NO DESCRIPTION'"
|
||||
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_axis -> show_axis: boolean '"Displays the object\'s origin and axis"'
|
||||
Object.draw_bounds -> show_bounds: boolean '"Displays the object\'s bounds"'
|
||||
Object.draw_bounds_type -> draw_bounds_type: enum "'Object boundary display type'"
|
||||
Object.draw_name -> show_name: boolean '"Displays the object\'s name"'
|
||||
Object.draw_texture_space -> show_texture_space: boolean '"Displays the object\'s texture space"'
|
||||
Object.draw_transparent -> show_transparent: boolean "'Enables transparent materials for the object (Mesh only)'"
|
||||
Object.draw_wire -> show_wire: boolean '"Adds the object\'s wireframe over solid drawing"'
|
||||
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.duplis_used -> is_duplicator: boolean, "'(read-only)'"
|
||||
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.hide -> hide: boolean "'Restrict visibility in the viewport'"
|
||||
Object.hide_render -> hide_render: boolean "'Restrict renderability'"
|
||||
Object.hide_select -> hide_select: boolean "'Restrict selection in the viewport'"
|
||||
Object.layers -> layers: boolean "'Layers the object is on'"
|
||||
Object.location -> location: float "'Location of the object'"
|
||||
Object.lock_location -> lock_location: boolean "'Lock editing of location in the interface'"
|
||||
Object.lock_rotation -> lock_rotation: boolean "'Lock editing of rotation in the interface'"
|
||||
Object.lock_rotation_w -> lock_rotation_w: boolean '"Lock editing of \'angle\' component of four-component rotations in the interface"'
|
||||
Object.lock_rotations_4d -> lock_rotations_4d: boolean "'Lock editing of four component rotations by components (instead of as Eulers)'"
|
||||
Object.lock_scale -> lock_scale: boolean "'Lock editing of scale in the interface'"
|
||||
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 -> 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 "'NO DESCRIPTION'"
|
||||
Object.rotation_quaternion -> rotation_quaternion: float "'Rotation in Quaternions'"
|
||||
Object.scale -> scale: float "'Scaling of the object'"
|
||||
Object.select -> select: boolean "'Object selection state'"
|
||||
Object.shape_key_edit_mode -> use_shape_key_edit_mode: boolean "'Apply shape keys in edit mode (for Meshes only)'"
|
||||
Object.shape_key_lock -> show_shape_key: boolean "'Always show the current Shape for this Object'"
|
||||
Object.slow_parent -> use_slow_parent: boolean "'Create a delay in the parent relationship'"
|
||||
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.time_offset_add_parent -> use_time_offset_add_parent: boolean "'Add the parents time offset value'"
|
||||
Object.time_offset_edit -> use_time_offset_edit: boolean "'Use time offset when inserting keys and display time offset for F-Curve and action views'"
|
||||
Object.time_offset_parent -> use_time_offset_parent: boolean "'Apply the time offset to this objects parent relationship'"
|
||||
Object.time_offset_particle -> use_time_offset_particle: boolean "'Let the time offset work on the particle effect'"
|
||||
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.use_dupli_faces_scale -> use_dupli_faces_scale: boolean "'Scale dupli based on face size'"
|
||||
Object.use_dupli_frames_speed -> use_dupli_frames_speed: boolean "'Set dupliframes to use the frame'"
|
||||
Object.use_dupli_verts_rotation -> use_dupli_verts_rotation: boolean "'Rotate dupli according to vertex normal'"
|
||||
Object.vertex_groups -> vertex_groups: collection, "'(read-only) Vertex groups of the object'"
|
||||
Object.x_ray -> show_x_ray: boolean "'Makes the object draw in front of others'"
|
||||
ObjectActuator.add_linear_velocity -> use_add_linear_velocity: boolean "'Toggles between ADD and SET linV'"
|
||||
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.local_angular_velocity -> use_local_angular_velocity: boolean "'Angular velocity is defined in local coordinates'"
|
||||
ObjectActuator.local_force -> use_local_force: boolean "'Force is defined in local coordinates'"
|
||||
ObjectActuator.local_linear_velocity -> use_local_linear_velocity: boolean "'Velocity is defined in local coordinates'"
|
||||
ObjectActuator.local_location -> use_local_location: boolean "'Location is defined in local coordinates'"
|
||||
ObjectActuator.local_rotation -> use_local_rotation: boolean "'Rotation is defined in local coordinates'"
|
||||
ObjectActuator.local_torque -> use_local_torque: boolean "'Torque is defined in local coordinates'"
|
||||
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.servo_limit_x -> use_servo_limit_x: boolean "'Set limit to force along the X axis'"
|
||||
ObjectActuator.servo_limit_y -> use_servo_limit_y: boolean "'Set limit to force along the Y axis'"
|
||||
ObjectActuator.servo_limit_z -> use_servo_limit_z: boolean "'Set limit to force along the Z axis'"
|
||||
ObjectActuator.torque -> torque: float "'Sets the torque'"
|
||||
ObjectBase.layers -> layers: boolean "'Layers the object base is on'"
|
||||
ObjectBase.object -> object: pointer, "'(read-only) Object this base links to'"
|
||||
ObjectBase.select -> select: boolean "'Object base selection state'"
|
||||
ObjectConstraints.active -> active: pointer "'Active Object constraint'"
|
||||
ObstacleFluidSettings.active -> use: boolean "'Object contributes to the fluid simulation'"
|
||||
ObstacleFluidSettings.export_animated_mesh -> use_animated_mesh: boolean "'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
ObstacleFluidSettings.volume_initialization -> volume_initialization: enum "'Volume initialization type'"
|
||||
Operator.bl_description -> bl_description: string "'NO DESCRIPTION'"
|
||||
Operator.bl_idname -> bl_idname: string "'NO DESCRIPTION'"
|
||||
Operator.bl_label -> bl_label: string "'NO DESCRIPTION'"
|
||||
Operator.bl_options -> bl_options: enum "'Options for this operator type'"
|
||||
Operator.has_reports -> has_reports: boolean, "'(read-only) Operator has a set of reports (warnings and errors) from last execution'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
OperatorStrokeElement.mouse -> mouse: float "'NO DESCRIPTION'"
|
||||
OperatorStrokeElement.pen_flip -> pen_flip: boolean "'NO DESCRIPTION'"
|
||||
OperatorStrokeElement.pressure -> pressure: float "'Tablet pressure'"
|
||||
OperatorStrokeElement.time -> time: float "'NO DESCRIPTION'"
|
||||
OperatorTypeMacro.properties -> properties: pointer, "'(read-only)'"
|
||||
OutflowFluidSettings.active -> use: boolean "'Object contributes to the fluid simulation'"
|
||||
OutflowFluidSettings.export_animated_mesh -> use_animated_mesh: boolean "'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'"
|
||||
OutflowFluidSettings.volume_initialization -> volume_initialization: enum "'Volume initialization type'"
|
||||
PackedFile.size -> size: int, "'(read-only) Size of packed file in bytes'"
|
||||
Paint.brush -> brush: pointer "'Active paint brush'"
|
||||
Paint.fast_navigate -> show_low_resolution: boolean "'For multires, show low resolution while navigating the view'"
|
||||
Paint.show_brush -> show_brush: boolean "'NO DESCRIPTION'"
|
||||
Paint.show_brush_on_surface -> show_brush_on_surface: boolean "'NO DESCRIPTION'"
|
||||
Panel.bl_context -> bl_context: string "'NO DESCRIPTION'"
|
||||
Panel.bl_default_closed -> bl_use_closed: boolean "'NO DESCRIPTION'"
|
||||
Panel.bl_idname -> bl_idname: string "'NO DESCRIPTION'"
|
||||
Panel.bl_label -> bl_label: string "'NO DESCRIPTION'"
|
||||
Panel.bl_region_type -> bl_region_type: enum "'NO DESCRIPTION'"
|
||||
Panel.bl_show_header -> bl_show_header: boolean "'NO DESCRIPTION'"
|
||||
Panel.bl_space_type -> bl_space_type: enum "'NO DESCRIPTION'"
|
||||
Panel.layout -> layout: pointer, "'(read-only)'"
|
||||
Panel.text -> text: string "'NO DESCRIPTION'"
|
||||
ParentActuator.compound -> use_compound: boolean "'Add this object shape to the parent shape (only if the parent shape is already compound)'"
|
||||
ParentActuator.ghost -> use_ghost: boolean "'Make this object ghost while parented (only if not compound)'"
|
||||
ParentActuator.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
ParentActuator.object -> object: pointer "'Set this object as parent'"
|
||||
Particle.alive_state -> alive_state: enum "'NO DESCRIPTION'"
|
||||
Particle.angular_velocity -> angular_velocity: float "'NO DESCRIPTION'"
|
||||
Particle.birthtime -> birthtime: float "'NO DESCRIPTION'"
|
||||
Particle.die_time -> die_time: float "'NO DESCRIPTION'"
|
||||
Particle.hair -> hair: collection, "'(read-only)'"
|
||||
Particle.is_existing -> is_existing: boolean, "'(read-only)'"
|
||||
Particle.is_visible -> is_visible: boolean, "'(read-only)'"
|
||||
Particle.keys -> keys: collection, "'(read-only)'"
|
||||
Particle.lifetime -> lifetime: float "'NO DESCRIPTION'"
|
||||
Particle.location -> location: float "'NO DESCRIPTION'"
|
||||
Particle.prev_angular_velocity -> prev_angular_velocity: float "'NO DESCRIPTION'"
|
||||
Particle.prev_location -> prev_location: float "'NO DESCRIPTION'"
|
||||
Particle.prev_rotation -> prev_rotation: float "'NO DESCRIPTION'"
|
||||
Particle.prev_velocity -> prev_velocity: float "'NO DESCRIPTION'"
|
||||
Particle.rotation -> rotation: float "'NO DESCRIPTION'"
|
||||
Particle.size -> size: float "'NO DESCRIPTION'"
|
||||
Particle.velocity -> velocity: float "'NO DESCRIPTION'"
|
||||
ParticleBrush.count -> count: int "'Particle count'"
|
||||
ParticleBrush.curve -> curve: pointer, "'(read-only)'"
|
||||
ParticleBrush.length_mode -> length_mode: enum "'NO DESCRIPTION'"
|
||||
ParticleBrush.puff_mode -> puff_mode: enum "'NO DESCRIPTION'"
|
||||
ParticleBrush.size -> size: int "'Brush size'"
|
||||
ParticleBrush.steps -> steps: int "'Brush steps'"
|
||||
ParticleBrush.strength -> strength: float "'Brush strength'"
|
||||
ParticleBrush.use_puff_volume -> use_puff_volume: boolean "'Apply puff to unselected end-points, (helps maintain hair volume when puffing root)'"
|
||||
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_interpolate -> use_add_interpolate: boolean "'Interpolate new particles from the existing ones'"
|
||||
ParticleEdit.add_keys -> add_keys: int "'How many keys to make new particles with'"
|
||||
ParticleEdit.auto_velocity -> use_auto_velocity: boolean "'Calculate point velocities automatically'"
|
||||
ParticleEdit.brush -> brush: pointer, "'(read-only)'"
|
||||
ParticleEdit.draw_particles -> show_particles: boolean "'Draw actual particles'"
|
||||
ParticleEdit.draw_step -> draw_step: int "'How many steps to draw the path with'"
|
||||
ParticleEdit.editable -> is_editable: boolean, "'(read-only) A valid edit mode exists'"
|
||||
ParticleEdit.emitter_deflect -> use_emitter_deflect: boolean "'Keep paths from intersecting the emitter'"
|
||||
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.fade_time -> use_fade_time: boolean "'Fade paths and keys further away from current frame'"
|
||||
ParticleEdit.hair -> is_hair: boolean, "'(read-only) Editing hair'"
|
||||
ParticleEdit.keep_lengths -> use_preserve_lengths: boolean "'Keep path lengths constant'"
|
||||
ParticleEdit.keep_root -> use_preserve_root: boolean "'Keep root keys unmodified'"
|
||||
ParticleEdit.object -> object: pointer, "'(read-only) The edited object'"
|
||||
ParticleEdit.selection_mode -> selection_mode: enum "'Particle select and display mode'"
|
||||
ParticleEdit.tool -> tool: enum "'NO DESCRIPTION'"
|
||||
ParticleEdit.type -> type: enum "'NO DESCRIPTION'"
|
||||
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.drops -> use_drops: boolean "'Show drop particles'"
|
||||
ParticleFluidSettings.floats -> use_floats: boolean "'Show floating foam particles'"
|
||||
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'"
|
||||
ParticleFluidSettings.tracer -> use_tracer: boolean "'Show tracer particles'"
|
||||
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.alive -> use_alive: boolean "'Show instances when particles are alive'"
|
||||
ParticleInstanceModifier.axis -> axis: enum "'Pole axis for rotation'"
|
||||
ParticleInstanceModifier.children -> use_children: boolean "'Create instances from child particles'"
|
||||
ParticleInstanceModifier.dead -> use_dead: boolean "'Show instances when particles are dead'"
|
||||
ParticleInstanceModifier.keep_shape -> use_preserve_shape: boolean '"Don\'t stretch the object"'
|
||||
ParticleInstanceModifier.normal -> use_normal: boolean "'Create instances from normal particles'"
|
||||
ParticleInstanceModifier.object -> object: pointer "'Object that has the particle system'"
|
||||
ParticleInstanceModifier.particle_system_number -> particle_system_number: int "'NO DESCRIPTION'"
|
||||
ParticleInstanceModifier.position -> position: float "'Position along path'"
|
||||
ParticleInstanceModifier.random_position -> random_position: float "'Randomize position along path'"
|
||||
ParticleInstanceModifier.size -> use_size: boolean "'Use particle size to scale the instances'"
|
||||
ParticleInstanceModifier.unborn -> use_unborn: boolean "'Show instances when particles are unborn'"
|
||||
ParticleInstanceModifier.use_path -> use_path: boolean "'Create instances along particle paths'"
|
||||
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.abs_path_time -> use_absolute_path_time: boolean "'Path timing is in absolute frames'"
|
||||
ParticleSettings.active_dupliweight -> active_dupliweight: pointer, "'(read-only)'"
|
||||
ParticleSettings.active_dupliweight_index -> active_dupliweight_index: int "'NO DESCRIPTION'"
|
||||
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.animate_branching -> use_animate_branching: boolean "'Animate branching'"
|
||||
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_lock -> lock_billboard: boolean "'Lock the billboards align axis'"
|
||||
ParticleSettings.billboard_object -> billboard_object: pointer "'Billboards face this object (default is active camera)'"
|
||||
ParticleSettings.billboard_offset -> billboard_offset: float "'NO DESCRIPTION'"
|
||||
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.boids_2d -> lock_boids_to_surface: boolean "'Constrain boids to a surface'"
|
||||
ParticleSettings.branch_threshold -> branch_threshold: float "'Threshold of branching'"
|
||||
ParticleSettings.branching -> use_branching: boolean "'Branch child paths from each other'"
|
||||
ParticleSettings.brownian_factor -> brownian_factor: float "'Specify the amount of Brownian motion'"
|
||||
ParticleSettings.child_effector -> apply_effector_to_children: boolean "'Apply effectors to children'"
|
||||
ParticleSettings.child_guide -> apply_guide_to_children: boolean "'NO DESCRIPTION'"
|
||||
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.die_on_collision -> use_die_on_collision: boolean "'Particles die when they collide with a deflector object'"
|
||||
ParticleSettings.died -> use_died: boolean "'Show particles after they have died'"
|
||||
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_health -> show_health: boolean "'Draw boid health'"
|
||||
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.emitter -> use_render_emitter: boolean "'Render emitter Object also'"
|
||||
ParticleSettings.enable_simplify -> use_simplify: boolean "'Remove child strands as the object becomes smaller on the screen'"
|
||||
ParticleSettings.even_distribution -> use_even_distribution: boolean "'Use even distribution from faces based on face areas or edge lengths'"
|
||||
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_invert -> invert_grid: boolean "'Invert what is considered object and what is not'"
|
||||
ParticleSettings.grid_resolution -> grid_resolution: int "'The resolution of the particle grid'"
|
||||
ParticleSettings.hair_bspline -> use_hair_bspline: boolean "'Interpolate hair using B-Splines'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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.material_color -> show_material_color: boolean '"Draw particles using material\'s diffuse color"'
|
||||
ParticleSettings.normal_factor -> normal_factor: float "'Let the surface normal give the particle a starting speed'"
|
||||
ParticleSettings.num -> show_number: boolean "'Show particle number'"
|
||||
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.parent -> use_parents: boolean "'Render parent particles'"
|
||||
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.rand_group -> use_group_pick_random: boolean "'Pick objects from group randomly'"
|
||||
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.react_multiple -> use_react_multiple: boolean "'React multiple times'"
|
||||
ParticleSettings.react_start_end -> use_react_start_end: boolean "'Give birth to unreacted particles eventually'"
|
||||
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_adaptive -> use_render_adaptive: boolean "'Use adapative rendering for paths'"
|
||||
ParticleSettings.render_step -> render_step: int "'How many steps paths are rendered with (power of 2)'"
|
||||
ParticleSettings.render_strand -> use_strand_primitive: boolean "'Use the strand primitive for rendering'"
|
||||
ParticleSettings.rendered_child_nbr -> rendered_child_nbr: int "'Amount of children/parent for rendering'"
|
||||
ParticleSettings.rotate_from -> rotate_from: enum "'NO DESCRIPTION'"
|
||||
ParticleSettings.rotation_dynamic -> use_dynamic_rotation: boolean "'Sets rotation to dynamic/constant'"
|
||||
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.self_effect -> use_self_effect: boolean "'Particle effectors effect themselves'"
|
||||
ParticleSettings.show_size -> show_size: boolean "'Show particle size'"
|
||||
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.size_deflect -> use_size_deflect: boolean '"Use particle\'s size in deflection"'
|
||||
ParticleSettings.sizemass -> use_multiply_size_mass: boolean "'Multiply mass by particle size'"
|
||||
ParticleSettings.subframes -> subframes: int "'Subframes to simulate for improved stability and finer granularity simulations'"
|
||||
ParticleSettings.symmetric_branching -> use_symmetric_branching: boolean "'Start and end points are the same'"
|
||||
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.trand -> use_emit_random: boolean "'Emit in random order of elements'"
|
||||
ParticleSettings.type -> type: enum "'NO DESCRIPTION'"
|
||||
ParticleSettings.unborn -> use_unborn: boolean "'Show particles before they are emitted'"
|
||||
ParticleSettings.use_global_dupli -> use_global_dupli: boolean '"Use object\'s global coordinates for duplication"'
|
||||
ParticleSettings.use_group_count -> use_group_count: boolean "'Use object multiple times in the same group'"
|
||||
ParticleSettings.userjit -> userjit: int "'Emission locations / face (0 = automatic)'"
|
||||
ParticleSettings.velocity -> show_velocity: boolean "'Show particle velocity'"
|
||||
ParticleSettings.velocity_length -> use_velocity_length: boolean "'Multiply line length by particle speed'"
|
||||
ParticleSettings.viewport -> use_simplify_viewport: boolean "'NO DESCRIPTION'"
|
||||
ParticleSettings.virtual_parents -> virtual_parents: float "'Relative amount of virtual parents'"
|
||||
ParticleSettings.whole_group -> use_whole_group: boolean "'Use whole group at once'"
|
||||
ParticleSystem.active_particle_target -> active_particle_target: pointer, "'(read-only)'"
|
||||
ParticleSystem.active_particle_target_index -> active_particle_target_index: int "'NO DESCRIPTION'"
|
||||
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.editable -> is_editable: boolean, "'(read-only) Particle system can be edited in particle mode'"
|
||||
ParticleSystem.edited -> is_edited: boolean, "'(read-only) Particle system has been edited in particle mode'"
|
||||
ParticleSystem.global_hair -> is_global_hair: boolean, "'(read-only) Hair keys are in global coordinate space'"
|
||||
ParticleSystem.hair_dynamics -> use_hair_dynamics: boolean "'Enable hair dynamics using cloth simulation'"
|
||||
ParticleSystem.keyed_timing -> use_keyed_timing: boolean "'Use key times'"
|
||||
ParticleSystem.multiple_caches -> has_multiple_caches: boolean, "'(read-only) Particle system has multiple point caches'"
|
||||
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_clump_negate -> invert_vertex_group_clump: boolean "'Negate the effect of the clump vertex group'"
|
||||
ParticleSystem.vertex_group_density -> vertex_group_density: string "'Vertex group to control density'"
|
||||
ParticleSystem.vertex_group_density_negate -> invert_vertex_group_density: boolean "'Negate the effect of the density vertex group'"
|
||||
ParticleSystem.vertex_group_field -> vertex_group_field: string "'Vertex group to control field'"
|
||||
ParticleSystem.vertex_group_field_negate -> invert_vertex_group_field: boolean "'Negate the effect of the field vertex group'"
|
||||
ParticleSystem.vertex_group_kink -> vertex_group_kink: string "'Vertex group to control kink'"
|
||||
ParticleSystem.vertex_group_kink_negate -> invert_vertex_group_kink: boolean "'Negate the effect of the kink vertex group'"
|
||||
ParticleSystem.vertex_group_length -> vertex_group_length: string "'Vertex group to control length'"
|
||||
ParticleSystem.vertex_group_length_negate -> invert_vertex_group_length: boolean "'Negate the effect of the length vertex group'"
|
||||
ParticleSystem.vertex_group_rotation -> vertex_group_rotation: string "'Vertex group to control rotation'"
|
||||
ParticleSystem.vertex_group_rotation_negate -> invert_vertex_group_rotation: boolean "'Negate the effect of the rotation vertex group'"
|
||||
ParticleSystem.vertex_group_roughness1 -> vertex_group_rough1: string "'Vertex group to control roughness 1'"
|
||||
ParticleSystem.vertex_group_roughness1_negate -> invert_vertex_group_roughness1: boolean "'Negate the effect of the roughness 1 vertex group'"
|
||||
ParticleSystem.vertex_group_roughness2 -> vertex_group_rough2: string "'Vertex group to control roughness 2'"
|
||||
ParticleSystem.vertex_group_roughness2_negate -> invert_vertex_group_roughness2: boolean "'Negate the effect of the roughness 2 vertex group'"
|
||||
ParticleSystem.vertex_group_roughness_end -> vertex_group_rough_end: string "'Vertex group to control roughness end'"
|
||||
ParticleSystem.vertex_group_roughness_end_negate -> invert_vertex_group_roughness_end: boolean "'Negate the effect of the roughness end vertex group'"
|
||||
ParticleSystem.vertex_group_size -> vertex_group_size: string "'Vertex group to control size'"
|
||||
ParticleSystem.vertex_group_size_negate -> invert_vertex_group_size: boolean "'Negate the effect of the size vertex group'"
|
||||
ParticleSystem.vertex_group_tangent -> vertex_group_tangent: string "'Vertex group to control tangent'"
|
||||
ParticleSystem.vertex_group_tangent_negate -> invert_vertex_group_tangent: boolean "'Negate the effect of the tangent vertex group'"
|
||||
ParticleSystem.vertex_group_velocity -> vertex_group_velocity: string "'Vertex group to control velocity'"
|
||||
ParticleSystem.vertex_group_velocity_negate -> invert_vertex_group_velocity: boolean "'Negate the effect of the velocity vertex group'"
|
||||
ParticleSystemModifier.particle_system -> particle_system: pointer, "'(read-only) Particle System that this modifier controls'"
|
||||
ParticleTarget.duration -> duration: float "'NO DESCRIPTION'"
|
||||
ParticleTarget.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
ParticleTarget.valid -> is_valid: boolean "'Keyed particles target is valid'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
PivotConstraint.target -> target: pointer "'Target Object, defining the position of the pivot when defined'"
|
||||
PivotConstraint.use_relative_position -> use_relative_location: boolean "'Offset will be an absolute point in space instead of relative to the target'"
|
||||
PluginSequence.filename -> filename: string, "'(read-only)'"
|
||||
PointCache.active_point_cache_index -> active_point_cache_index: int "'NO DESCRIPTION'"
|
||||
PointCache.baked -> is_baked: boolean, "'(read-only)'"
|
||||
PointCache.baking -> is_baking: boolean, "'(read-only)'"
|
||||
PointCache.disk_cache -> use_disk_cache: boolean "'Save cache files to disk (.blend file must be saved first)'"
|
||||
PointCache.external -> use_external: boolean "'Read cache from an external location'"
|
||||
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.frames_skipped -> frames_skipped: boolean, "'(read-only)'"
|
||||
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.outdated -> is_outdated: boolean, "'(read-only)'"
|
||||
PointCache.point_cache_list -> point_cache_list: collection, "'(read-only) Point cache list'"
|
||||
PointCache.quick_cache -> use_quick_cache: boolean "'Update simulation with cache steps'"
|
||||
PointCache.step -> step: int "'Number of frames between cached frames'"
|
||||
PointCache.use_library_path -> use_library_path: boolean "'Use this files path when library linked into another file.'"
|
||||
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_soft: 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 -> use_turbulence: boolean "'Add directed noise to the density at render-time'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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.only_shadow -> use_only_shadow: boolean "'Causes light to cast shadows only without illuminating objects'"
|
||||
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_layer -> use_shadow_layer: boolean "'Causes only objects on the same layer to cast shadows'"
|
||||
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_sample_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)'"
|
||||
PointLamp.sphere -> use_sphere: boolean "'Sets light intensity to zero beyond lamp distance'"
|
||||
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.has_ik -> is_in_ik_chain: boolean, "'(read-only) Is part of an IK chain'"
|
||||
PoseBone.head -> head: float, '"(read-only) Location of head of the channel\'s bone"'
|
||||
NEGATE * PoseBone.ik_dof_x -> lock_ik_x: boolean "'Allow movement around the X axis'"
|
||||
NEGATE * PoseBone.ik_dof_y -> lock_ik_y: boolean "'Allow movement around the Y axis'"
|
||||
NEGATE * PoseBone.ik_dof_z -> lock_ik_z: boolean "'Allow movement around the Z axis'"
|
||||
PoseBone.ik_limit_x -> lock_ik_x: boolean "'Limit movement around the X axis'"
|
||||
PoseBone.ik_limit_y -> lock_ik_y: boolean "'Limit movement around the Y axis'"
|
||||
PoseBone.ik_limit_z -> lock_ik_z: boolean "'Limit movement around the Z axis'"
|
||||
PoseBone.ik_lin_control -> use_ik_lin_control: boolean "'Apply channel size as IK constraint if stretching is enabled'"
|
||||
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_control -> use_ik_rot_control: boolean "'Apply channel rotation as IK constraint'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
PoseBone.lock_location -> lock_location: boolean "'Lock editing of location in the interface'"
|
||||
PoseBone.lock_rotation -> lock_rotation: boolean "'Lock editing of rotation in the interface'"
|
||||
PoseBone.lock_rotation_w -> lock_rotation_w: boolean '"Lock editing of \'angle\' component of four-component rotations in the interface"'
|
||||
PoseBone.lock_rotations_4d -> lock_rotations_4d: boolean "'Lock editing of four component rotations by components (instead of as Eulers)'"
|
||||
PoseBone.lock_scale -> lock_scale: boolean "'Lock editing of scale in the interface'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
PoseBone.rotation_quaternion -> rotation_quaternion: float "'Rotation in Quaternions'"
|
||||
PoseBone.scale -> scale: float "'NO DESCRIPTION'"
|
||||
PoseBone.select -> select: boolean "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
PoseTemplateSettings.active_template_index -> active_template_index: int "'NO DESCRIPTION'"
|
||||
PoseTemplateSettings.generate_def_rig -> use_generate_deform_rig: boolean "'Create a copy of the metarig, constrainted by the generated rig'"
|
||||
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.is_never_none -> is_never_none: boolean, '"(read-only) True when this value can\'t be set to None"'
|
||||
Property.is_readonly -> is_readonly: boolean, "'(read-only) Property is editable through RNA'"
|
||||
Property.is_required -> is_required: boolean, "'(read-only) False when this property is an optional argument in an RNA function'"
|
||||
Property.name -> name: string, "'(read-only) Human readable name'"
|
||||
Property.registered -> is_registered: boolean, "'(read-only) Property is registered as part of type registration'"
|
||||
Property.registered_optional -> is_registered_optional: boolean, "'(read-only) Property is optionally registered as part of type registration'"
|
||||
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'"
|
||||
Property.use_output -> is_output: boolean, "'(read-only) True when this property is an output value from an RNA function'"
|
||||
PropertyActuator.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
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 -> value_max: string "'Specify maximum value in Interval type'"
|
||||
PropertySensor.min_value -> value_min: string "'Specify minimum value in Interval type'"
|
||||
PropertySensor.property -> property: string "'NO DESCRIPTION'"
|
||||
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.script_error -> has_script_error: boolean, "'(read-only) The linked Python script has thrown an error'"
|
||||
PythonConstraint.targets -> targets: collection, "'(read-only) Target Objects'"
|
||||
PythonConstraint.text -> text: pointer "'The text object that contains the Python script'"
|
||||
PythonConstraint.use_targets -> use_targets: boolean "'Use the targets indicated in the constraint panel'"
|
||||
PythonController.debug -> use_debug: boolean "'Continuously reload the module from disk for editing external modules without restarting'"
|
||||
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.always_true -> use_always_true: boolean "'Always false or always true'"
|
||||
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'"
|
||||
RaySensor.x_ray_mode -> use_x_ray: boolean '"See through objects that don\'t have the 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.box_clip -> use_box_clip: boolean '"Clip objects based on what\'s visible in other side views"'
|
||||
RegionView3D.box_preview -> show_synced_view: boolean "'Sync view position between side views'"
|
||||
RegionView3D.lock_rotation -> lock_rotation: boolean "'Lock view rotation in side views'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
RenderEngine.bl_label -> bl_label: string "'NO DESCRIPTION'"
|
||||
RenderEngine.bl_postprocess -> bl_use_postprocess: boolean "'NO DESCRIPTION'"
|
||||
RenderEngine.bl_preview -> bl_use_preview: boolean "'NO DESCRIPTION'"
|
||||
RenderLayer.all_z -> use_all_z: boolean, "'(read-only) Fill in Z values for solid faces in invisible layers, for masking'"
|
||||
RenderLayer.edge -> use_edge_enhance: boolean, "'(read-only) Render Edge-enhance in this Layer (only works for Solid faces)'"
|
||||
RenderLayer.enabled -> use: boolean, "'(read-only) Disable or enable the render layer'"
|
||||
RenderLayer.halo -> use_halo: boolean, "'(read-only) Render Halos in this Layer (on top of Solid)'"
|
||||
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.pass_ao -> use_pass_ambient_occlusion: boolean, "'(read-only) Deliver AO pass'"
|
||||
RenderLayer.pass_ao_exclude -> exclude_ambient_occlusion: boolean, "'(read-only) Exclude AO pass from combined'"
|
||||
RenderLayer.pass_color -> use_pass_color: boolean, "'(read-only) Deliver shade-less color pass'"
|
||||
RenderLayer.pass_combined -> use_pass_combined: boolean, "'(read-only) Deliver full combined RGBA buffer'"
|
||||
RenderLayer.pass_diffuse -> use_pass_diffuse: boolean, "'(read-only) Deliver diffuse pass'"
|
||||
RenderLayer.pass_emit -> use_pass_emit: boolean, "'(read-only) Deliver emission pass'"
|
||||
RenderLayer.pass_emit_exclude -> exclude_emit: boolean, "'(read-only) Exclude emission pass from combined'"
|
||||
RenderLayer.pass_environment -> use_pass_environment: boolean, "'(read-only) Deliver environment lighting pass'"
|
||||
RenderLayer.pass_environment_exclude -> exclude_environment: boolean, "'(read-only) Exclude environment pass from combined'"
|
||||
RenderLayer.pass_indirect -> use_pass_indirect: boolean, "'(read-only) Deliver indirect lighting pass'"
|
||||
RenderLayer.pass_indirect_exclude -> exclude_indirect: boolean, "'(read-only) Exclude indirect pass from combined'"
|
||||
RenderLayer.pass_mist -> use_pass_mist: boolean, "'(read-only) Deliver mist factor pass (0.0-1.0)'"
|
||||
RenderLayer.pass_normal -> use_pass_normal: boolean, "'(read-only) Deliver normal pass'"
|
||||
RenderLayer.pass_object_index -> use_pass_object_index: boolean, "'(read-only) Deliver object index pass'"
|
||||
RenderLayer.pass_reflection -> use_pass_reflection: boolean, "'(read-only) Deliver raytraced reflection pass'"
|
||||
RenderLayer.pass_reflection_exclude -> exclude_reflection: boolean, "'(read-only) Exclude raytraced reflection pass from combined'"
|
||||
RenderLayer.pass_refraction -> use_pass_refraction: boolean, "'(read-only) Deliver raytraced refraction pass'"
|
||||
RenderLayer.pass_refraction_exclude -> exclude_refraction: boolean, "'(read-only) Exclude raytraced refraction pass from combined'"
|
||||
RenderLayer.pass_shadow -> use_pass_shadow: boolean, "'(read-only) Deliver shadow pass'"
|
||||
RenderLayer.pass_shadow_exclude -> exclude_shadow: boolean, "'(read-only) Exclude shadow pass from combined'"
|
||||
RenderLayer.pass_specular -> use_pass_specular: boolean, "'(read-only) Deliver specular pass'"
|
||||
RenderLayer.pass_specular_exclude -> exclude_specular: boolean, "'(read-only) Exclude specular pass from combined'"
|
||||
RenderLayer.pass_uv -> use_pass_uv: boolean, "'(read-only) Deliver texture UV pass'"
|
||||
RenderLayer.pass_vector -> use_pass_vector: boolean, "'(read-only) Deliver speed vector pass'"
|
||||
RenderLayer.pass_z -> use_pass_z: boolean, "'(read-only) Deliver Z values pass'"
|
||||
RenderLayer.passes -> passes: collection, "'(read-only)'"
|
||||
RenderLayer.rect -> rect: float "'NO DESCRIPTION'"
|
||||
RenderLayer.sky -> use_sky: boolean, "'(read-only) Render Sky in this Layer'"
|
||||
RenderLayer.solid -> use_solid: boolean, "'(read-only) Render Solid faces in this Layer'"
|
||||
RenderLayer.strand -> use_strand: boolean, "'(read-only) Render Strands in this Layer'"
|
||||
RenderLayer.visible_layers -> layers: boolean, "'(read-only) Scene layers included in this render layer'"
|
||||
RenderLayer.zmask -> use_zmask: boolean, '"(read-only) Only render what\'s in front of the solid z values"'
|
||||
RenderLayer.zmask_layers -> layers_zmask: boolean, "'(read-only) Zmask scene layers'"
|
||||
RenderLayer.zmask_negate -> invert_zmask: boolean, "'(read-only) For Zmask, only render what is behind solid z values instead of in front'"
|
||||
RenderLayer.ztransp -> use_ztransp: boolean, "'(read-only) Render Z-Transparent faces in this Layer (On top of Solid and Halos)'"
|
||||
RenderPass.channel_id -> channel_id: string, "'(read-only)'"
|
||||
RenderPass.channels -> channels: int, "'(read-only)'"
|
||||
RenderPass.name -> name: string, "'(read-only)'"
|
||||
RenderPass.rect -> rect: float "'NO DESCRIPTION'"
|
||||
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.backbuf -> use_backbuf: boolean "'Render backbuffer image'"
|
||||
RenderSettings.bake_aa_mode -> bake_aa_mode: enum "'NO DESCRIPTION'"
|
||||
RenderSettings.bake_active -> use_bake_active_to_selected: boolean "'Bake shading on the surface of selected objects to the active object'"
|
||||
RenderSettings.bake_bias -> bake_bias: float "'Bias towards faces further away from the object (in blender units)'"
|
||||
RenderSettings.bake_clear -> use_bake_clear: boolean "'Clear Images before baking'"
|
||||
RenderSettings.bake_distance -> bake_distance: float "'Maximum distance from active object to other object (in blender units'"
|
||||
RenderSettings.bake_enable_aa -> use_bake_antialiasing: boolean "'Enables Anti-aliasing'"
|
||||
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_normalized -> use_bake_normalized: boolean "'With displacement normalize to the distance, with ambient occlusion normalize without using material settings'"
|
||||
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_log -> use_cineon_log: boolean "'Convert to logarithmic color space'"
|
||||
RenderSettings.cineon_white -> cineon_white: int "'Log conversion reference whitepoint'"
|
||||
RenderSettings.color_management -> use_color_management: boolean "'Use color profiles and gamma corrected imaging pipeline'"
|
||||
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.crop_to_border -> use_crop_to_border: boolean "'Crop the rendered frame to the defined border size'"
|
||||
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 -> use_edge_enhance: boolean "'use_Create a toon outline around the edges of geometry'"
|
||||
RenderSettings.edge_color -> edge_color: float "'NO DESCRIPTION'"
|
||||
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.fields -> use_fields: boolean "'Render image to two fields per frame, for interlaced TV output'"
|
||||
RenderSettings.fields_still -> use_fields_still: boolean "'Disable the time difference between fields'"
|
||||
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.free_image_textures -> use_free_image_textures: boolean "'Free all image texture from memory after render, to save memory before compositing'"
|
||||
RenderSettings.free_unused_nodes -> use_free_unused_nodes: boolean "'Free Nodes that are not used while compositing, to save memory'"
|
||||
RenderSettings.full_sample -> use_full_sample: boolean "'Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing'"
|
||||
RenderSettings.is_movie_format -> is_movie_format: boolean, "'(read-only) When true the format is a movie'"
|
||||
RenderSettings.layers -> layers: collection, "'(read-only)'"
|
||||
RenderSettings.motion_blur -> use_motion_blur: boolean "'Use multi-sampled 3D scene motion blur'"
|
||||
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.multiple_engines -> has_multiple_engines: boolean, "'(read-only) More than one rendering engine is available'"
|
||||
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.render_antialiasing -> use_antialiasing: boolean "'Render and combine multiple samples per pixel to prevent jagged edges'"
|
||||
RenderSettings.render_stamp -> use_stamp: boolean "'Render the stamp info text in the rendered image'"
|
||||
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.save_buffers -> use_save_buffers: boolean "'Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample)'"
|
||||
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.simplify_triangulate -> use_simplify_triangulate: boolean "'Disables non-planer quads being triangulated'"
|
||||
RenderSettings.single_layer -> use_single_layer: boolean "'Only render the active layer'"
|
||||
RenderSettings.stamp_background -> stamp_background: float "'Color to use behind stamp text'"
|
||||
RenderSettings.stamp_camera -> use_stamp_camera: boolean "'Include the name of the active camera in image metadata'"
|
||||
RenderSettings.stamp_date -> use_stamp_date: boolean "'Include the current date in image metadata'"
|
||||
RenderSettings.stamp_filename -> use_stamp_filename: boolean "'Include the filename of the .blend file in image metadata'"
|
||||
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_frame -> use_stamp_frame: boolean "'Include the frame number in image metadata'"
|
||||
RenderSettings.stamp_marker -> use_stamp_marker: boolean "'Include the name of the last marker in image metadata'"
|
||||
RenderSettings.stamp_note -> use_stamp_note: boolean "'Include a custom note in image metadata'"
|
||||
RenderSettings.stamp_note_text -> stamp_note_text: string "'Custom text to appear in the stamp note'"
|
||||
RenderSettings.stamp_render_time -> use_stamp_render_time: boolean "'Include the render time in the stamp image'"
|
||||
RenderSettings.stamp_scene -> use_stamp_scene: boolean "'Include the name of the active scene in image metadata'"
|
||||
RenderSettings.stamp_sequencer_strip -> use_stamp_sequencer_strip: boolean "'Include the name of the foreground sequence strip in image metadata'"
|
||||
RenderSettings.stamp_time -> use_stamp_time: boolean "'Include the render frame as HH:MM:SS.FF in image metadata'"
|
||||
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'"
|
||||
RenderSettings.tiff_bit -> use_tiff_16bit: boolean "'Save TIFF with 16 bits per channel'"
|
||||
RenderSettings.use_border -> use_border: boolean "'Render a user-defined border region, within the frame size. Note, this disables save_buffers and full_sample'"
|
||||
RenderSettings.use_compositing -> use_compositing: boolean "'Process the render result through the compositing pipeline, if compositing nodes are enabled'"
|
||||
RenderSettings.use_envmaps -> use_envmaps: boolean "'Calculate environment maps while rendering'"
|
||||
RenderSettings.use_file_extension -> use_file_extension: boolean "'Add the file format extensions to the rendered file name (eg: filename + .jpg)'"
|
||||
RenderSettings.use_game_engine -> use_game_engine: boolean, "'(read-only) Current rendering engine is a game engine'"
|
||||
RenderSettings.use_instances -> use_instances: boolean "'Instance support leads to effective memory reduction when using duplicates'"
|
||||
RenderSettings.use_local_coords -> use_local_coords: boolean "'Vertex coordinates are stored localy on each primitive. Increases memory usage, but may have impact on speed'"
|
||||
RenderSettings.use_overwrite -> use_overwrite: boolean "'Overwrite existing files while rendering'"
|
||||
RenderSettings.use_placeholder -> use_placeholder: boolean '"Create empty placeholder files while rendering frames (similar to Unix \'touch\')"'
|
||||
RenderSettings.use_radiosity -> use_radiosity: boolean "'Calculate radiosity in a pre-process before rendering'"
|
||||
RenderSettings.use_raytracing -> use_raytrace: boolean "'Pre-calculate the raytrace accelerator and render raytracing effects'"
|
||||
RenderSettings.use_sequencer -> use_sequencer: boolean "'Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist'"
|
||||
RenderSettings.use_sequencer_gl_preview -> use_sequencer_gl_preview: boolean "'NO DESCRIPTION'"
|
||||
RenderSettings.use_sequencer_gl_render -> use_sequencer_gl_render: boolean "'NO DESCRIPTION'"
|
||||
RenderSettings.use_shadows -> use_shadows: boolean "'Calculate shadows while rendering'"
|
||||
RenderSettings.use_simplify -> use_simplify: boolean "'Enable simplification of scene for quicker preview renders'"
|
||||
RenderSettings.use_sss -> use_sss: boolean "'Calculate sub-surface scattering in materials rendering'"
|
||||
RenderSettings.use_textures -> use_textures: boolean "'Use textures to affect material properties'"
|
||||
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'"
|
||||
NEGATE * RigidBodyJointConstraint.disable_linked_collision -> use_linked_collision: boolean "'Disable collision between linked bodies'"
|
||||
RigidBodyJointConstraint.draw_pivot -> show_pivot: boolean "'Display the pivot point and rotation in 3D view'"
|
||||
RigidBodyJointConstraint.pivot_type -> pivot_type: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
Scene.frame_drop -> use_frame_drop: boolean "'Play back dropping frames if frame display is too slow'"
|
||||
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.layers -> layers: boolean "'Layers visible when rendering the scene'"
|
||||
Scene.mute_audio -> mute_audio: boolean "'Play back of audio from Sequence Editor will be muted'"
|
||||
Scene.network_render -> network_render: pointer, "'(read-only) Network Render Settings'"
|
||||
Scene.nla_tweakmode_on -> use_nla_tweakmode: boolean, "'(read-only) Indicates whether there is any action referenced by NLA being edited. Strictly read-only'"
|
||||
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.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.scrub_audio -> use_audio_scrub: boolean "'Play audio from Sequence Editor while scrubbing'"
|
||||
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_audio -> use_audio_sync: boolean "'Play back and sync with audio clock, dropping frames if frame display is too slow'"
|
||||
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.use_gravity -> use_gravity: boolean "'Use global gravity for all dynamics'"
|
||||
Scene.use_nodes -> use_nodes: boolean "'Enable the compositing node tree'"
|
||||
Scene.use_preview_range -> use_preview_range: boolean "'Use an alternative start/end frame for UI playback, rather than the scene start/end frame'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 -> use_activity_culling: boolean "'Activity culling is enabled'"
|
||||
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.auto_start -> use_auto_start: boolean "'Automatically start game at load time'"
|
||||
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 -> frame_color: float "'Set colour of the bars'"
|
||||
SceneGameData.framing_type -> frame_type: enum "'Select the type of Framing you want'"
|
||||
SceneGameData.frequency -> frequency: int "'Displays clock frequency of fullscreen display'"
|
||||
SceneGameData.fullscreen -> show_fullscreen: boolean "'Starts player in a new fullscreen display'"
|
||||
SceneGameData.glsl_extra_textures -> use_glsl_extra_textures: boolean "'Use extra textures like normal or specular maps for GLSL rendering'"
|
||||
SceneGameData.glsl_lights -> use_glsl_lights: boolean "'Use lights for GLSL rendering'"
|
||||
SceneGameData.glsl_nodes -> use_glsl_nodes: boolean "'Use nodes for GLSL rendering'"
|
||||
SceneGameData.glsl_ramps -> use_glsl_ramps: boolean "'Use ramps for GLSL rendering'"
|
||||
SceneGameData.glsl_shaders -> use_glsl_shaders: boolean "'Use shaders for GLSL rendering'"
|
||||
SceneGameData.glsl_shadows -> use_glsl_shadows: boolean "'Use shadows for GLSL rendering'"
|
||||
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.show_debug_properties -> show_debug_properties: boolean "'Show properties marked for debugging while the game runs'"
|
||||
SceneGameData.show_framerate_profile -> show_framerate_profile: boolean "'Show framerate and profiling information while the game runs'"
|
||||
SceneGameData.show_physics_visualization -> show_physics_visualization: boolean "'Show a visualization of physics bounds and interactions'"
|
||||
SceneGameData.stereo -> stereo: enum "'NO DESCRIPTION'"
|
||||
SceneGameData.stereo_mode -> stereo_mode: enum "'Stereographic techniques'"
|
||||
SceneGameData.use_animation_record -> use_animation_record: boolean "'Record animation to fcurves'"
|
||||
SceneGameData.use_deprecation_warnings -> use_deprecation_warnings: boolean "'Print warnings when using deprecated features in the python API'"
|
||||
SceneGameData.use_display_lists -> use_display_lists: boolean "'Use display lists to speed up rendering by keeping geometry on the GPU'"
|
||||
SceneGameData.use_frame_rate -> use_frame_rate: boolean "'Respect the frame rate rather than rendering as many frames as possible'"
|
||||
SceneGameData.use_occlusion_culling -> use_occlusion_culling: boolean "'Use optimized Bullet DBVT tree for view frustum and occlusion culling'"
|
||||
SceneObjects.active -> active: pointer "'Active object for this scene'"
|
||||
SceneRenderLayer.all_z -> use_all_z: boolean "'Fill in Z values for solid faces in invisible layers, for masking'"
|
||||
SceneRenderLayer.edge -> use_edge_enhance: boolean "'Render Edge-enhance in this Layer (only works for Solid faces)'"
|
||||
SceneRenderLayer.enabled -> use: boolean "'Disable or enable the render layer'"
|
||||
SceneRenderLayer.halo -> use_halo: boolean "'Render Halos in this Layer (on top of Solid)'"
|
||||
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'"
|
||||
SceneRenderLayer.pass_ao -> use_pass_ambient_occlusion: boolean "'Deliver AO pass'"
|
||||
SceneRenderLayer.pass_ao_exclude -> exclude_ambient_occlusion: boolean "'Exclude AO pass from combined'"
|
||||
SceneRenderLayer.pass_color -> use_pass_color: boolean "'Deliver shade-less color pass'"
|
||||
SceneRenderLayer.pass_combined -> use_pass_combined: boolean "'Deliver full combined RGBA buffer'"
|
||||
SceneRenderLayer.pass_diffuse -> use_pass_diffuse: boolean "'Deliver diffuse pass'"
|
||||
SceneRenderLayer.pass_emit -> use_pass_emit: boolean "'Deliver emission pass'"
|
||||
SceneRenderLayer.pass_emit_exclude -> exclude_emit: boolean "'Exclude emission pass from combined'"
|
||||
SceneRenderLayer.pass_environment -> use_pass_environment: boolean "'Deliver environment lighting pass'"
|
||||
SceneRenderLayer.pass_environment_exclude -> exclude_environment: boolean "'Exclude environment pass from combined'"
|
||||
SceneRenderLayer.pass_indirect -> use_pass_indirect: boolean "'Deliver indirect lighting pass'"
|
||||
SceneRenderLayer.pass_indirect_exclude -> exclude_indirect: boolean "'Exclude indirect pass from combined'"
|
||||
SceneRenderLayer.pass_mist -> use_pass_mist: boolean "'Deliver mist factor pass (0.0-1.0)'"
|
||||
SceneRenderLayer.pass_normal -> use_pass_normal: boolean "'Deliver normal pass'"
|
||||
SceneRenderLayer.pass_object_index -> use_pass_object_index: boolean "'Deliver object index pass'"
|
||||
SceneRenderLayer.pass_reflection -> use_pass_reflection: boolean "'Deliver raytraced reflection pass'"
|
||||
SceneRenderLayer.pass_reflection_exclude -> exclude_reflection: boolean "'Exclude raytraced reflection pass from combined'"
|
||||
SceneRenderLayer.pass_refraction -> use_pass_refraction: boolean "'Deliver raytraced refraction pass'"
|
||||
SceneRenderLayer.pass_refraction_exclude -> exclude_refraction: boolean "'Exclude raytraced refraction pass from combined'"
|
||||
SceneRenderLayer.pass_shadow -> use_pass_shadow: boolean "'Deliver shadow pass'"
|
||||
SceneRenderLayer.pass_shadow_exclude -> exclude_shadow: boolean "'Exclude shadow pass from combined'"
|
||||
SceneRenderLayer.pass_specular -> use_pass_specular: boolean "'Deliver specular pass'"
|
||||
SceneRenderLayer.pass_specular_exclude -> exclude_specular: boolean "'Exclude specular pass from combined'"
|
||||
SceneRenderLayer.pass_uv -> use_pass_uv: boolean "'Deliver texture UV pass'"
|
||||
SceneRenderLayer.pass_vector -> use_pass_vector: boolean "'Deliver speed vector pass'"
|
||||
SceneRenderLayer.pass_z -> use_pass_z: boolean "'Deliver Z values pass'"
|
||||
SceneRenderLayer.sky -> use_sky: boolean "'Render Sky in this Layer'"
|
||||
SceneRenderLayer.solid -> use_solid: boolean "'Render Solid faces in this Layer'"
|
||||
SceneRenderLayer.strand -> use_strand: boolean "'Render Strands in this Layer'"
|
||||
SceneRenderLayer.visible_layers -> layers: boolean "'Scene layers included in this render layer'"
|
||||
SceneRenderLayer.zmask -> use_zmask: boolean '"Only render what\'s in front of the solid z values"'
|
||||
SceneRenderLayer.zmask_layers -> layers_zmask: boolean "'Zmask scene layers'"
|
||||
SceneRenderLayer.zmask_negate -> invert_zmask: boolean "'For Zmask, only render what is behind solid z values instead of in front'"
|
||||
SceneRenderLayer.ztransp -> use_ztransp: boolean "'Render Z-Transparent faces in this Layer (On top of Solid and Halos)'"
|
||||
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.color_saturation -> color_saturation: float "'NO DESCRIPTION'"
|
||||
SceneSequence.convert_float -> use_float: boolean "'Convert input to float data'"
|
||||
SceneSequence.crop -> crop: pointer, "'(read-only)'"
|
||||
SceneSequence.de_interlace -> use_deinterlace: boolean "'For video movies to remove fields'"
|
||||
SceneSequence.flip_x -> use_flip_x: boolean "'Flip on the X axis'"
|
||||
SceneSequence.flip_y -> use_flip_y: boolean "'Flip on the Y axis'"
|
||||
SceneSequence.multiply_colors -> multiply_colors: float "'NO DESCRIPTION'"
|
||||
SceneSequence.premultiply -> use_premultiply: boolean "'Convert RGB from key alpha to premultiplied alpha'"
|
||||
SceneSequence.proxy -> proxy: pointer, "'(read-only)'"
|
||||
SceneSequence.proxy_custom_directory -> use_proxy_custom_directory: boolean "'Use a custom directory to store data'"
|
||||
SceneSequence.proxy_custom_file -> use_proxy_custom_file: boolean "'Use a custom file to read proxy data from'"
|
||||
SceneSequence.reverse_frames -> use_reverse_frames: boolean "'Reverse frame order'"
|
||||
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)'"
|
||||
SceneSequence.use_color_balance -> use_color_balance: boolean "'(3-Way color correction) on input'"
|
||||
SceneSequence.use_crop -> use_crop: boolean "'Crop image before processing'"
|
||||
SceneSequence.use_proxy -> use_proxy: boolean "'Use a preview proxy for this strip'"
|
||||
SceneSequence.use_translation -> use_translation: boolean "'Translate image before processing'"
|
||||
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.use_full_resolution -> use_full_resolution: boolean "'Sample every pixel of the image'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
Screen.animation_playing -> is_animation_playing: boolean, "'(read-only) Animation playback is active'"
|
||||
Screen.areas -> areas: collection, "'(read-only) Areas the screen is subdivided into'"
|
||||
Screen.fullscreen -> is_fullscreen: boolean, "'(read-only) An area is maximised, filling this screen'"
|
||||
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'"
|
||||
ScrewModifier.use_normal_calculate -> use_normal_calculate: boolean "'Calculate the order of edges (needed for meshes, but not curves)'"
|
||||
ScrewModifier.use_normal_flip -> use_normal_flip: boolean "'Flip normals of lathed faces'"
|
||||
ScrewModifier.use_object_screw_offset -> use_object_screw_offset: boolean "'Use the distance between the objects to make a screw'"
|
||||
Sculpt.lock_x -> lock_x: boolean "'Disallow changes to the X axis of vertices'"
|
||||
Sculpt.lock_y -> lock_y: boolean "'Disallow changes to the Y axis of vertices'"
|
||||
Sculpt.lock_z -> lock_z: boolean "'Disallow changes to the Z axis of vertices'"
|
||||
Sculpt.radial_symm -> radial_symm: int "'Number of times to copy strokes across the surface'"
|
||||
Sculpt.symmetry_x -> use_symmetry_x: boolean "'Mirror brush across the X axis'"
|
||||
Sculpt.symmetry_y -> use_symmetry_y: boolean "'Mirror brush across the Y axis'"
|
||||
Sculpt.symmetry_z -> use_symmetry_z: boolean "'Mirror brush across the Z axis'"
|
||||
Sculpt.use_openmp -> use_openmp: boolean "'Take advantage of multiple CPU cores to improve sculpting performance'"
|
||||
Sculpt.use_symmetry_feather -> use_symmetry_feather: boolean "'Reduce the strength of the brush where it overlaps symmetrical daubs'"
|
||||
Sensor.expanded -> show_expanded: boolean "'Set sensor expanded in the user interface'"
|
||||
Sensor.frequency -> frequency: int "'Delay between repeated pulses(in logic tics, 0=no delay)'"
|
||||
Sensor.invert -> invert: boolean "'Invert the level(output) of this sensor'"
|
||||
Sensor.level -> use_level: boolean "'Level detector, trigger controllers of new states (only applicable upon logic state transition)'"
|
||||
Sensor.name -> name: string "'Sensor name'"
|
||||
Sensor.pinned -> pinned: boolean "'Display when not linked to a visible states controller'"
|
||||
Sensor.pulse_false_level -> use_pulse_false_level: boolean "'Activate FALSE level triggering (pulse mode)'"
|
||||
Sensor.pulse_true_level -> use_pulse_true_level: boolean "'Activate TRUE level triggering (pulse mode)'"
|
||||
Sensor.tap -> use_tap: boolean "'Trigger controllers only for an instant, even while the sensor remains true'"
|
||||
Sensor.type -> type: enum "'NO DESCRIPTION'"
|
||||
Sequence.blend_mode -> blend_type: enum "'NO DESCRIPTION'"
|
||||
Sequence.blend_opacity -> blend_opacity: float "'NO DESCRIPTION'"
|
||||
Sequence.channel -> channel: int "'Y position of the sequence strip'"
|
||||
Sequence.effect_fader -> effect_fader: float "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
Sequence.frame_still_end -> frame_still_end: int, "'(read-only)'"
|
||||
Sequence.frame_still_start -> frame_still_start: int, "'(read-only)'"
|
||||
Sequence.lock -> lock: boolean '"Lock strip so that it can\'t be transformed"'
|
||||
Sequence.mute -> mute: boolean "'NO DESCRIPTION'"
|
||||
Sequence.name -> name: string "'NO DESCRIPTION'"
|
||||
Sequence.select -> select: boolean "'NO DESCRIPTION'"
|
||||
Sequence.select_left_handle -> select_left_handle: boolean "'NO DESCRIPTION'"
|
||||
Sequence.select_right_handle -> select_right_handle: boolean "'NO DESCRIPTION'"
|
||||
Sequence.speed_fader -> speed_fader: float "'NO DESCRIPTION'"
|
||||
Sequence.type -> type: enum, "'(read-only)'"
|
||||
Sequence.use_effect_default_fade -> use_default_fade: boolean "'Fade effect using the built-in default (usually make transition as long as effect strip)'"
|
||||
SequenceColorBalance.gain -> gain: float "'Color balance gain (highlights)'"
|
||||
SequenceColorBalance.gamma -> gamma: float "'Color balance gamma (midtones)'"
|
||||
SequenceColorBalance.inverse_gain -> invert_gain: boolean "'NO DESCRIPTION'"
|
||||
SequenceColorBalance.inverse_gamma -> invert_gamma: boolean "'NO DESCRIPTION'"
|
||||
SequenceColorBalance.inverse_lift -> invert_lift: boolean "'NO DESCRIPTION'"
|
||||
SequenceColorBalance.lift -> lift: float "'Color balance lift (shadows)'"
|
||||
SequenceCrop.bottom -> bottom: int "'NO DESCRIPTION'"
|
||||
SequenceCrop.left -> left: int "'NO DESCRIPTION'"
|
||||
SequenceCrop.right -> right: int "'NO DESCRIPTION'"
|
||||
SequenceCrop.top -> top: int "'NO DESCRIPTION'"
|
||||
SequenceEditor.active_strip -> active_strip: pointer "'NO DESCRIPTION'"
|
||||
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.overlay_lock -> overlay_lock: boolean "'NO DESCRIPTION'"
|
||||
SequenceEditor.sequences -> sequences: collection, "'(read-only)'"
|
||||
SequenceEditor.sequences_all -> sequences_all: collection, "'(read-only)'"
|
||||
SequenceEditor.show_overlay -> show_overlay: boolean "'Partial overlay ontop of the sequencer'"
|
||||
SequenceElement.filename -> filename: string "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
SequenceTransform.offset_y -> offset_y: int "'NO DESCRIPTION'"
|
||||
ShaderNode.type -> type: enum, "'(read-only)'"
|
||||
ShaderNodeExtendedMaterial.diffuse -> use_diffuse: boolean "'Material Node outputs Diffuse'"
|
||||
ShaderNodeExtendedMaterial.invert_normal -> invert_normal: boolean "'Material Node uses inverted normal'"
|
||||
ShaderNodeExtendedMaterial.material -> material: pointer "'NO DESCRIPTION'"
|
||||
ShaderNodeExtendedMaterial.specular -> use_specular: boolean "'Material Node outputs Specular'"
|
||||
ShaderNodeGeometry.color_layer -> color_layer: string "'NO DESCRIPTION'"
|
||||
ShaderNodeGeometry.uv_layer -> uv_layer: string "'NO DESCRIPTION'"
|
||||
ShaderNodeMapping.clamp_maximum -> use_max: boolean "'Clamp the output coordinate to a maximum value'"
|
||||
ShaderNodeMapping.clamp_minimum -> use_min: boolean "'Clamp the output coordinate to a minimum value'"
|
||||
ShaderNodeMapping.location -> location: float "'Location offset for the input coordinate'"
|
||||
ShaderNodeMapping.maximum -> max: float "'Maximum value to clamp coordinate to'"
|
||||
ShaderNodeMapping.minimum -> min: 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.diffuse -> use_diffuse: boolean "'Material Node outputs Diffuse'"
|
||||
ShaderNodeMaterial.invert_normal -> invert_normal: boolean "'Material Node uses inverted normal'"
|
||||
ShaderNodeMaterial.material -> material: pointer "'NO DESCRIPTION'"
|
||||
ShaderNodeMaterial.specular -> use_specular: boolean "'Material Node outputs Specular'"
|
||||
ShaderNodeMath.operation -> operation: enum "'NO DESCRIPTION'"
|
||||
ShaderNodeMixRGB.alpha -> use_alpha: boolean "'Include alpha of second input in this operation'"
|
||||
ShaderNodeMixRGB.blend_type -> blend_type: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
ShaderNodeValToRGB.color_ramp -> color_ramp: pointer, "'(read-only)'"
|
||||
ShaderNodeVectorCurve.mapping -> mapping: pointer, "'(read-only)'"
|
||||
ShaderNodeVectorMath.operation -> operation: enum "'NO DESCRIPTION'"
|
||||
ShapeActionActuator.action -> action: pointer "'NO DESCRIPTION'"
|
||||
ShapeActionActuator.blendin -> blendin: int "'Number of frames of motion blending'"
|
||||
ShapeActionActuator.continue_last_frame -> use_continue_last_frame: boolean "'Restore last frame when switching on/off, otherwise play from the start each time'"
|
||||
ShapeActionActuator.frame_end -> frame_end: int "'NO DESCRIPTION'"
|
||||
ShapeActionActuator.frame_property -> frame_property: string '"Assign the action\'s current frame number to this property"'
|
||||
ShapeActionActuator.frame_start -> frame_start: int "'NO DESCRIPTION'"
|
||||
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.mute -> mute: boolean "'Mute this shape key'"
|
||||
ShapeKey.name -> name: string "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
ShapeKeyBezierPoint.handle_1_co -> handle_1_co: float "'NO DESCRIPTION'"
|
||||
ShapeKeyBezierPoint.handle_2_co -> handle_2_co: float "'NO DESCRIPTION'"
|
||||
ShapeKeyCurvePoint.co -> co: float "'NO DESCRIPTION'"
|
||||
ShapeKeyCurvePoint.tilt -> tilt: float "'NO DESCRIPTION'"
|
||||
ShapeKeyPoint.co -> co: float "'NO DESCRIPTION'"
|
||||
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'"
|
||||
ShrinkwrapConstraint.use_x -> use_x: boolean "'Projection over X Axis'"
|
||||
ShrinkwrapConstraint.use_y -> use_y: boolean "'Projection over Y Axis'"
|
||||
ShrinkwrapConstraint.use_z -> use_z: boolean "'Projection over Z Axis'"
|
||||
ShrinkwrapModifier.auxiliary_target -> auxiliary_target: pointer "'Additional mesh target to shrink to'"
|
||||
ShrinkwrapModifier.cull_back_faces -> use_cull_back_faces: boolean "'Stop vertices from projecting to a back face on the target'"
|
||||
ShrinkwrapModifier.cull_front_faces -> use_cull_front_faces: boolean "'Stop vertices from projecting to a front face on the target'"
|
||||
ShrinkwrapModifier.keep_above_surface -> use_keep_above_surface: boolean "'NO DESCRIPTION'"
|
||||
ShrinkwrapModifier.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
ShrinkwrapModifier.negative -> use_negative_direction: boolean "'Allow vertices to move in the negative direction of axis'"
|
||||
ShrinkwrapModifier.offset -> offset: float "'Distance to keep from the target'"
|
||||
ShrinkwrapModifier.positive -> use_positive_direction: boolean "'Allow vertices to move in the positive direction of axis'"
|
||||
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'"
|
||||
ShrinkwrapModifier.x -> use_project_x: boolean "'NO DESCRIPTION'"
|
||||
ShrinkwrapModifier.y -> use_project_y: boolean "'NO DESCRIPTION'"
|
||||
ShrinkwrapModifier.z -> use_project_z: boolean "'NO DESCRIPTION'"
|
||||
SimpleDeformModifier.factor -> factor: float "'NO DESCRIPTION'"
|
||||
SimpleDeformModifier.limits -> limits: float "'Lower/Upper limits for deform'"
|
||||
SimpleDeformModifier.lock_x_axis -> lock_x: boolean "'NO DESCRIPTION'"
|
||||
SimpleDeformModifier.lock_y_axis -> lock_y: boolean "'NO DESCRIPTION'"
|
||||
SimpleDeformModifier.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
SimpleDeformModifier.origin -> origin: pointer "'Origin of modifier space coordinates'"
|
||||
SimpleDeformModifier.relative -> use_relative: boolean "'Sets the origin of deform space to be relative to the object'"
|
||||
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_smoke -> use_dissolve_smoke: boolean "'Enable smoke to disappear over time'"
|
||||
SmokeDomainSettings.dissolve_smoke_log -> use_dissolve_smoke_log: boolean "'Using 1/x'"
|
||||
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.highres -> use_high_resolution: boolean "'Enable high resolution (using amplification)'"
|
||||
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.smoke_domain_colli -> smoke_domain_colli: enum "'Selects which domain border will be treated as collision object.'"
|
||||
SmokeDomainSettings.smoothemitter -> smoothemitter: boolean "'Smoothens emitted smoke to avoid blockiness.'"
|
||||
SmokeDomainSettings.strength -> strength: float "'Strength of wavelet noise'"
|
||||
SmokeDomainSettings.time_scale -> time_scale: float "'Adjust simulation speed.'"
|
||||
SmokeDomainSettings.viewhighres -> show_high_resolution: boolean "'Show high resolution (using amplification)'"
|
||||
SmokeDomainSettings.vorticity -> vorticity: float "'Amount of turbulence/rotation in fluid.'"
|
||||
SmokeFlowSettings.absolute -> absolute: boolean "'Only allows given density value in emitter area.'"
|
||||
SmokeFlowSettings.density -> density: float "'NO DESCRIPTION'"
|
||||
SmokeFlowSettings.initial_velocity -> initial_velocity: boolean '"Smoke inherits it\'s velocity from the emitter particle"'
|
||||
NEGATE * SmokeFlowSettings.outflow -> use_outflow: boolean "'Deletes smoke from simulation'"
|
||||
SmokeFlowSettings.psys -> psys: pointer "'Particle systems emitted from the object'"
|
||||
SmokeFlowSettings.temperature -> temperature: float "'Temperature difference to ambient temperature'"
|
||||
SmokeFlowSettings.velocity_multiplier -> velocity_multiplier: float "'Multiplier to adjust velocity passed to smoke'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
SmoothModifier.factor -> factor: float "'NO DESCRIPTION'"
|
||||
SmoothModifier.repeat -> repeat: int "'NO DESCRIPTION'"
|
||||
SmoothModifier.vertex_group -> vertex_group: string "'Vertex group name'"
|
||||
SmoothModifier.x -> use_x: boolean "'NO DESCRIPTION'"
|
||||
SmoothModifier.y -> use_y: boolean "'NO DESCRIPTION'"
|
||||
SmoothModifier.z -> use_z: boolean "'NO DESCRIPTION'"
|
||||
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.auto_step -> use_auto_step: boolean "'Use velocities for automagic step sizes'"
|
||||
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 -> bend: 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.diagnose -> use_diagnose: boolean "'Turn on SB diagnose console prints'"
|
||||
SoftBodySettings.edge_collision -> use_edge_collision: boolean "'Edges collide too'"
|
||||
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.estimate_matrix -> use_estimate_matrix: boolean "'estimate matrix .. split to COM , ROT ,SCALE'"
|
||||
SoftBodySettings.face_collision -> use_face_collision: boolean "'Faces collide too, SLOOOOOW warning'"
|
||||
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 -> step_max: int "'Maximal # solver steps/frame'"
|
||||
SoftBodySettings.minstep -> step_min: 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.self_collision -> use_self_collision: boolean "'Enable naive vertex ball self collision'"
|
||||
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'"
|
||||
SoftBodySettings.stiff_quads -> use_stiff_quads: boolean "'Adds diagonal springs on 4-gons'"
|
||||
SoftBodySettings.use_edges -> use_edges: boolean "'Use Edges as springs'"
|
||||
SoftBodySettings.use_goal -> use_goal: boolean "'Define forces for vertices to stick to animated position'"
|
||||
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.invert -> invert_vertex_group: boolean "'Invert the vertex group influence'"
|
||||
SolidifyModifier.offset -> offset: float "'NO DESCRIPTION'"
|
||||
SolidifyModifier.thickness -> thickness: float "'Thickness of the shell'"
|
||||
SolidifyModifier.use_even_offset -> use_even_offset: boolean "'Maintain thickness by adjusting for sharp corners (slow, disable when not needed)'"
|
||||
SolidifyModifier.use_quality_normals -> use_quality_normals: boolean "'Calculate normals which result in more even thickness (slow, disable when not needed)'"
|
||||
SolidifyModifier.use_rim -> use_rim: boolean "'Create edge loops between the inner and outer surfaces on face edges (slow, disable when not needed)'"
|
||||
SolidifyModifier.use_rim_material -> use_rim_material: boolean "'Use in the next material for rim faces'"
|
||||
SolidifyModifier.vertex_group -> vertex_group: string "'Vertex group name'"
|
||||
Sound.caching -> use_ram_cache: boolean "'The sound file is decoded and loaded into RAM'"
|
||||
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.enable_sound_3d -> use_3d_sound: boolean "'Enable/Disable 3D Sound'"
|
||||
SoundActuator.max_distance_3d -> distance_3d_max: float "'The maximum distance at which you can hear the sound'"
|
||||
SoundActuator.maximum_gain_3d -> gain_3d_max: float "'The maximum gain of the sound, no matter how near it is'"
|
||||
SoundActuator.minimum_gain_3d -> gain_3d_min: float "'The minimum gain of the sound, no matter how far it is away'"
|
||||
SoundActuator.mode -> mode: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
SpaceConsole.selection_start -> selection_start: int "'NO DESCRIPTION'"
|
||||
SpaceConsole.show_report_debug -> show_report_debug: boolean "'Display debug reporting info'"
|
||||
SpaceConsole.show_report_error -> show_report_error: boolean "'Display error text'"
|
||||
SpaceConsole.show_report_info -> show_report_info: boolean "'Display general information'"
|
||||
SpaceConsole.show_report_operator -> show_report_operator: boolean "'Display the operator log'"
|
||||
SpaceConsole.show_report_warn -> show_report_warning: boolean "'Display warnings'"
|
||||
SpaceDopeSheetEditor.action -> action: pointer "'Action displayed and edited in this space'"
|
||||
SpaceDopeSheetEditor.automerge_keyframes -> use_automerge_keyframes: boolean "'Automatically merge nearby keyframes'"
|
||||
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'"
|
||||
SpaceDopeSheetEditor.realtime_updates -> use_realtime_updates: boolean "'When transforming keyframes, changes to the animation data are flushed to other views'"
|
||||
SpaceDopeSheetEditor.show_cframe_indicator -> show_frame_indicator: boolean "'Show frame number beside the current frame indicator line'"
|
||||
SpaceDopeSheetEditor.show_seconds -> show_seconds: boolean, "'(read-only) Show timing in seconds not frames'"
|
||||
SpaceDopeSheetEditor.show_sliders -> show_sliders: boolean "'Show sliders beside F-Curve channels'"
|
||||
SpaceDopeSheetEditor.use_marker_sync -> use_marker_sync: boolean "'Sync Markers with keyframe edits'"
|
||||
SpaceFileBrowser.params -> params: pointer, "'(read-only) Parameters and Settings for the Filebrowser'"
|
||||
SpaceGraphEditor.automerge_keyframes -> use_automerge_keyframes: boolean "'Automatically merge nearby keyframes'"
|
||||
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.has_ghost_curves -> has_ghost_curves: boolean "'Graph Editor instance has some ghost curves stored'"
|
||||
SpaceGraphEditor.mode -> mode: enum "'Editing context being displayed'"
|
||||
SpaceGraphEditor.only_selected_curves_handles -> use_only_selected_curves_handles: boolean "'Only keyframes of selected F-Curves are visible and editable'"
|
||||
SpaceGraphEditor.only_selected_keyframe_handles -> use_only_selected_keyframe_handles: boolean "'Only show and edit handles of selected keyframes'"
|
||||
SpaceGraphEditor.pivot_point -> pivot_point: enum "'Pivot center for rotation/scaling'"
|
||||
SpaceGraphEditor.realtime_updates -> use_realtime_updates: boolean "'When transforming keyframes, changes to the animation data are flushed to other views'"
|
||||
SpaceGraphEditor.show_cframe_indicator -> show_frame_indicator: boolean "'Show frame number beside the current frame indicator line'"
|
||||
SpaceGraphEditor.show_cursor -> show_cursor: boolean "'Show 2D cursor'"
|
||||
SpaceGraphEditor.show_handles -> show_handles: boolean "'Show handles of Bezier control points'"
|
||||
SpaceGraphEditor.show_seconds -> show_seconds: boolean, "'(read-only) Show timing in seconds not frames'"
|
||||
SpaceGraphEditor.show_sliders -> show_sliders: boolean "'Show sliders beside F-Curve channels'"
|
||||
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.draw_repeated -> show_repeated: boolean "'Draw the image repeated outside of the main view'"
|
||||
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_painting -> use_image_paint: boolean "'Enable image painting mode'"
|
||||
SpaceImageEditor.image_pin -> use_image_pin: boolean "'Display current image regardless of object selection'"
|
||||
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.show_paint -> show_paint: boolean, "'(read-only) Show paint related properties'"
|
||||
SpaceImageEditor.show_render -> show_render: boolean, "'(read-only) Show render related properties'"
|
||||
SpaceImageEditor.show_uvedit -> show_uvedit: boolean, "'(read-only) Show UV editing related properties'"
|
||||
SpaceImageEditor.update_automatically -> use_realtime_updates: boolean "'Update other affected window spaces automatically to reflect changes during interactive operations such as transform'"
|
||||
SpaceImageEditor.use_grease_pencil -> use_grease_pencil: boolean "'Display and edit the grease pencil freehand annotations overlay'"
|
||||
SpaceImageEditor.uv_editor -> uv_editor: pointer, "'(read-only) UV editor settings'"
|
||||
SpaceLogicEditor.actuators_show_active_objects -> show_actuators_active_objects: boolean "'Show actuators of active object'"
|
||||
SpaceLogicEditor.actuators_show_active_states -> show_actuators_active_states: boolean "'Show only actuators connected to active states'"
|
||||
SpaceLogicEditor.actuators_show_linked_controller -> show_actuators_linked_controller: boolean "'Show linked objects to the actuator'"
|
||||
SpaceLogicEditor.actuators_show_selected_objects -> show_actuators_selected_objects: boolean "'Show actuators of all selected objects'"
|
||||
SpaceLogicEditor.controllers_show_active_objects -> show_controllers_active_objects: boolean "'Show controllers of active object'"
|
||||
SpaceLogicEditor.controllers_show_linked_controller -> show_controllers_linked_controller: boolean "'Show linked objects to sensor/actuator'"
|
||||
SpaceLogicEditor.controllers_show_selected_objects -> show_controllers_selected_objects: boolean "'Show controllers of all selected objects'"
|
||||
SpaceLogicEditor.sensors_show_active_objects -> show_sensors_active_objects: boolean "'Show sensors of active object'"
|
||||
SpaceLogicEditor.sensors_show_active_states -> show_sensors_active_states: boolean "'Show only sensors connected to active states'"
|
||||
SpaceLogicEditor.sensors_show_linked_controller -> show_sensors_linked_controller: boolean "'Show linked objects to the controller'"
|
||||
SpaceLogicEditor.sensors_show_selected_objects -> show_sensors_selected_objects: boolean "'Show sensors of all selected objects'"
|
||||
SpaceNLA.autosnap -> autosnap: enum "'Automatic time snapping settings for transformations'"
|
||||
SpaceNLA.dopesheet -> dopesheet: pointer, "'(read-only) Settings for filtering animation data'"
|
||||
SpaceNLA.realtime_updates -> use_realtime_updates: boolean "'When transforming strips, changes to the animation data are flushed to other views'"
|
||||
SpaceNLA.show_cframe_indicator -> show_frame_indicator: boolean "'Show frame number beside the current frame indicator line'"
|
||||
SpaceNLA.show_seconds -> show_seconds: boolean, "'(read-only) Show timing in seconds not frames'"
|
||||
SpaceNLA.show_strip_curves -> show_strip_curves: boolean "'Show influence curves on strips'"
|
||||
SpaceNodeEditor.backdrop -> show_backdrop: boolean "'Use active Viewer Node output as backdrop for compositing nodes'"
|
||||
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'"
|
||||
SpaceOutliner.match_case_sensitive -> use_match_case_sensitive: boolean "'Only use case sensitive matches of search string'"
|
||||
SpaceOutliner.match_complete -> use_match_complete: boolean "'Only use complete matches of search string'"
|
||||
SpaceOutliner.show_restriction_columns -> show_restriction_columns: boolean "'Show column'"
|
||||
SpaceProperties.align -> align: enum "'Arrangement of the panels'"
|
||||
SpaceProperties.brush_texture -> show_brush_texture: boolean "'Show brush textures'"
|
||||
SpaceProperties.context -> context: enum "'Type of active data to display and edit'"
|
||||
SpaceProperties.pin_id -> pin_id: pointer "'NO DESCRIPTION'"
|
||||
SpaceProperties.use_pin_id -> use_pin_id: boolean "'Use the pinned context'"
|
||||
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_frames -> show_frames: boolean "'Draw frames rather than seconds'"
|
||||
SpaceSequenceEditor.draw_overexposed -> draw_overexposed: int "'Show overexposed areas with zebra stripes'"
|
||||
SpaceSequenceEditor.draw_safe_margin -> show_safe_margin: boolean "'Draw title safe margins in preview'"
|
||||
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.separate_color_preview -> show_separate_color: boolean "'Separate color channels in preview'"
|
||||
SpaceSequenceEditor.show_cframe_indicator -> show_frame_indicator: boolean "'Show frame number beside the current frame indicator line'"
|
||||
SpaceSequenceEditor.use_grease_pencil -> use_grease_pencil: boolean "'Display and edit the grease pencil freehand annotations overlay'"
|
||||
SpaceSequenceEditor.use_marker_sync -> use_marker_sync: boolean "'Transform markers as well as strips'"
|
||||
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_all -> use_find_all: boolean "'Search in all text datablocks, instead of only the active one'"
|
||||
SpaceTextEditor.find_text -> find_text: string "'Text to search for with the find tool'"
|
||||
SpaceTextEditor.find_wrap -> use_find_wrap: boolean "'Search again from the start of the file when reaching the end'"
|
||||
SpaceTextEditor.font_size -> font_size: int "'Font size to use for displaying the text'"
|
||||
SpaceTextEditor.line_numbers -> show_line_numbers: boolean "'Show line numbers next to the text'"
|
||||
SpaceTextEditor.live_edit -> use_live_edit: boolean "'Run python while editing'"
|
||||
SpaceTextEditor.overwrite -> use_overwrite: boolean "'Overwrite characters when typing rather than inserting them'"
|
||||
SpaceTextEditor.replace_text -> replace_text: string "'Text to replace selected text with using the replace tool'"
|
||||
SpaceTextEditor.syntax_highlight -> show_syntax_highlight: boolean "'Syntax highlight for scripting'"
|
||||
SpaceTextEditor.tab_width -> tab_width: int "'Number of spaces to display tabs with'"
|
||||
SpaceTextEditor.text -> text: pointer "'Text displayed and edited in this space'"
|
||||
SpaceTextEditor.word_wrap -> use_word_wrap: boolean "'Wrap words if there is not enough horizontal space'"
|
||||
SpaceTimeline.cache_cloth -> cache_cloth: boolean '"Show the active object\'s cloth point cache"'
|
||||
SpaceTimeline.cache_particles -> cache_particles: boolean '"Show the active object\'s particle point cache"'
|
||||
SpaceTimeline.cache_smoke -> cache_smoke: boolean '"Show the active object\'s smoke cache"'
|
||||
SpaceTimeline.cache_softbody -> cache_softbody: boolean '"Show the active object\'s softbody point cache"'
|
||||
SpaceTimeline.only_selected -> show_only_selected: boolean "'Show keyframes for active Object and/or its selected channels only'"
|
||||
SpaceTimeline.play_all_3d -> use_play_3d_editors: boolean "'NO DESCRIPTION'"
|
||||
SpaceTimeline.play_anim -> use_play_animation_editors: boolean "'NO DESCRIPTION'"
|
||||
SpaceTimeline.play_buttons -> use_play_properties_editors: boolean "'NO DESCRIPTION'"
|
||||
SpaceTimeline.play_image -> use_play_image_editors: boolean "'NO DESCRIPTION'"
|
||||
SpaceTimeline.play_nodes -> use_play_node_editors: boolean "'NO DESCRIPTION'"
|
||||
SpaceTimeline.play_sequencer -> use_play_sequence_editors: boolean "'NO DESCRIPTION'"
|
||||
SpaceTimeline.play_top_left -> use_play_top_left_3d_editor: boolean "'NO DESCRIPTION'"
|
||||
SpaceTimeline.show_cache -> show_cache: boolean "'Show the status of cached frames in the timeline'"
|
||||
SpaceTimeline.show_cframe_indicator -> show_frame_indicator: boolean "'Show frame number beside the current frame indicator line'"
|
||||
SpaceUVEditor.constrain_to_image_bounds -> use_constrain_to_image_bounds: boolean "'Constraint to stay within the image bounds while editing'"
|
||||
SpaceUVEditor.cursor_location -> cursor_location: float "'2D cursor location for this view'"
|
||||
SpaceUVEditor.draw_modified_edges -> show_modified_edges: boolean "'Draw edges after modifiers are applied'"
|
||||
SpaceUVEditor.draw_other_objects -> show_other_objects: boolean "'Draw other selected objects that share the same image'"
|
||||
SpaceUVEditor.draw_smooth_edges -> show_smooth_edges: boolean "'Draw UV edges anti-aliased'"
|
||||
SpaceUVEditor.draw_stretch -> show_stretch: boolean "'Draw faces colored according to the difference in shape between UVs and their 3D coordinates (blue for low distortion, red for high distortion)'"
|
||||
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.live_unwrap -> use_live_unwrap: boolean "'Continuously unwrap the selected UV island while transforming pinned vertices'"
|
||||
SpaceUVEditor.normalized_coordinates -> show_normalized_coordinates: boolean "'Display UV coordinates from 0.0 to 1.0 rather than in pixels'"
|
||||
SpaceUVEditor.pivot -> pivot: enum "'Rotation/Scaling Pivot'"
|
||||
SpaceUVEditor.snap_to_pixels -> use_snap_to_pixels: boolean "'Snap UVs to pixel locations while editing'"
|
||||
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.all_object_origins -> show_all_objects_origin: boolean "'Show the object origin center dot for all (selected and unselected) objects'"
|
||||
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.display_background_images -> show_background_images: boolean "'Display reference images behind objects in the 3D View'"
|
||||
SpaceView3D.display_floor -> show_floor: boolean "'Show the ground plane grid in perspective view'"
|
||||
SpaceView3D.display_render_override -> show_only_render: boolean "'Display only objects which will be rendered'"
|
||||
SpaceView3D.display_x_axis -> show_axis_x: boolean "'Show the X axis line in perspective view'"
|
||||
SpaceView3D.display_y_axis -> show_axis_y: boolean "'Show the Y axis line in perspective view'"
|
||||
SpaceView3D.display_z_axis -> show_axis_z: boolean "'Show the Z axis line in perspective view'"
|
||||
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.layers -> layers: boolean "'Layers visible in this 3D View'"
|
||||
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_camera_and_layers -> lock_camera_and_layers: boolean '"Use the scene\'s active camera and layers in this view, rather than local layers"'
|
||||
SpaceView3D.lock_object -> lock_object: pointer '"3D View center is locked to this object\'s position"'
|
||||
SpaceView3D.manipulator -> use_manipulator: boolean "'Use a 3D manipulator widget for controlling transforms'"
|
||||
SpaceView3D.manipulator_rotate -> use_manipulator_rotate: boolean "'Use the manipulator for rotation transformations'"
|
||||
SpaceView3D.manipulator_scale -> use_manipulator_scale: boolean "'Use the manipulator for scale transformations'"
|
||||
SpaceView3D.manipulator_translate -> use_manipulator_translate: boolean "'Use the manipulator for movement transformations'"
|
||||
SpaceView3D.occlude_geometry -> use_occlude_geometry: boolean "'Limit selection to visible (clipped with depth buffer)'"
|
||||
SpaceView3D.outline_selected -> show_outline_selected: boolean "'Show an outline highlight around selected objects in non-wireframe views'"
|
||||
SpaceView3D.pivot_point -> pivot_point: enum "'Pivot center for rotation/scaling'"
|
||||
SpaceView3D.pivot_point_align -> use_pivot_point_align: boolean "'Manipulate object centers only'"
|
||||
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.relationship_lines -> show_relationship_lines: boolean "'Show dashed lines indicating parent or constraint relationships'"
|
||||
SpaceView3D.textured_solid -> show_textured_solid: boolean "'Display face-assigned textures in solid view'"
|
||||
SpaceView3D.transform_orientation -> transform_orientation: enum "'Transformation orientation'"
|
||||
SpaceView3D.used_layers -> layers_used: boolean, "'(read-only) Layers that contain something'"
|
||||
SpaceView3D.viewport_shading -> viewport_shade: enum "'Method to display/shade objects in the 3D View'"
|
||||
SpeedControlSequence.curve_compress_y -> use_curve_compress_y: boolean "'Scale F-Curve value to get the target frame number, F-Curve value runs from 0.0 to 1.0'"
|
||||
SpeedControlSequence.curve_velocity -> use_curve_velocity: boolean "'Interpret the F-Curve value as a velocity instead of a frame number'"
|
||||
SpeedControlSequence.frame_blending -> use_frame_blend: boolean "'Blend two frames into the target for a smoother result'"
|
||||
SpeedControlSequence.global_speed -> global_speed: float "'NO DESCRIPTION'"
|
||||
Spline.bezier_points -> bezier_points: collection, "'(read-only) Collection of points for bezier curves only'"
|
||||
Spline.bezier_u -> use_bezier_u: boolean "'Make this nurbs curve or surface act like a bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled)'"
|
||||
Spline.bezier_v -> use_bezier_v: boolean "'Make this nurbs surface act like a bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled)'"
|
||||
Spline.character_index -> character_index: int, "'(read-only) Location of this character in the text data (only for text curves)'"
|
||||
Spline.cyclic_u -> use_cyclic_u: boolean "'Make this curve or surface a closed loop in the U direction'"
|
||||
Spline.cyclic_v -> use_cyclic_v: boolean "'Make this surface a closed loop in the V direction'"
|
||||
Spline.endpoint_u -> use_endpoint_u: boolean "'Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled)'"
|
||||
Spline.endpoint_v -> use_endpoint_v: boolean "'Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)'"
|
||||
Spline.hide -> hide: boolean "'Hide this curve in editmode'"
|
||||
Spline.material_index -> material_index: int "'NO DESCRIPTION'"
|
||||
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.smooth -> use_smooth: boolean "'Smooth the normals of the surface or beveled curve'"
|
||||
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.chain_offset -> use_chain_offset: boolean "'Offset the entire chain relative to the root joint'"
|
||||
SplineIKConstraint.even_divisions -> use_even_divisions: boolean "'Ignore the relative lengths of the bones when fitting to the curve'"
|
||||
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.use_curve_radius -> use_curve_radius: boolean "'Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, on top of XZ Scale mode'"
|
||||
SplineIKConstraint.xz_scaling_mode -> xz_scale_mode: enum "'Method used for determining the scaling of the X and Z axes of the bones'"
|
||||
SplineIKConstraint.y_stretch -> use_y_stretch: boolean "'Stretch the Y axis of the bones to fit the curve'"
|
||||
SplinePoint.co -> co: float "'Point coordinates'"
|
||||
SplinePoint.hide -> hide: boolean "'Visibility status'"
|
||||
SplinePoint.radius -> radius: float, "'(read-only) Radius for bevelling'"
|
||||
SplinePoint.select -> select: boolean "'Selection status'"
|
||||
SplinePoint.tilt -> tilt: float "'Tilt in 3D View'"
|
||||
SplinePoint.weight -> weight: float "'Nurbs weight'"
|
||||
SplinePoint.weight_softbody -> weight_softbody: float "'Softbody goal weight'"
|
||||
SpotLamp.auto_clip_end -> use_auto_clip_end: boolean "'Automatic calculation of clipping-end, based on visible vertices'"
|
||||
SpotLamp.auto_clip_start -> use_auto_clip_start: boolean "'Automatic calculation of clipping-start, based on visible vertices'"
|
||||
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 -> use_halo: boolean "'Renders spotlight with a volumetric halo (Buffer Shadows)'"
|
||||
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.only_shadow -> use_only_shadow: boolean "'Causes light to cast shadows only without illuminating objects'"
|
||||
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_layer -> use_shadow_layer: boolean "'Causes only objects on the same layer to cast 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_sample_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.show_cone -> show_cone: boolean "'Draw transparent cone in 3D view to visualize which objects are contained in it'"
|
||||
SpotLamp.sphere -> use_sphere: boolean "'Sets light intensity to zero beyond lamp distance'"
|
||||
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'"
|
||||
SpotLamp.square -> use_square: boolean "'Casts a square spot light shape'"
|
||||
StateActuator.operation -> operation: enum "'Select the bit operation on object state mask'"
|
||||
StateActuator.state -> states: boolean "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 -> length_max: 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 "'NO DESCRIPTION'"
|
||||
StucciTexture.stype -> stype: enum "'NO DESCRIPTION'"
|
||||
StucciTexture.turbulence -> turbulence: float "'Sets the turbulence of the bandnoise and ringnoise types'"
|
||||
SubsurfModifier.levels -> levels: int "'Number of subdivisions to perform'"
|
||||
SubsurfModifier.optimal_display -> show_only_control_edges: boolean "'Skip drawing/rendering of interior subdivided edges'"
|
||||
SubsurfModifier.render_levels -> render_levels: int "'Number of subdivisions to perform when rendering'"
|
||||
SubsurfModifier.subdivision_type -> subdivision_type: enum "'Selects type of subdivision algorithm'"
|
||||
SubsurfModifier.subsurf_uv -> use_subsurf_uv: boolean "'Use subsurf to subdivide UVs'"
|
||||
SunLamp.only_shadow -> use_only_shadow: boolean "'Causes light to cast shadows only without illuminating objects'"
|
||||
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_layer -> use_shadow_layer: boolean "'Causes only objects on the same layer to cast shadows'"
|
||||
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'"
|
||||
SurfaceCurve.map_along_length -> use_map_along_length: boolean "'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'"
|
||||
TexMapping.has_maximum -> use_max: boolean "'Whether to use maximum clipping value'"
|
||||
TexMapping.has_minimum -> use_min: boolean "'Whether to use minimum clipping value'"
|
||||
TexMapping.location -> location: float "'NO DESCRIPTION'"
|
||||
TexMapping.maximum -> max: float "'Maximum value for clipping'"
|
||||
TexMapping.minimum -> min: float "'Minimum value for clipping'"
|
||||
TexMapping.rotation -> rotation: float "'NO DESCRIPTION'"
|
||||
TexMapping.scale -> scale: float "'NO DESCRIPTION'"
|
||||
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.dirty -> is_dirty: boolean, "'(read-only) Text file has been edited since last save'"
|
||||
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.memory -> is_in_memory: boolean, "'(read-only) Text file is in memory, without a corresponding file on disk'"
|
||||
Text.modified -> is_modified: boolean, "'(read-only) Text file on disk is different than the one in memory'"
|
||||
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'"
|
||||
Text.tabs_as_spaces -> use_tabs_as_spaces: boolean "'Automatically converts all new tabs into spaces'"
|
||||
Text.use_module -> use_module: boolean '"Register this text as a module on loading, Text name must end with \'.py\'"'
|
||||
TextBox.height -> height: float "'NO DESCRIPTION'"
|
||||
TextBox.width -> width: float "'NO DESCRIPTION'"
|
||||
TextBox.x -> x: float "'NO DESCRIPTION'"
|
||||
TextBox.y -> y: float "'NO DESCRIPTION'"
|
||||
TextCharacterFormat.bold -> use_bold: boolean "'NO DESCRIPTION'"
|
||||
TextCharacterFormat.italic -> use_italic: boolean "'NO DESCRIPTION'"
|
||||
TextCharacterFormat.underline -> use_underline: boolean "'NO DESCRIPTION'"
|
||||
TextCharacterFormat.use_small_caps -> use_small_caps: boolean "'NO DESCRIPTION'"
|
||||
TextCurve.active_textbox -> active_textbox: int "'NO DESCRIPTION'"
|
||||
TextCurve.body -> body: string "'contents of this text object'"
|
||||
TextCurve.body_format -> body_format: collection, "'(read-only) Stores the style of each character'"
|
||||
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.fast -> use_fast_editing: boolean '"Don\'t fill polygons while editing"'
|
||||
TextCurve.font -> font: pointer "'NO DESCRIPTION'"
|
||||
TextCurve.line_dist -> line_distance: float "'NO DESCRIPTION'"
|
||||
TextCurve.map_along_length -> use_map_along_length: boolean "'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'"
|
||||
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.small_caps_scale -> small_caps_scale: float "'Scale of small capitals'"
|
||||
TextCurve.spacemode -> spacemode: enum "'Text align from the object center'"
|
||||
TextCurve.spacing -> spacing: float "'NO DESCRIPTION'"
|
||||
TextCurve.text_on_curve -> text_on_curve: pointer "'Curve deforming text object'"
|
||||
TextCurve.text_size -> text_size: float "'NO DESCRIPTION'"
|
||||
TextCurve.textboxes -> textboxes: collection, "'(read-only)'"
|
||||
TextCurve.ul_height -> ul_height: float "'NO DESCRIPTION'"
|
||||
TextCurve.ul_position -> ul_position: float "'Vertical position of underline'"
|
||||
TextCurve.word_spacing -> word_spacing: float "'NO DESCRIPTION'"
|
||||
TextLine.line -> line: string "'Text in the line'"
|
||||
TextMarker.color -> color: float "'Color to display the marker with'"
|
||||
TextMarker.edit_all -> use_edit_all: boolean, "'(read-only) Edit all markers of the same group as one'"
|
||||
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'"
|
||||
TextMarker.temporary -> is_temporary: boolean, "'(read-only) Marker is temporary'"
|
||||
Texture.animation_data -> animation_data: pointer, "'(read-only) Animation data for this datablock'"
|
||||
Texture.brightness -> intensity: float "'NO DESCRIPTION'"
|
||||
Texture.color_ramp -> color_ramp: pointer, "'(read-only)'"
|
||||
Texture.contrast -> contrast: float "'NO DESCRIPTION'"
|
||||
Texture.factor_blue -> factor_blue: float "'NO DESCRIPTION'"
|
||||
Texture.factor_green -> factor_green: float "'NO DESCRIPTION'"
|
||||
Texture.factor_red -> factor_red: float "'NO DESCRIPTION'"
|
||||
Texture.node_tree -> node_tree: pointer, "'(read-only) Node tree for node-based textures'"
|
||||
Texture.saturation -> saturation: float "'NO DESCRIPTION'"
|
||||
Texture.type -> type: enum "'NO DESCRIPTION'"
|
||||
Texture.use_color_ramp -> use_color_ramp: boolean "'Toggle color ramp operations'"
|
||||
Texture.use_nodes -> use_nodes: boolean "'Make this a node-based texture'"
|
||||
Texture.use_preview_alpha -> use_preview_alpha: boolean "'Show Alpha in Preview Render'"
|
||||
TextureNode.type -> type: enum, "'(read-only)'"
|
||||
TextureNodeBricks.offset -> offset: float "'NO DESCRIPTION'"
|
||||
TextureNodeBricks.offset_frequency -> offset_frequency: int "'Offset every N rows'"
|
||||
TextureNodeBricks.squash -> squash: float "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
TextureNodeCurveTime.start -> start: int "'NO DESCRIPTION'"
|
||||
TextureNodeImage.image -> image: pointer "'NO DESCRIPTION'"
|
||||
TextureNodeMath.operation -> operation: enum "'NO DESCRIPTION'"
|
||||
TextureNodeMixRGB.alpha -> use_alpha: boolean "'Include alpha of second input in this operation'"
|
||||
TextureNodeMixRGB.blend_type -> blend_type: enum "'NO DESCRIPTION'"
|
||||
TextureNodeOutput.output_name -> output_name: string "'NO DESCRIPTION'"
|
||||
TextureNodeTexture.node_output -> node_output: int "'For node-based textures, which output node to use'"
|
||||
TextureNodeTexture.texture -> texture: pointer "'NO DESCRIPTION'"
|
||||
TextureNodeValToRGB.color_ramp -> color_ramp: pointer, "'(read-only)'"
|
||||
TextureSlot.blend_type -> blend_type: enum "'NO DESCRIPTION'"
|
||||
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.negate -> invert: boolean "'Inverts the values of the texture to reverse its effect'"
|
||||
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.rgb_to_intensity -> use_rgb_to_intensity: boolean "'Converts texture RGB values to intensity (gray) values'"
|
||||
TextureSlot.size -> size: float '"Sets scaling for the texture\'s X, Y and Z sizes"'
|
||||
TextureSlot.stencil -> use_stencil: boolean "'Use this texture as a blending value on the next texture'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.frame_current -> frame_current: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.grid -> grid: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeAudioWindow.window_sliders -> window_sliders: float "'NO DESCRIPTION'"
|
||||
ThemeBoneColorSet.active -> active: float "'Color used for active bones'"
|
||||
ThemeBoneColorSet.colored_constraints -> show_colored_constraints: boolean "'Allow the use of colors indicating constraints/keyed status'"
|
||||
ThemeBoneColorSet.normal -> normal: float "'Color used for the surface of bones'"
|
||||
ThemeBoneColorSet.select -> select: float "'Color used for selected bones'"
|
||||
ThemeConsole.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.cursor -> cursor: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.line_error -> line_error: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.line_info -> line_info: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.line_input -> line_input: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.line_output -> line_output: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeConsole.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.active_channels_group -> active_channels_group: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.channel_group -> channel_group: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.channels -> channels: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.channels_selected -> channels_selected: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.dopesheet_channel -> dopesheet_channel: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.dopesheet_subchannel -> dopesheet_subchannel: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.frame_current -> frame_current: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.grid -> grid: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.list -> list: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.list_text -> list_text: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.list_text_hi -> list_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.list_title -> list_title: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.long_key -> long_key: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.long_key_selected -> long_key_selected: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.value_sliders -> value_sliders: float "'NO DESCRIPTION'"
|
||||
ThemeDopeSheet.view_sliders -> view_sliders: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.active_file -> active_file: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.active_file_text -> active_file_text: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.list -> list: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.list_text -> list_text: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.list_text_hi -> list_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.list_title -> list_title: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.scroll_handle -> scroll_handle: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.scrollbar -> scrollbar: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.selected_file -> selected_file: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.tiles -> tiles: float "'NO DESCRIPTION'"
|
||||
ThemeFileBrowser.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeFontStyle.font_kerning_style -> font_kerning_style: enum "'Which style to use for font kerning'"
|
||||
ThemeFontStyle.points -> points: int "'NO DESCRIPTION'"
|
||||
ThemeFontStyle.shadow -> shadow: int "'Shadow size in pixels (0, 3 and 5 supported)'"
|
||||
ThemeFontStyle.shadowalpha -> shadowalpha: float "'NO DESCRIPTION'"
|
||||
ThemeFontStyle.shadowcolor -> shadowcolor: float "'Shadow color in grey value'"
|
||||
ThemeFontStyle.shadx -> shadow_offset_x: int "'Shadow offset in pixels'"
|
||||
ThemeFontStyle.shady -> shadow_offset_y: int "'Shadow offset in pixels'"
|
||||
ThemeGraphEditor.active_channels_group -> active_channels_group: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.channel_group -> channel_group: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.channels_region -> channels_region: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.dopesheet_channel -> dopesheet_channel: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.dopesheet_subchannel -> dopesheet_subchannel: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.frame_current -> frame_current: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.grid -> grid: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_align -> handle_align: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_auto -> handle_auto: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_free -> handle_free: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_sel_align -> handle_sel_align: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_sel_auto -> handle_sel_auto: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_sel_free -> handle_sel_free: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_sel_vect -> handle_sel_vect: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_vect -> handle_vect: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_vertex -> handle_vertex: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_vertex_select -> handle_vertex_select: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.handle_vertex_size -> handle_vertex_size: int "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.lastsel_point -> lastsel_point: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.list -> list: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.list_text -> list_text: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.list_text_hi -> list_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.list_title -> list_title: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.panel -> panel: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.vertex -> vertex: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.vertex_select -> vertex_select: float "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.vertex_size -> vertex_size: int "'NO DESCRIPTION'"
|
||||
ThemeGraphEditor.window_sliders -> window_sliders: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.editmesh_active -> editmesh_active: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.face -> face: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.face_dot -> face_dot: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.face_select -> face_select: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.facedot_size -> facedot_size: int "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.scope_back -> scope_back: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.vertex -> vertex: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.vertex_select -> vertex_select: float "'NO DESCRIPTION'"
|
||||
ThemeImageEditor.vertex_size -> vertex_size: int "'NO DESCRIPTION'"
|
||||
ThemeInfo.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeInfo.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.panel -> panel: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeLogicEditor.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.bars -> bars: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.bars_selected -> bars_selected: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.frame_current -> frame_current: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.grid -> grid: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.list -> list: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.list_text -> list_text: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.list_text_hi -> list_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.list_title -> list_title: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.strips -> strips: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.strips_selected -> strips_selected: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeNLAEditor.view_sliders -> view_sliders: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.converter_node -> converter_node: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.group_node -> group_node: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.in_out_node -> in_out_node: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.list -> list: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.list_text -> list_text: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.list_text_hi -> list_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.list_title -> list_title: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.node_backdrop -> node_backdrop: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.operator_node -> operator_node: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.selected_text -> selected_text: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.wire_select -> wire_select: float "'NO DESCRIPTION'"
|
||||
ThemeNodeEditor.wires -> wires: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeOutliner.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.panel -> panel: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeProperties.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.audio_strip -> audio_strip: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.draw_action -> draw_action: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.effect_strip -> effect_strip: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.frame_current -> frame_current: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.grid -> grid: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.image_strip -> image_strip: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.keyframe -> keyframe: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.meta_strip -> meta_strip: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.movie_strip -> movie_strip: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.plugin_strip -> plugin_strip: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.scene_strip -> scene_strip: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.transition_strip -> transition_strip: float "'NO DESCRIPTION'"
|
||||
ThemeSequenceEditor.window_sliders -> window_sliders: float "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.cursor -> cursor: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.line_numbers_background -> line_numbers_background: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.scroll_bar -> scroll_bar: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.selected_text -> selected_text: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.syntax_builtin -> syntax_builtin: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.syntax_comment -> syntax_comment: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.syntax_numbers -> syntax_numbers: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.syntax_special -> syntax_special: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.syntax_string -> syntax_string: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeTextEditor.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.frame_current -> frame_current: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.grid -> grid: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeTimeline.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeUserInterface.icon_file -> icon_file: string "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeUserPreferences.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.act_spline -> act_spline: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.back -> back: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.bone_pose -> bone_pose: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.bone_solid -> bone_solid: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.button -> button: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.button_text -> button_text: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.button_text_hi -> button_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.button_title -> button_title: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.edge_crease -> edge_crease: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.edge_facesel -> edge_facesel: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.edge_seam -> edge_seam: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.edge_select -> edge_select: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.edge_sharp -> edge_sharp: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.editmesh_active -> editmesh_active: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.face -> face: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.face_dot -> face_dot: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.face_select -> face_select: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.facedot_size -> facedot_size: int "'NO DESCRIPTION'"
|
||||
ThemeView3D.frame_current -> frame_current: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.grid -> grid: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.handle_align -> handle_align: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.handle_auto -> handle_auto: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.handle_free -> handle_free: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.handle_sel_align -> handle_sel_align: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.handle_sel_auto -> handle_sel_auto: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.handle_sel_free -> handle_sel_free: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.handle_sel_vect -> handle_sel_vect: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.handle_vect -> handle_vect: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.header -> header: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.header_text -> header_text: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.header_text_hi -> header_text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.lamp -> lamp: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.lastsel_point -> lastsel_point: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.normal -> normal: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.nurb_sel_uline -> nurb_sel_uline: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.nurb_sel_vline -> nurb_sel_vline: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.nurb_uline -> nurb_uline: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.nurb_vline -> nurb_vline: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.object_active -> object_active: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.object_grouped -> object_grouped: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.object_grouped_active -> object_grouped_active: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.object_selected -> object_selected: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.panel -> panel: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.text_hi -> text_hi: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.title -> title: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.transform -> transform: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.vertex -> vertex: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.vertex_normal -> vertex_normal: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.vertex_select -> vertex_select: float "'NO DESCRIPTION'"
|
||||
ThemeView3D.vertex_size -> vertex_size: int "'NO DESCRIPTION'"
|
||||
ThemeView3D.wire -> wire: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.inner -> inner: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.inner_sel -> inner_sel: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.item -> item: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.outline -> outline: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.shaded -> show_shaded: boolean "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.shadedown -> shadedown: int "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.shadetop -> shadetop: int "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.text -> text: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetColors.text_sel -> text_sel: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetStateColors.blend -> blend: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetStateColors.inner_anim -> inner_anim: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetStateColors.inner_anim_sel -> inner_anim_sel: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetStateColors.inner_driven -> inner_driven: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetStateColors.inner_driven_sel -> inner_driven_sel: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetStateColors.inner_key -> inner_key: float "'NO DESCRIPTION'"
|
||||
ThemeWidgetStateColors.inner_key_sel -> inner_key_sel: float "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
TimelineMarker.select -> select: boolean "'Marker selection state'"
|
||||
ToolSettings.auto_normalize -> use_auto_normalize: boolean "'Ensure all bone-deforming vertex groups add up to 1.0 while weight painting'"
|
||||
ToolSettings.autokey_mode -> autokey_mode: enum "'Mode of automatic keyframe insertion for Objects and Bones'"
|
||||
ToolSettings.automerge_editing -> use_automerge_editing: boolean "'Automatically merge vertices moved to the same location'"
|
||||
ToolSettings.bone_sketching -> use_bone_sketching: boolean "'DOC BROKEN'"
|
||||
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_autoname -> use_etch_autoname: boolean "'DOC BROKEN'"
|
||||
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_overdraw -> use_etch_overdraw: boolean "'DOC BROKEN'"
|
||||
ToolSettings.etch_quick -> use_etch_quick: boolean "'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.mesh_selection_mode -> mesh_selection_mode: boolean "'Which mesh elements selection works on'"
|
||||
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_edit: enum "'Proportional editing mode'"
|
||||
ToolSettings.proportional_editing_falloff -> proportional_edit_falloff: enum "'Falloff type for proportional editing mode'"
|
||||
ToolSettings.proportional_editing_objects -> proportional_editing_objects: boolean "'Proportional editing object mode'"
|
||||
ToolSettings.record_with_nla -> use_record_with_nla: boolean "'Add a new NLA Track + Strip for every loop/pass made over the animation to allow non-destructive tweaking'"
|
||||
ToolSettings.sculpt -> sculpt: pointer, "'(read-only)'"
|
||||
ToolSettings.sculpt_paint_use_unified_size -> sculpt_paint_use_unified_size: boolean "'Instead of per brush radius, the radius is shared across brushes'"
|
||||
ToolSettings.sculpt_paint_use_unified_strength -> sculpt_paint_use_unified_strength: boolean "'Instead of per brush strength, the strength is shared across brushes'"
|
||||
ToolSettings.snap -> use_snap: boolean "'Snap during transform'"
|
||||
ToolSettings.snap_align_rotation -> use_snap_align_rotation: boolean "'Align rotation with the snapping target'"
|
||||
ToolSettings.snap_element -> snap_element: enum "'Type of element to snap to'"
|
||||
ToolSettings.snap_peel_object -> use_snap_peel_object: boolean "'Consider objects as whole when finding volume center'"
|
||||
ToolSettings.snap_project -> use_snap_project: boolean "'Project vertices on the surface of other objects'"
|
||||
ToolSettings.snap_target -> snap_target: enum "'Which part to snap onto the target'"
|
||||
ToolSettings.use_auto_keying -> use_keyframe_insert_auto: boolean "'Automatic keyframe insertion for Objects and Bones'"
|
||||
ToolSettings.uv_local_view -> show_local_view: boolean "'Draw only faces with the currently displayed image assigned'"
|
||||
ToolSettings.uv_selection_mode -> uv_selection_mode: enum "'UV selection and display mode'"
|
||||
ToolSettings.uv_sync_selection -> use_uv_sync_selection: boolean "'Keep UV and edit mode mesh selection in sync'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
TrackToConstraint.target -> target: pointer "'Target Object'"
|
||||
TrackToConstraint.target_z -> use_target_z: boolean '"Target\'s Z axis, not World Z axis, will constraint the Up direction"'
|
||||
TrackToConstraint.track -> track: enum "'Axis that points to the target object'"
|
||||
TrackToConstraint.up -> up: enum "'Axis that points upward'"
|
||||
TransformConstraint.extrapolate_motion -> use_motion_extrapolate: boolean "'Extrapolate ranges'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
TransformOrientation.name -> name: string "'NO DESCRIPTION'"
|
||||
TransformSequence.interpolation -> interpolation: enum "'NO DESCRIPTION'"
|
||||
TransformSequence.rotation_start -> rotation_start: float "'NO DESCRIPTION'"
|
||||
TransformSequence.scale_start_x -> scale_start_x: float "'NO DESCRIPTION'"
|
||||
TransformSequence.scale_start_y -> scale_start_y: float "'NO DESCRIPTION'"
|
||||
TransformSequence.translate_start_x -> translate_start_x: float "'NO DESCRIPTION'"
|
||||
TransformSequence.translate_start_y -> translate_start_y: float "'NO DESCRIPTION'"
|
||||
TransformSequence.translation_unit -> translation_unit: enum "'NO DESCRIPTION'"
|
||||
TransformSequence.uniform_scale -> use_uniform_scale: boolean "'Scale uniformly, preserving aspect ratio'"
|
||||
UILayout.active -> show_active: boolean "'NO DESCRIPTION'"
|
||||
UILayout.alignment -> alignment: enum "'NO DESCRIPTION'"
|
||||
UILayout.enabled -> show_enabled: boolean "'NO DESCRIPTION'"
|
||||
UILayout.operator_context -> operator_context: enum "'NO DESCRIPTION'"
|
||||
UILayout.scale_x -> scale_x: float "'NO DESCRIPTION'"
|
||||
UILayout.scale_y -> scale_y: float "'NO DESCRIPTION'"
|
||||
UVProjectModifier.aspect_x -> aspect_x: float "'NO DESCRIPTION'"
|
||||
UVProjectModifier.aspect_y -> aspect_y: float "'NO DESCRIPTION'"
|
||||
UVProjectModifier.image -> image: pointer "'NO DESCRIPTION'"
|
||||
UVProjectModifier.num_projectors -> num_projectors: int "'Number of projectors to use'"
|
||||
UVProjectModifier.override_image -> use_image_override: boolean '"Override faces\' current images with the given image"'
|
||||
UVProjectModifier.projectors -> projectors: collection, "'(read-only)'"
|
||||
UVProjectModifier.scale_x -> scale_x: float "'NO DESCRIPTION'"
|
||||
UVProjectModifier.scale_y -> scale_y: float "'NO DESCRIPTION'"
|
||||
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'"
|
||||
UnitSettings.use_separate -> use_separate: boolean "'Display units in pairs'"
|
||||
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_keyframe_insert_available -> use_keyframe_insert_available: boolean "'Automatic keyframe insertion in available curves'"
|
||||
UserPreferencesEdit.auto_keyframe_insert_keyingset -> use_keyframe_insert_keyingset: boolean "'Automatic keyframe insertion using active Keying Set'"
|
||||
UserPreferencesEdit.auto_keying_mode -> auto_keying_mode: enum "'Mode of automatic keyframe insertion for Objects and Bones'"
|
||||
UserPreferencesEdit.drag_immediately -> use_drag_immediately: boolean "'Moving things with a mouse drag confirms when releasing the button'"
|
||||
UserPreferencesEdit.duplicate_action -> use_duplicate_action: boolean "'Causes actions to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_armature -> use_duplicate_armature: boolean "'Causes armature data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_curve -> use_duplicate_curve: boolean "'Causes curve data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_fcurve -> use_duplicate_fcurve: boolean "'Causes F-curve data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_lamp -> use_duplicate_lamp: boolean "'Causes lamp data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_material -> use_duplicate_material: boolean "'Causes material data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_mesh -> use_duplicate_mesh: boolean "'Causes mesh data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_metaball -> use_duplicate_metaball: boolean "'Causes metaball data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_particle -> use_duplicate_particle: boolean "'Causes particle systems to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_surface -> use_duplicate_surface: boolean "'Causes surface data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_text -> use_duplicate_text: boolean "'Causes text data to be duplicated with the object'"
|
||||
UserPreferencesEdit.duplicate_texture -> use_duplicate_texture: boolean "'Causes texture data to be duplicated with the object'"
|
||||
UserPreferencesEdit.enter_edit_mode -> use_enter_edit_mode: boolean "'Enter Edit Mode automatically after adding a new object'"
|
||||
UserPreferencesEdit.global_undo -> use_global_undo: boolean "'Global undo works by keeping a full copy of the file itself in memory, so takes extra memory'"
|
||||
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.grease_pencil_simplify_stroke -> use_grease_pencil_simplify_stroke: boolean "'Simplify the final stroke'"
|
||||
UserPreferencesEdit.grease_pencil_smooth_stroke -> use_grease_pencil_smooth_stroke: boolean "'Smooth the final stroke'"
|
||||
UserPreferencesEdit.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb: boolean "'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'"
|
||||
UserPreferencesEdit.keyframe_insert_needed -> use_keyframe_insert_needed: boolean "'Keyframe insertion only when keyframe needed'"
|
||||
UserPreferencesEdit.keyframe_new_handle_type -> keyframe_new_handle_type: enum "'NO DESCRIPTION'"
|
||||
UserPreferencesEdit.keyframe_new_interpolation_type -> keyframe_new_interpolation_type: enum "'NO DESCRIPTION'"
|
||||
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.sculpt_paint_overlay_col -> sculpt_paint_overlay_col: float "'Color of texture overlay'"
|
||||
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)'"
|
||||
UserPreferencesEdit.use_auto_keying -> use_auto_keying: boolean "'Automatic keyframe insertion for Objects and Bones'"
|
||||
UserPreferencesEdit.use_negative_frames -> use_negative_frames: boolean "'Current frame number can be manually set to a negative value'"
|
||||
UserPreferencesEdit.use_visual_keying -> use_visual_keying: boolean "'Use Visual keying automatically for constrained objects'"
|
||||
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_temporary_files -> use_auto_save_temporary_files: boolean "'Automatic saving of temporary files'"
|
||||
UserPreferencesFilePaths.auto_save_time -> auto_save_time: int "'The time (in minutes) to wait between automatic temporary saves'"
|
||||
UserPreferencesFilePaths.compress_file -> use_file_compression: boolean "'Enable file compression when saving .blend files'"
|
||||
UserPreferencesFilePaths.filter_file_extensions -> use_filter_files: boolean "'Display only files with extensions in the image select window'"
|
||||
UserPreferencesFilePaths.fonts_directory -> fonts_directory: string "'The default directory to search for loading fonts'"
|
||||
UserPreferencesFilePaths.hide_dot_files_datablocks -> show_hidden_files_datablocks: boolean "'Hide files/datablocks that start with a dot(.*)'"
|
||||
UserPreferencesFilePaths.image_editor -> image_editor: string "'Path to an image editor'"
|
||||
UserPreferencesFilePaths.load_ui -> use_load_ui: boolean "'Load user interface setup when loading .blend files'"
|
||||
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_preview_images -> use_save_preview_images: boolean "'Enables automatic saving of preview images in the .blend file'"
|
||||
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'"
|
||||
UserPreferencesFilePaths.use_relative_paths -> use_relative_paths: boolean "'Default relative path option for the file selector'"
|
||||
UserPreferencesInput.continuous_mouse -> use_continuous_mouse: boolean "'Allow moving the mouse outside the view on some manipulations (transform, ui control drag)'"
|
||||
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.emulate_3_button_mouse -> use_emulate_3_button_mouse: boolean '"Emulates Middle Mouse with Alt+LeftMouse (doesn\'t work with Left Mouse Select option)"'
|
||||
UserPreferencesInput.emulate_numpad -> use_emulate_numpad: boolean "'Causes the 1 to 0 keys to act as the numpad (useful for laptops)'"
|
||||
UserPreferencesInput.invert_zoom_direction -> invert_mouse_wheel_zoom: boolean "'Invert the axis of mouse movement for zooming'"
|
||||
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.use_middle_mouse_paste -> use_mouse_mmb_paste: boolean "'In text window, paste with middle mouse button instead of panning'"
|
||||
UserPreferencesInput.view_rotation -> view_rotation: enum "'Rotation style in the viewport'"
|
||||
UserPreferencesInput.wheel_invert_zoom -> wheel_invert_zoom: boolean "'Swap the Mouse Wheel zoom direction'"
|
||||
UserPreferencesInput.wheel_scroll_lines -> wheel_scroll_lines: int "'The number of lines scrolled at a time with the mouse wheel'"
|
||||
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.auto_execute_scripts -> use_scripts_auto_execute: boolean "'Allow any .blend file to run scripts automatically (unsafe with blend files from an untrusted source)'"
|
||||
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.enable_all_codecs -> use_preview_images: boolean "'Enables automatic saving of preview images in the .blend file (Windows only)'"
|
||||
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.international_fonts -> use_international_fonts: boolean "'Use international fonts'"
|
||||
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.tabs_as_spaces -> use_tabs_as_spaces: boolean "'Automatically converts all new tabs into spaces for new and loaded text files'"
|
||||
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.translate_buttons -> use_translate_buttons: boolean "'Translate button labels'"
|
||||
UserPreferencesSystem.translate_toolbox -> use_translate_toolbox: boolean "'Translate toolbox menu'"
|
||||
UserPreferencesSystem.translate_tooltips -> use_translate_tooltips: boolean "'Translate Tooltips'"
|
||||
UserPreferencesSystem.use_antialiasing -> use_antialiasing: boolean "'Use anti-aliasing for the 3D view (may impact redraw performance)'"
|
||||
UserPreferencesSystem.use_mipmaps -> use_mipmaps: boolean "'Scale textures for the 3D View (looks nicer but uses more memory and slows image reloading)'"
|
||||
UserPreferencesSystem.use_textured_fonts -> use_textured_fonts: boolean "'Use textures for drawing international fonts'"
|
||||
UserPreferencesSystem.use_vbos -> use_vertex_buffer_objects: boolean "'Use Vertex Buffer Objects (or Vertex Arrays, if unsupported) for viewport rendering'"
|
||||
UserPreferencesSystem.use_weight_color_range -> use_weight_color_range: boolean "'Enable color range used for weight visualization in weight painting mode'"
|
||||
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.auto_depth -> use_mouse_auto_depth: boolean "'Use the depth under the mouse to improve view pan/rotate/zoom functionality'"
|
||||
UserPreferencesView.auto_perspective -> use_auto_perspective: boolean "'Automatically switch between orthographic and perspective when changing from top/front/side views'"
|
||||
UserPreferencesView.directional_menus -> use_directional_menus: boolean "'Otherwise menus, etc will always be top to bottom, left to right, no matter opening direction'"
|
||||
UserPreferencesView.display_object_info -> show_object_info: boolean "'Display objects name and frame number in 3D view'"
|
||||
UserPreferencesView.global_pivot -> use_global_pivot: boolean "'Lock the same rotation/scaling pivot in all 3D Views'"
|
||||
UserPreferencesView.global_scene -> use_global_scene: boolean "'Forces the current Scene to be displayed in all Screens'"
|
||||
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_mouse_over -> use_mouse_over_open: boolean "'Open menu buttons and pulldowns automatically when the mouse is hovering'"
|
||||
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.rotate_around_selection -> use_rotate_around_selection: boolean "'Use selection as the pivot point'"
|
||||
UserPreferencesView.rotation_angle -> rotation_angle: int "'The rotation step for numerical pad keys (2 4 6 8)'"
|
||||
UserPreferencesView.show_mini_axis -> show_mini_axis: boolean "'Show a small rotating 3D axis in the bottom left corner of the 3D View'"
|
||||
UserPreferencesView.show_playback_fps -> show_playback_fps: boolean "'Show the frames per second screen refresh rate, while animation is played back'"
|
||||
UserPreferencesView.show_splash -> show_splash: boolean "'Display splash screen on startup'"
|
||||
UserPreferencesView.show_view_name -> show_view_name: boolean '"Show the name of the view\'s direction in each 3D View"'
|
||||
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.tooltips -> show_tooltips: boolean "'Display tooltips'"
|
||||
UserPreferencesView.use_column_layout -> show_column_layout: boolean "'Use a column layout for toolbox'"
|
||||
UserPreferencesView.use_large_cursors -> show_large_cursors: boolean "'Use large mouse cursors when available'"
|
||||
UserPreferencesView.use_manipulator -> show_manipulator: boolean "'Use 3D transform manipulator'"
|
||||
UserPreferencesView.view2d_grid_minimum_spacing -> view2d_grid_spacing_min: int "'Minimum number of pixels between each gridline in 2D Viewports'"
|
||||
UserPreferencesView.zoom_to_mouse -> use_zoom_to_mouse: boolean '"Zoom in towards the mouse pointer\'s position in the 3D view, rather than the 2D window center"'
|
||||
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.enabled -> use: boolean "'Enable this OpenGL light in solid draw mode'"
|
||||
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'"
|
||||
VertexPaint.all_faces -> use_all_faces: boolean "'Paint on all faces inside brush'"
|
||||
VertexPaint.normals -> use_normal: boolean "'Applies the vertex normal before painting'"
|
||||
VertexPaint.spray -> use_spray: boolean "'Keep applying paint effect while holding mouse'"
|
||||
VisibilityActuator.children -> apply_to_children: boolean "'Set all the children of this object to the same visibility/occlusion recursively'"
|
||||
VisibilityActuator.occlusion -> use_occlusion: boolean "'Set the object to occlude objects behind it. Initialized from the object type in physics button'"
|
||||
VisibilityActuator.visible -> use_visible: boolean "'Set the objects visible. Initialized from the objects render restriction toggle (access in the outliner)'"
|
||||
VoronoiTexture.coloring -> color_mode: enum "'NO DESCRIPTION'"
|
||||
VoronoiTexture.distance_metric -> distance_metric: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 -> use_still_frame: boolean "'Always render a still frame from the voxel data sequence'"
|
||||
VoxelData.still_frame_number -> still_frame_number: int "'The frame number to always use'"
|
||||
VoxelDataTexture.image -> image: pointer "'NO DESCRIPTION'"
|
||||
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.cyclic -> use_cyclic: boolean "'Cyclic wave effect'"
|
||||
WaveModifier.damping_time -> damping_time: float "'NO DESCRIPTION'"
|
||||
WaveModifier.falloff_radius -> falloff_radius: float "'NO DESCRIPTION'"
|
||||
WaveModifier.height -> height: float "'NO DESCRIPTION'"
|
||||
WaveModifier.lifetime -> lifetime: float "'NO DESCRIPTION'"
|
||||
WaveModifier.narrowness -> narrowness: float "'NO DESCRIPTION'"
|
||||
WaveModifier.normals -> use_normal: boolean "'Displace along normal'"
|
||||
WaveModifier.speed -> speed: float "'NO DESCRIPTION'"
|
||||
WaveModifier.start_position_object -> start_position_object: pointer "'NO DESCRIPTION'"
|
||||
WaveModifier.start_position_x -> start_position_x: float "'NO DESCRIPTION'"
|
||||
WaveModifier.start_position_y -> start_position_y: float "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
WaveModifier.x -> use_x: boolean "'X axis motion'"
|
||||
WaveModifier.x_normal -> use_normal_x: boolean "'Enable displacement along the X normal'"
|
||||
WaveModifier.y -> use_y: boolean "'Y axis motion'"
|
||||
WaveModifier.y_normal -> use_normal_y: boolean "'Enable displacement along the Y normal'"
|
||||
WaveModifier.z_normal -> use_normal_z: boolean "'Enable displacement along the Z normal'"
|
||||
Window.screen -> screen: pointer "'Active screen showing in the window'"
|
||||
WindowManager.active_keyconfig -> active_keyconfig: pointer "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
WoodTexture.noisebasis2 -> noisebasis2: enum "'NO DESCRIPTION'"
|
||||
WoodTexture.stype -> stype: enum "'NO DESCRIPTION'"
|
||||
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 "'NO DESCRIPTION'"
|
||||
World.animation_data -> animation_data: pointer, "'(read-only) Animation data for this datablock'"
|
||||
World.blend_sky -> use_sky_blend: boolean "'Render background with natural progression from horizon to zenith'"
|
||||
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.paper_sky -> use_sky_paper: boolean "'Flatten blend or texture coordinates'"
|
||||
World.range -> range: float "'The color range that will be mapped to 0-1'"
|
||||
World.real_sky -> use_sky_real: boolean "'Render background with a real horizon, relative to the camera angle'"
|
||||
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_type: 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 -> use_falloff: boolean "'NO DESCRIPTION'"
|
||||
WorldLighting.falloff_strength -> falloff_strength: float '"Distance attenuation factor, the higher, the \'shorter\' the shadows"'
|
||||
WorldLighting.gather_method -> gather_method: enum "'NO DESCRIPTION'"
|
||||
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.pixel_cache -> use_cache: boolean "'Cache AO results in pixels and interpolate over neighbouring pixels for speedup (for Approximate)'"
|
||||
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)'"
|
||||
WorldLighting.use_ambient_occlusion -> use_ambient_occlusian: boolean "'Use Ambient Occlusion to add shadowing based on distance between objects'"
|
||||
WorldLighting.use_environment_lighting -> use_environment_lighting: boolean "'Add light coming from the environment'"
|
||||
WorldLighting.use_indirect_lighting -> use_indirect_lighting: boolean "'Add indirect light bouncing of surrounding objects'"
|
||||
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'"
|
||||
WorldMistSettings.use_mist -> use_mist: boolean "'Occlude objects with the environment color as they are further away'"
|
||||
WorldStarsSettings.average_separation -> average_separation: float "'Average distance between any two stars'"
|
||||
WorldStarsSettings.color_randomization -> color_randomization: float "'Randomize star colors'"
|
||||
WorldStarsSettings.min_distance -> distance_min: float "'Minimum distance to the camera for stars'"
|
||||
WorldStarsSettings.size -> size: float "'Average screen dimension of stars'"
|
||||
WorldStarsSettings.use_stars -> use_stars: boolean "'Enable starfield generation'"
|
||||
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.map_blend -> use_map_blend: boolean "'Affect the color progression of the background'"
|
||||
WorldTextureSlot.map_horizon -> use_map_horizon: boolean "'Affect the color of the horizon'"
|
||||
WorldTextureSlot.map_zenith_down -> use_map_zenith_down: boolean "'Affect the color of the zenith below'"
|
||||
WorldTextureSlot.map_zenith_up -> use_map_zenith_up: boolean "'Affect the color of the zenith above'"
|
||||
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'"
|
||||
|
||||
Reference in New Issue
Block a user