diff --git a/bbp_ng/UTIL_translation.py b/bbp_ng/UTIL_translation.py index 930d899..5c2d646 100644 --- a/bbp_ng/UTIL_translation.py +++ b/bbp_ng/UTIL_translation.py @@ -81,7 +81,4685 @@ def build_prototype_showcase_cfg_context(identifier: str, cfg_index: int) -> str # Tuple of tuples: # ((msgctxt, msgid), (sources, gen_comments), (lang, translation, (is_fuzzy, comments)), ...) -translations_tuple = () +translations_tuple = ( + (("*", ""), + ((), ()), + ("zh_HANS", "Project-Id-Version: Ballance Blender Plugin 4.1.0 (0)\n", + (False, ("FIRST AUTHOR , YEAR.",))), + ), + (("BBPPreferences/property", "Ballance Texture Folder"), + (("bpy.types.BBPPreferences.ballance_texture_folder",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The path to folder which will be used by this plugin to get external Ballance texture."), + (("bpy.types.BBPPreferences.ballance_texture_folder",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBPPreferences/property", "No Component Collection"), + (("bpy.types.BBPPreferences.no_component_collection",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "When importing, it is the name of collection where objects store will not be saved as component. When exporting, all forced no component objects will be stored in this name represented collection"), + (("bpy.types.BBPPreferences.no_component_collection",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Ballance Floor"), + (("bpy.types.BBP_MT_AddBmeMenu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddBmeMenu", "Floors"), + (("bpy.types.BBP_MT_AddBmeMenu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Ballance Component"), + (("bpy.types.BBP_MT_AddComponentsMenu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddComponentsMenu", "Components"), + (("bpy.types.BBP_MT_AddComponentsMenu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Ballance Rail"), + (("bpy.types.BBP_MT_AddRailMenu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddRailMenu", "Rails"), + (("bpy.types.BBP_MT_AddRailMenu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Ballance 3D related operators"), + (("bpy.types.BBP_MT_View3DMenu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_View3DMenu", "Ballance"), + (("bpy.types.BBP_MT_View3DMenu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_arc_rail", "Arc Rail"), + (("bpy.types.BBP_OT_add_arc_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Arc Rail"), + (("bpy.types.BBP_OT_add_arc_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedExtraTransform/property", "Extra Rotation"), + (("bpy.types.BBP_OT_add_arc_rail.extra_rotation", + "bpy.types.BBP_OT_add_side_rail.extra_rotation", + "bpy.types.BBP_OT_add_side_spiral_rail.extra_rotation", + "bpy.types.BBP_OT_add_spiral_rail.extra_rotation", + "bpy.types.BBP_OT_add_straight_rail.extra_rotation", + "bpy.types.BBP_OT_add_transition_rail.extra_rotation"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The extra rotation applied to object after moving to cursor."), + (("bpy.types.BBP_OT_add_arc_rail.extra_rotation", + "bpy.types.BBP_OT_add_bme_struct.extra_rotation", + "bpy.types.BBP_OT_add_side_rail.extra_rotation", + "bpy.types.BBP_OT_add_side_spiral_rail.extra_rotation", + "bpy.types.BBP_OT_add_spiral_rail.extra_rotation", + "bpy.types.BBP_OT_add_straight_rail.extra_rotation", + "bpy.types.BBP_OT_add_transition_rail.extra_rotation"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedExtraTransform/property", "Extra Translation"), + (("bpy.types.BBP_OT_add_arc_rail.extra_translation", + "bpy.types.BBP_OT_add_side_rail.extra_translation", + "bpy.types.BBP_OT_add_side_spiral_rail.extra_translation", + "bpy.types.BBP_OT_add_spiral_rail.extra_translation", + "bpy.types.BBP_OT_add_straight_rail.extra_translation", + "bpy.types.BBP_OT_add_transition_rail.extra_translation"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The extra translation applied to object after moving to cursor."), + (("bpy.types.BBP_OT_add_arc_rail.extra_translation", + "bpy.types.BBP_OT_add_bme_struct.extra_translation", + "bpy.types.BBP_OT_add_side_rail.extra_translation", + "bpy.types.BBP_OT_add_side_spiral_rail.extra_translation", + "bpy.types.BBP_OT_add_spiral_rail.extra_translation", + "bpy.types.BBP_OT_add_straight_rail.extra_translation", + "bpy.types.BBP_OT_add_transition_rail.extra_translation"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedRailCapInputProperty/property", "End Cap"), + (("bpy.types.BBP_OT_add_arc_rail.rail_end_cap", + "bpy.types.BBP_OT_add_side_rail.rail_end_cap", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_end_cap", + "bpy.types.BBP_OT_add_spiral_rail.rail_end_cap", + "bpy.types.BBP_OT_add_straight_rail.rail_end_cap", + "bpy.types.BBP_OT_add_transition_rail.rail_end_cap"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether this rail should have cap at end terminal."), + (("bpy.types.BBP_OT_add_arc_rail.rail_end_cap", + "bpy.types.BBP_OT_add_side_rail.rail_end_cap", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_end_cap", + "bpy.types.BBP_OT_add_spiral_rail.rail_end_cap", + "bpy.types.BBP_OT_add_straight_rail.rail_end_cap", + "bpy.types.BBP_OT_add_transition_rail.rail_end_cap"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_arc_rail/property", "Angle"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_angle",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The angle of this arc rail rotated."), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_angle",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedScrewRailInputProperty/property", "Flip X"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_flip_x", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_flip_x", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_flip_x"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether flip this rail with X axis"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_flip_x", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_flip_x", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_flip_x"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedScrewRailInputProperty/property", "Flip Y"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_flip_y", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_flip_y", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_flip_y"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether flip this rail with Y axis"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_flip_y", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_flip_y", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_flip_y"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedScrewRailInputProperty/property", "Flip Z"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_flip_z", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_flip_z", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_flip_z"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether flip this rail with Z axis"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_flip_z", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_flip_z", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_flip_z"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedScrewRailInputProperty/property", "Radius"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_radius", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_radius", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_radius"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The screw radius."), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_radius", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_radius", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_radius"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedScrewRailInputProperty/property", "Steps"), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_steps", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_steps", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_steps"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The segment count per iteration. More segment, more smooth but lower performance."), + (("bpy.types.BBP_OT_add_arc_rail.rail_screw_steps", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_steps", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_steps"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedRailCapInputProperty/property", "Start Cap"), + (("bpy.types.BBP_OT_add_arc_rail.rail_start_cap", + "bpy.types.BBP_OT_add_side_rail.rail_start_cap", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_start_cap", + "bpy.types.BBP_OT_add_spiral_rail.rail_start_cap", + "bpy.types.BBP_OT_add_straight_rail.rail_start_cap", + "bpy.types.BBP_OT_add_transition_rail.rail_start_cap"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether this rail should have cap at start terminal."), + (("bpy.types.BBP_OT_add_arc_rail.rail_start_cap", + "bpy.types.BBP_OT_add_side_rail.rail_start_cap", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_start_cap", + "bpy.types.BBP_OT_add_spiral_rail.rail_start_cap", + "bpy.types.BBP_OT_add_straight_rail.rail_start_cap", + "bpy.types.BBP_OT_add_transition_rail.rail_start_cap"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedRailSectionInputProperty/property", "Type"), + (("bpy.types.BBP_OT_add_arc_rail.rail_type", + "bpy.types.BBP_OT_add_rail_section.rail_type", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_type", + "bpy.types.BBP_OT_add_straight_rail.rail_type"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Rail type"), + (("bpy.types.BBP_OT_add_arc_rail.rail_type", + "bpy.types.BBP_OT_add_rail_section.rail_type", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_type", + "bpy.types.BBP_OT_add_straight_rail.rail_type"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedRailSectionInputProperty/property", "Monorail"), + (("bpy.types.BBP_OT_add_arc_rail.rail_type:'MONORAIL'", + "bpy.types.BBP_OT_add_rail_section.rail_type:'MONORAIL'", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_type:'MONORAIL'", + "bpy.types.BBP_OT_add_straight_rail.rail_type:'MONORAIL'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedRailSectionInputProperty/property", "Rail"), + (("bpy.types.BBP_OT_add_arc_rail.rail_type:'RAIL'", + "bpy.types.BBP_OT_add_rail_section.rail_type:'RAIL'", + "bpy.types.BBP_OT_add_side_spiral_rail.rail_type:'RAIL'", + "bpy.types.BBP_OT_add_straight_rail.rail_type:'RAIL'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct", "Add BME Structure"), + (("bpy.types.BBP_OT_add_bme_struct",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add BME structure"), + (("bpy.types.BBP_OT_add_bme_struct",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Configurations"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_cfgs",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The collection holding BME structure configurations."), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_cfgs",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Type"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The type of BME structure."), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal 1x1"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_1x1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink 1x1"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_1x1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal Border"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_border'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink Border"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_border'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Ribbon Border"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_ribbon_border'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal Inner Corner"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_inner_corner'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink Inner Corner"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_inner_corner'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Ribbon Inner Corner"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_ribbon_inner_corner'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal Outter Corner"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_outter_corner'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink Outter Corner"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_outter_corner'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Ribbon Outter Corner"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_ribbon_outter_corner'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal L Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_l_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink L Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_l_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal T Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_t_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink T Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_t_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal X Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_x_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink X Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_x_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Flat"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_flat'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal Platform"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_platform'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink Platform"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_platform'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Ribbon Platform"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_ribbon_platform'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal Floor"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_straight'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink Floor"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_straight'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Normal Floor Terminal"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_normal_terminal'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Sink Floor Terminal"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_sink_terminal'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Wood Trafo"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'wood_trafo'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Stone Trafo"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'stone_trafo'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Paper Trafo"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'paper_trafo'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Transition"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_transition'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Narrow Transition"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_narrow_transition'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Wide Floor"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_wide_straight'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Wide Floor Terminal"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_wide_terminal'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Wide Floor L Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_wide_l_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Wide Floor T Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_wide_t_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Wide Floor X Crossing"), + (("bpy.types.BBP_OT_add_bme_struct.bme_struct_type:'floor_wide_x_crossing'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Extra Rotation"), + (("bpy.types.BBP_OT_add_bme_struct.extra_rotation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/property", "Extra Translation"), + (("bpy.types.BBP_OT_add_bme_struct.extra_translation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component", "Add Component"), + (("bpy.types.BBP_OT_add_component",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add ordinary Component"), + (("bpy.types.BBP_OT_add_component",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_component.ComponentSectorParam/property", "Sector"), + (("bpy.types.BBP_OT_add_component.component_sector", + "bpy.types.BBP_OT_add_nong_extra_point.component_sector", + "bpy.types.BBP_OT_add_nong_ventilator.component_sector", + "bpy.types.BBP_OT_add_sector_component_pair.component_sector", + "bpy.types.BBP_OT_add_swing_series.component_sector", + "bpy.types.BBP_OT_add_tilting_block_series.component_sector", + "bpy.types.BBP_OT_add_ventilator_series.component_sector"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The sector which this component will be grouped in."), + (("bpy.types.BBP_OT_add_component.component_sector", + "bpy.types.BBP_OT_add_nong_extra_point.component_sector", + "bpy.types.BBP_OT_add_nong_ventilator.component_sector", + "bpy.types.BBP_OT_add_sector_component_pair.component_sector", + "bpy.types.BBP_OT_add_swing_series.component_sector", + "bpy.types.BBP_OT_add_tilting_block_series.component_sector", + "bpy.types.BBP_OT_add_ventilator_series.component_sector"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "Type"), + (("bpy.types.BBP_OT_add_component.component_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The type of this component."), + (("bpy.types.BBP_OT_add_component.component_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Extra_Life"), + (("bpy.types.BBP_OT_add_component.component_type:'0'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Extra_Point"), + (("bpy.types.BBP_OT_add_component.component_type:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Trafo_Paper"), + (("bpy.types.BBP_OT_add_component.component_type:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Trafo_Stone"), + (("bpy.types.BBP_OT_add_component.component_type:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Trafo_Wood"), + (("bpy.types.BBP_OT_add_component.component_type:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Ball_Paper"), + (("bpy.types.BBP_OT_add_component.component_type:'5'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Ball_Stone"), + (("bpy.types.BBP_OT_add_component.component_type:'6'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Ball_Wood"), + (("bpy.types.BBP_OT_add_component.component_type:'7'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Box"), + (("bpy.types.BBP_OT_add_component.component_type:'8'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Dome"), + (("bpy.types.BBP_OT_add_component.component_type:'9'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_01"), + (("bpy.types.BBP_OT_add_component.component_type:'10'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_03"), + (("bpy.types.BBP_OT_add_component.component_type:'11'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_08"), + (("bpy.types.BBP_OT_add_component.component_type:'12'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_17"), + (("bpy.types.BBP_OT_add_component.component_type:'13'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_18"), + (("bpy.types.BBP_OT_add_component.component_type:'14'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_19"), + (("bpy.types.BBP_OT_add_component.component_type:'15'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_25"), + (("bpy.types.BBP_OT_add_component.component_type:'16'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_26"), + (("bpy.types.BBP_OT_add_component.component_type:'17'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_29"), + (("bpy.types.BBP_OT_add_component.component_type:'18'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_30"), + (("bpy.types.BBP_OT_add_component.component_type:'19'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_34"), + (("bpy.types.BBP_OT_add_component.component_type:'20'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_37"), + (("bpy.types.BBP_OT_add_component.component_type:'21'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "P_Modul_41"), + (("bpy.types.BBP_OT_add_component.component_type:'22'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "PC_TwoFlames"), + (("bpy.types.BBP_OT_add_component.component_type:'23'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "PE_Balloon"), + (("bpy.types.BBP_OT_add_component.component_type:'24'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "PR_Resetpoint"), + (("bpy.types.BBP_OT_add_component.component_type:'25'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/property", "PS_FourFlames"), + (("bpy.types.BBP_OT_add_component.component_type:'26'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_ioport_encodings", "Add in Encodings List"), + (("bpy.types.BBP_OT_add_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add item at the tail of encodings list used by BMap for Virtools file read and write."), + (("bpy.types.BBP_OT_add_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_extra_point", "Nong Extra Point"), + (("bpy.types.BBP_OT_add_nong_extra_point",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Nong Extra Point"), + (("bpy.types.BBP_OT_add_nong_extra_point",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_component.ComponentCountParam/property", "Count"), + (("bpy.types.BBP_OT_add_nong_extra_point.component_count", + "bpy.types.BBP_OT_add_nong_ventilator.component_count", + "bpy.types.BBP_OT_add_swing_series.component_count", + "bpy.types.BBP_OT_add_tilting_block_series.component_count", + "bpy.types.BBP_OT_add_ventilator_series.component_count"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The count of components which you want to generate"), + (("bpy.types.BBP_OT_add_nong_extra_point.component_count", + "bpy.types.BBP_OT_add_nong_ventilator.component_count", + "bpy.types.BBP_OT_add_swing_series.component_count", + "bpy.types.BBP_OT_add_tilting_block_series.component_count", + "bpy.types.BBP_OT_add_ventilator_series.component_count"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator", "Nong Ventilator"), + (("bpy.types.BBP_OT_add_nong_ventilator",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Nong Ventilator"), + (("bpy.types.BBP_OT_add_nong_ventilator",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator/property", "Preset Count"), + (("bpy.types.BBP_OT_add_nong_ventilator.preset_vetilator_count",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Pick preset ventilator count."), + (("bpy.types.BBP_OT_add_nong_ventilator.preset_vetilator_count",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator/property", "Paper"), + (("bpy.types.BBP_OT_add_nong_ventilator.preset_vetilator_count:'PAPER'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The ventilator count (1) can push paper ball up."), + (("bpy.types.BBP_OT_add_nong_ventilator.preset_vetilator_count:'PAPER'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator/property", "Wood"), + (("bpy.types.BBP_OT_add_nong_ventilator.preset_vetilator_count:'WOOD'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The ventilator count (6) can push wood ball up."), + (("bpy.types.BBP_OT_add_nong_ventilator.preset_vetilator_count:'WOOD'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator/property", "Stone"), + (("bpy.types.BBP_OT_add_nong_ventilator.preset_vetilator_count:'STONE'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The ventilator count (32) can push stone ball up."), + (("bpy.types.BBP_OT_add_nong_ventilator.preset_vetilator_count:'STONE'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator/property", "Ventilator Count Source"), + (("bpy.types.BBP_OT_add_nong_ventilator.ventilator_count_source",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator/property", "Predefined"), + (("bpy.types.BBP_OT_add_nong_ventilator.ventilator_count_source:'DEFINED'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Pre-defined ventilator count."), + (("bpy.types.BBP_OT_add_nong_ventilator.ventilator_count_source:'DEFINED'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator/property", "Custom"), + (("bpy.types.BBP_OT_add_nong_ventilator.ventilator_count_source:'CUSTOM'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "User specified ventilator count."), + (("bpy.types.BBP_OT_add_nong_ventilator.ventilator_count_source:'CUSTOM'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_objects_virtools_group", "Grouping Objects"), + (("bpy.types.BBP_OT_add_objects_virtools_group",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Grouping Selected Objects"), + (("bpy.types.BBP_OT_add_objects_virtools_group",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/PROP_virtools_grourp.SharedGroupNameInputProperties/property", "Custom Group Name"), + (("bpy.types.BBP_OT_add_objects_virtools_group.custom_group_name", + "bpy.types.BBP_OT_add_virtools_groups.custom_group_name", + "bpy.types.BBP_OT_rm_objects_virtools_group.custom_group_name", + "bpy.types.BBP_OT_select_object_by_virtools_group.custom_group_name"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Input your custom group name."), + (("bpy.types.BBP_OT_add_objects_virtools_group.custom_group_name", + "bpy.types.BBP_OT_add_virtools_groups.custom_group_name", + "bpy.types.BBP_OT_rm_objects_virtools_group.custom_group_name", + "bpy.types.BBP_OT_select_object_by_virtools_group.custom_group_name"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/PROP_virtools_grourp.SharedGroupNameInputProperties/property", "Group Name Source"), + (("bpy.types.BBP_OT_add_objects_virtools_group.group_name_source", + "bpy.types.BBP_OT_add_virtools_groups.group_name_source", + "bpy.types.BBP_OT_rm_objects_virtools_group.group_name_source", + "bpy.types.BBP_OT_select_object_by_virtools_group.group_name_source"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/PROP_virtools_grourp.SharedGroupNameInputProperties/property", "Predefined"), + (("bpy.types.BBP_OT_add_objects_virtools_group.group_name_source:'DEFINED'", + "bpy.types.BBP_OT_add_virtools_groups.group_name_source:'DEFINED'", + "bpy.types.BBP_OT_rm_objects_virtools_group.group_name_source:'DEFINED'", + "bpy.types.BBP_OT_select_object_by_virtools_group.group_name_source:'DEFINED'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Pre-defined group name."), + (("bpy.types.BBP_OT_add_objects_virtools_group.group_name_source:'DEFINED'", + "bpy.types.BBP_OT_add_virtools_groups.group_name_source:'DEFINED'", + "bpy.types.BBP_OT_rm_objects_virtools_group.group_name_source:'DEFINED'", + "bpy.types.BBP_OT_select_object_by_virtools_group.group_name_source:'DEFINED'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/PROP_virtools_grourp.SharedGroupNameInputProperties/property", "Custom"), + (("bpy.types.BBP_OT_add_objects_virtools_group.group_name_source:'CUSTOM'", + "bpy.types.BBP_OT_add_virtools_groups.group_name_source:'CUSTOM'", + "bpy.types.BBP_OT_rm_objects_virtools_group.group_name_source:'CUSTOM'", + "bpy.types.BBP_OT_select_object_by_virtools_group.group_name_source:'CUSTOM'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "User specified group name."), + (("bpy.types.BBP_OT_add_objects_virtools_group.group_name_source:'CUSTOM'", + "bpy.types.BBP_OT_add_virtools_groups.group_name_source:'CUSTOM'", + "bpy.types.BBP_OT_rm_objects_virtools_group.group_name_source:'CUSTOM'", + "bpy.types.BBP_OT_select_object_by_virtools_group.group_name_source:'CUSTOM'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/PROP_virtools_grourp.SharedGroupNameInputProperties/property", "Group Name"), + (("bpy.types.BBP_OT_add_objects_virtools_group.preset_group_name", + "bpy.types.BBP_OT_add_virtools_groups.preset_group_name", + "bpy.types.BBP_OT_rm_objects_virtools_group.preset_group_name", + "bpy.types.BBP_OT_select_object_by_virtools_group.preset_group_name"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Pick vanilla Ballance group name."), + (("bpy.types.BBP_OT_add_objects_virtools_group.preset_group_name", + "bpy.types.BBP_OT_add_virtools_groups.preset_group_name", + "bpy.types.BBP_OT_rm_objects_virtools_group.preset_group_name", + "bpy.types.BBP_OT_select_object_by_virtools_group.preset_group_name"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_rail_section", "Rail Section"), + (("bpy.types.BBP_OT_add_rail_section",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Rail Section"), + (("bpy.types.BBP_OT_add_rail_section",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_sector_component_pair", "Sector Pair"), + (("bpy.types.BBP_OT_add_sector_component_pair",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Sector Pair, both check point and reset point."), + (("bpy.types.BBP_OT_add_sector_component_pair",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_side_rail", "Side Rail"), + (("bpy.types.BBP_OT_add_side_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Side Rail"), + (("bpy.types.BBP_OT_add_side_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedStraightRailInputProperty/property", "Length"), + (("bpy.types.BBP_OT_add_side_rail.rail_length", + "bpy.types.BBP_OT_add_straight_rail.rail_length", + "bpy.types.BBP_OT_add_transition_rail.rail_length"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The length of this rail."), + (("bpy.types.BBP_OT_add_side_rail.rail_length", + "bpy.types.BBP_OT_add_straight_rail.rail_length", + "bpy.types.BBP_OT_add_transition_rail.rail_length"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_side_rail/property", "Side Type"), + (("bpy.types.BBP_OT_add_side_rail.side_rail_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Side rail type"), + (("bpy.types.BBP_OT_add_side_rail.side_rail_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_side_rail/property", "Normal"), + (("bpy.types.BBP_OT_add_side_rail.side_rail_type:'NORMAL'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The normal side rail."), + (("bpy.types.BBP_OT_add_side_rail.side_rail_type:'NORMAL'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_side_rail/property", "Stone Specific"), + (("bpy.types.BBP_OT_add_side_rail.side_rail_type:'STONE'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The side rail which also allow stone ball passed."), + (("bpy.types.BBP_OT_add_side_rail.side_rail_type:'STONE'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_side_spiral_rail", "Side Spiral Rail"), + (("bpy.types.BBP_OT_add_side_spiral_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Side Spiral Rail"), + (("bpy.types.BBP_OT_add_side_spiral_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_side_spiral_rail/property", "Iterations"), + (("bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_iterations",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Indicate how many layers of this spiral rail should be generated."), + (("bpy.types.BBP_OT_add_side_spiral_rail.rail_screw_iterations", + "bpy.types.BBP_OT_add_spiral_rail.rail_screw_iterations"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_spiral_rail", "Spiral Rail"), + (("bpy.types.BBP_OT_add_spiral_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Spiral Rail"), + (("bpy.types.BBP_OT_add_spiral_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_spiral_rail/property", "Iterations"), + (("bpy.types.BBP_OT_add_spiral_rail.rail_screw_iterations",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_spiral_rail/property", "Screw"), + (("bpy.types.BBP_OT_add_spiral_rail.rail_screw_screw",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The increased height in each iteration. Minus height also is accepted."), + (("bpy.types.BBP_OT_add_spiral_rail.rail_screw_screw",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_straight_rail", "Straight Rail"), + (("bpy.types.BBP_OT_add_straight_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Straight Rail"), + (("bpy.types.BBP_OT_add_straight_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_swing_series", "Swing Series"), + (("bpy.types.BBP_OT_add_swing_series",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Swing Series"), + (("bpy.types.BBP_OT_add_swing_series",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_swing_series/property", "Span"), + (("bpy.types.BBP_OT_add_swing_series.component_span",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The distance between each swing"), + (("bpy.types.BBP_OT_add_swing_series.component_span",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_swing_series/property", "Staggered"), + (("bpy.types.BBP_OT_add_swing_series.staggered_swing",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether place Swing staggered. Staggered Swing accept any ball however Non-Staggered Swing only accept Wood and Paper ball."), + (("bpy.types.BBP_OT_add_swing_series.staggered_swing",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_tilting_block_series", "Tilting Block Series"), + (("bpy.types.BBP_OT_add_tilting_block_series",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Tilting Block Series"), + (("bpy.types.BBP_OT_add_tilting_block_series",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_tilting_block_series/property", "Span"), + (("bpy.types.BBP_OT_add_tilting_block_series.component_span",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The distance between each titling blocks"), + (("bpy.types.BBP_OT_add_tilting_block_series.component_span",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_transition_rail", "Transition Rail"), + (("bpy.types.BBP_OT_add_transition_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Transition Rail"), + (("bpy.types.BBP_OT_add_transition_rail",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_transition_section", "Transition Section"), + (("bpy.types.BBP_OT_add_transition_section",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Transition Section"), + (("bpy.types.BBP_OT_add_transition_section",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_ventilator_series", "Ventilator Series"), + (("bpy.types.BBP_OT_add_ventilator_series",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add Ventilator Series"), + (("bpy.types.BBP_OT_add_ventilator_series",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_ventilator_series/property", "Delta Vector"), + (("bpy.types.BBP_OT_add_ventilator_series.component_translation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The translation between each ventilators. You can use this property to implement vertical or horizontal ventilator series. Set all factors to zero can get Nong ventilator."), + (("bpy.types.BBP_OT_add_ventilator_series.component_translation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_virtools_group", "Add to Virtools Groups"), + (("bpy.types.BBP_OT_add_virtools_groups",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Add a Virtools Group for Active Object."), + (("bpy.types.BBP_OT_add_virtools_groups",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_apply_virtools_light", "Apply to Blender Light"), + (("bpy.types.BBP_OT_apply_virtools_light",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Apply Virtools Light to Blender Light."), + (("bpy.types.BBP_OT_apply_virtools_light",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_apply_virtools_material", "Apply to Blender Material"), + (("bpy.types.BBP_OT_apply_virtools_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Apply Virtools Material to Blender Material."), + (("bpy.types.BBP_OT_apply_virtools_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_auto_grouping", "Auto Grouping"), + (("bpy.types.BBP_OT_auto_grouping",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Auto Grouping Objects by Its Name and Name Convention"), + (("bpy.types.BBP_OT_auto_grouping",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_clear_ioport_encodings", "Clear Encodings List"), + (("bpy.types.BBP_OT_clear_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Clear the encodings list used by BMap for Virtools file read and write."), + (("bpy.types.BBP_OT_clear_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_clear_objects_virtools_group", "Clear All Groups"), + (("bpy.types.BBP_OT_clear_objects_virtools_group",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Clear Virtools Groups on Selected Objects"), + (("bpy.types.BBP_OT_clear_objects_virtools_group",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_clear_virtools_groups", "Clear Virtools Groups"), + (("bpy.types.BBP_OT_clear_virtools_groups",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Clear All Virtools Group for Active Object."), + (("bpy.types.BBP_OT_clear_virtools_groups",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_convert_to_imengyu", "Convert to Imengyu"), + (("bpy.types.BBP_OT_convert_to_imengyu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Convert Objects Name from YYC Convention to Imengyu Convention."), + (("bpy.types.BBP_OT_convert_to_imengyu",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_direct_set_virtools_texture", "Import and Assign Texture"), + (("bpy.types.BBP_OT_direct_set_virtools_texture",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Import and Assign Texture Directly"), + (("bpy.types.BBP_OT_direct_set_virtools_texture",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_down_ioport_encodings", "Move Down in Encodings List"), + (("bpy.types.BBP_OT_down_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Move selected item down in encodings list used by BMap for Virtools file read and write."), + (("bpy.types.BBP_OT_down_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_export_bmfile", "Export BM (Ballance Map) File"), + (("bpy.types.BBP_OT_export_bmfile",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Save a Ballance Map File (BM File Spec 1.4)"), + (("bpy.types.BBP_OT_export_bmfile",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ExportParams/property", "Export Mode"), + (("bpy.types.BBP_OT_export_bmfile.export_mode", + "bpy.types.BBP_OT_export_virtools.export_mode"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ExportParams/property", "Collection"), + (("bpy.types.BBP_OT_export_bmfile.export_mode:'COLLECTION'", + "bpy.types.BBP_OT_export_virtools.export_mode:'COLLECTION'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Export a collection"), + (("bpy.types.BBP_OT_export_bmfile.export_mode:'COLLECTION'", + "bpy.types.BBP_OT_export_virtools.export_mode:'COLLECTION'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ExportParams/property", "Object"), + (("bpy.types.BBP_OT_export_bmfile.export_mode:'OBJECT'", + "bpy.types.BBP_OT_export_virtools.export_mode:'OBJECT'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Export an object"), + (("bpy.types.BBP_OT_export_bmfile.export_mode:'OBJECT'", + "bpy.types.BBP_OT_export_virtools.export_mode:'OBJECT'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_export_virtools", "Export Virtools File"), + (("bpy.types.BBP_OT_export_virtools",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Export Virtools File"), + (("bpy.types.BBP_OT_export_virtools",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/property", "Compress Level"), + (("bpy.types.BBP_OT_export_virtools.compress_level", + "bpy.types.BBP_OT_import_virtools.compress_level"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The ZLib compress level used by Virtools Engine when saving composition."), + (("bpy.types.BBP_OT_export_virtools.compress_level", + "bpy.types.BBP_OT_import_virtools.compress_level"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.BallanceParams/property", "Successive Sector"), + (("bpy.types.BBP_OT_export_virtools.successive_sector", + "bpy.types.BBP_OT_import_virtools.successive_sector"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether order exporter to use document specified sector count to make sure sector is successive."), + (("bpy.types.BBP_OT_export_virtools.successive_sector", + "bpy.types.BBP_OT_import_virtools.successive_sector"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/property", "Global Texture Save Options"), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt", + "bpy.types.BBP_OT_import_virtools.texture_save_opt"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Decide how texture saved if texture is specified as Use Global as its Save Options."), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt", + "bpy.types.BBP_OT_import_virtools.texture_save_opt"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/property", "Raw Data"), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'0'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'0'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Save raw data inside file. The bitmap is saved in a raw 32 bit per pixel format. "), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'0'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'0'", + "bpy.types.BBP_PG_virtools_texture.save_options:'0'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/property", "External"), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'1'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Store only the file name for the texture. The bitmap file must be present in the bitmap paths when loading the composition. "), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'1'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'1'", + "bpy.types.BBP_PG_virtools_texture.save_options:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/property", "Image Format"), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'2'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Save using format specified. The bitmap data will be converted to the specified format by the correspondant bitmap plugin and saved inside file. "), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'2'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'2'", + "bpy.types.BBP_PG_virtools_texture.save_options:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/property", "Use Global"), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'3'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Use Global settings, that is the settings given with CKContext::SetGlobalImagesSaveOptions. (Not valid when using CKContext::SetImagesSaveOptions). "), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'3'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'3'", + "bpy.types.BBP_PG_virtools_texture.save_options:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/property", "Include Original File"), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'4'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Insert original image file inside CMO file. The bitmap file that was used originally for the texture or sprite will be append to the composition file and extracted when the file is loaded. "), + (("bpy.types.BBP_OT_export_virtools.texture_save_opt:'4'", + "bpy.types.BBP_OT_import_virtools.texture_save_opt:'4'", + "bpy.types.BBP_PG_virtools_texture.save_options:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/property", "Use Compress"), + (("bpy.types.BBP_OT_export_virtools.use_compress", + "bpy.types.BBP_OT_import_virtools.use_compress"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether use ZLib to compress result when saving composition."), + (("bpy.types.BBP_OT_export_virtools.use_compress", + "bpy.types.BBP_OT_import_virtools.use_compress"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_fix_all_material", "Fix All Materials"), + (("bpy.types.BBP_OT_fix_all_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Fix All Materials by Its Referred Ballance Texture Name."), + (("bpy.types.BBP_OT_fix_all_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_fix_single_material", "Fix Material"), + (("bpy.types.BBP_OT_fix_single_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Fix Active Materials by Its Referred Ballance Texture Name."), + (("bpy.types.BBP_OT_fix_single_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv", "Flatten UV"), + (("bpy.types.BBP_OT_flatten_uv",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Flatten selected face UV. Only works for convex face"), + (("bpy.types.BBP_OT_flatten_uv",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Flatten Method"), + (("bpy.types.BBP_OT_flatten_uv.flatten_method",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Raw"), + (("bpy.types.BBP_OT_flatten_uv.flatten_method:'RAW'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Legacy flatten UV."), + (("bpy.types.BBP_OT_flatten_uv.flatten_method:'RAW'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Floor"), + (("bpy.types.BBP_OT_flatten_uv.flatten_method:'FLOOR'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Floor specific flatten UV."), + (("bpy.types.BBP_OT_flatten_uv.flatten_method:'FLOOR'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Wood"), + (("bpy.types.BBP_OT_flatten_uv.flatten_method:'WOOD'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Wood specific flatten UV."), + (("bpy.types.BBP_OT_flatten_uv.flatten_method:'WOOD'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Reference Edge"), + (("bpy.types.BBP_OT_flatten_uv.reference_edge",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The references edge of UV.\nIt will be placed in V axis."), + (("bpy.types.BBP_OT_flatten_uv.reference_edge",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Reference Point"), + (("bpy.types.BBP_OT_flatten_uv.reference_point",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The references point of UV.\nIt's U component will be set to the number specified by Reference Point UV.\nThis point index is related to the start point of reference edge."), + (("bpy.types.BBP_OT_flatten_uv.reference_point",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Reference Point UV"), + (("bpy.types.BBP_OT_flatten_uv.reference_uv",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The U component which should be applied to references point in UV."), + (("bpy.types.BBP_OT_flatten_uv.reference_uv",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Scale Mode"), + (("bpy.types.BBP_OT_flatten_uv.scale_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Scale Size"), + (("bpy.types.BBP_OT_flatten_uv.scale_mode:'NUM'", + "bpy.types.BBP_OT_flatten_uv.scale_number"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Scale UV with specific number."), + (("bpy.types.BBP_OT_flatten_uv.scale_mode:'NUM'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/property", "Ref. Point"), + (("bpy.types.BBP_OT_flatten_uv.scale_mode:'REF'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Scale UV with Reference Point feature."), + (("bpy.types.BBP_OT_flatten_uv.scale_mode:'REF'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The size which will be applied for scale."), + (("bpy.types.BBP_OT_flatten_uv.scale_number",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_import_bmfile", "Import BM (Ballance Map) File"), + (("bpy.types.BBP_OT_import_bmfile",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Load a Ballance Map File (BM File Spec 1.4)"), + (("bpy.types.BBP_OT_import_bmfile",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/property", "Light Name Conflict"), + (("bpy.types.BBP_OT_import_bmfile.light_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.light_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Define how to process light name conflict"), + (("bpy.types.BBP_OT_import_bmfile.light_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.light_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/property", "Rename"), + (("bpy.types.BBP_OT_import_bmfile.light_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_bmfile.material_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_bmfile.mesh_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_bmfile.object_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_bmfile.texture_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.light_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.material_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.mesh_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.object_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.texture_conflict_strategy:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Rename the new one"), + (("bpy.types.BBP_OT_import_bmfile.light_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_bmfile.material_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_bmfile.mesh_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_bmfile.object_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_bmfile.texture_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.light_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.material_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.mesh_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.object_conflict_strategy:'1'", + "bpy.types.BBP_OT_import_virtools.texture_conflict_strategy:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/property", "Use Current"), + (("bpy.types.BBP_OT_import_bmfile.light_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_bmfile.material_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_bmfile.mesh_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_bmfile.object_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_bmfile.texture_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.light_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.material_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.mesh_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.object_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.texture_conflict_strategy:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Use current one"), + (("bpy.types.BBP_OT_import_bmfile.light_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_bmfile.material_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_bmfile.mesh_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_bmfile.object_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_bmfile.texture_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.light_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.material_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.mesh_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.object_conflict_strategy:'2'", + "bpy.types.BBP_OT_import_virtools.texture_conflict_strategy:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/property", "Material Name Conflict"), + (("bpy.types.BBP_OT_import_bmfile.material_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.material_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Define how to process material name conflict"), + (("bpy.types.BBP_OT_import_bmfile.material_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.material_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/property", "Mesh Name Conflict"), + (("bpy.types.BBP_OT_import_bmfile.mesh_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.mesh_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Define how to process mesh name conflict"), + (("bpy.types.BBP_OT_import_bmfile.mesh_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.mesh_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/property", "Object Name Conflict"), + (("bpy.types.BBP_OT_import_bmfile.object_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.object_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Define how to process object name conflict"), + (("bpy.types.BBP_OT_import_bmfile.object_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.object_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/property", "Texture Name Conflict"), + (("bpy.types.BBP_OT_import_bmfile.texture_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.texture_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Define how to process texture name conflict"), + (("bpy.types.BBP_OT_import_bmfile.texture_conflict_strategy", + "bpy.types.BBP_OT_import_virtools.texture_conflict_strategy"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_import_virtools", "Import Virtools File"), + (("bpy.types.BBP_OT_import_virtools",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Import Virtools File"), + (("bpy.types.BBP_OT_import_virtools",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_legacy_align", "3ds Max Align"), + (("bpy.types.BBP_OT_legacy_align",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Align Objects with 3ds Max Style"), + (("bpy.types.BBP_OT_legacy_align",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_preset_virtools_material", "Preset Virtools Material"), + (("bpy.types.BBP_OT_preset_virtools_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Preset Virtools Material with Original Ballance Data."), + (("bpy.types.BBP_OT_preset_virtools_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Preset"), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The preset which you want to apply."), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "FloorSide"), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "FloorTop"), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "TrafoPaper"), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "TraforWoodStone"), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Rail"), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type:'5'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "WoodPath"), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type:'6'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "WoodChip"), + (("bpy.types.BBP_OT_preset_virtools_material.preset_type:'7'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_rail_uv", "Rail UV"), + (("bpy.types.BBP_OT_rail_uv",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Create UV for Rail as Ballance Showen (TT_ReflectionMapping)"), + (("bpy.types.BBP_OT_rail_uv",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_regulate_objects_name", "Regulate Objects Name"), + (("bpy.types.BBP_OT_regulate_objects_name",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Regulate Objects Name by Virtools Group and Naming Convention"), + (("bpy.types.BBP_OT_regulate_objects_name",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_reset_ballance_elements", "Reset Ballance Elements"), + (("bpy.types.BBP_OT_reset_ballance_elements",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Reset all Meshes of Loaded Ballance Elements to Original Geometry."), + (("bpy.types.BBP_OT_reset_ballance_elements",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_reset_bme_materials", "Reset BME Materials"), + (("bpy.types.BBP_OT_reset_bme_materials",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Reset all BME Materials to Default Settings."), + (("bpy.types.BBP_OT_reset_bme_materials",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_rm_ioport_encodings", "Remove from Encodings List"), + (("bpy.types.BBP_OT_rm_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Remove selected item in encodings list used by BMap for Virtools file read and write."), + (("bpy.types.BBP_OT_rm_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_rm_objects_virtools_group", "Ungrouping Objects"), + (("bpy.types.BBP_OT_rm_objects_virtools_group",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Ungrouping Selected Objects"), + (("bpy.types.BBP_OT_rm_objects_virtools_group",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_rm_virtools_group", "Remove from Virtools Groups"), + (("bpy.types.BBP_OT_rm_virtools_groups",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Remove a Virtools Group for Active Object."), + (("bpy.types.BBP_OT_rm_virtools_groups",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group", "Select by Virtools Group"), + (("bpy.types.BBP_OT_select_object_by_virtools_group",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Select Objects by Virtools Group"), + (("bpy.types.BBP_OT_select_object_by_virtools_group",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group/property", "Mode"), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Selection mode"), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group/property", "Set"), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Sets a new selection."), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group/property", "Extend"), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Adds newly selected items to the existing selection."), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group/property", "Subtract"), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Removes newly selected items from the existing selection."), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group/property", "Invert"), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Inverts the selection."), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group/property", "Intersect"), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'5'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Selects items that intersect with the existing selection."), + (("bpy.types.BBP_OT_select_object_by_virtools_group.selection_mode:'5'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_snoop_group_then_to_mesh", "Snoop Group then to Mesh"), + (("bpy.types.BBP_OT_snoop_group_then_to_mesh",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Convert selected objects into mesh objects and try to copy the Virtools Group infos of their associated curve bevel object if they have. "), + (("bpy.types.BBP_OT_snoop_group_then_to_mesh",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_up_ioport_encodings", "Move Up in Encodings List"), + (("bpy.types.BBP_OT_up_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Move selected item up in encodings list used by BMap for Virtools file read and write."), + (("bpy.types.BBP_OT_up_ioport_encodings",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Show Ballance Elements Properties."), + (("bpy.types.BBP_PT_ballance_elements",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_ballance_elements", "Ballance Elements"), + (("bpy.types.BBP_PT_ballance_elements",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Show Ballance Map Infos."), + (("bpy.types.BBP_PT_ballance_map_info",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_ballance_map_info", "Ballance Map"), + (("bpy.types.BBP_PT_ballance_map_info",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Show BME Materials Properties."), + (("bpy.types.BBP_PT_bme_materials",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_bme_materials", "BME Materials"), + (("bpy.types.BBP_PT_bme_materials",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Show Virtools Groups Properties."), + (("bpy.types.BBP_PT_virtools_groups",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_groups", "Virtools Groups"), + (("bpy.types.BBP_PT_virtools_groups",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Show Virtools Light Properties"), + (("bpy.types.BBP_PT_virtools_light",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_light", "Virtools Light"), + (("bpy.types.BBP_PT_virtools_light",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Show Virtools Material Properties."), + (("bpy.types.BBP_PT_virtools_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material", "Virtools Material"), + (("bpy.types.BBP_PT_virtools_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Show Virtools Mesh Properties."), + (("bpy.types.BBP_PT_virtools_mesh",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_mesh", "Virtools Mesh"), + (("bpy.types.BBP_PT_virtools_mesh",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "String Definition"), + (("bpy.types.StringProperty",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "RNA text string property definition"), + (("bpy.types.StringProperty",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "String default value"), + (("bpy.types.StringProperty.default",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Maximum Length"), + (("bpy.types.StringProperty.length_max",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Maximum length of the string, 0 means unlimited"), + (("bpy.types.StringProperty.length_max",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_ballance_element/property", "Element Id"), + (("bpy.types.BBP_PG_ballance_element.element_id",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_ballance_element/property", "Mesh"), + (("bpy.types.BBP_PG_ballance_element.mesh_ptr",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_ballance_map_info/property", "Sector"), + (("bpy.types.BBP_PG_ballance_map_info.sector_count",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The sector count of this Ballance map which is used in exporting map and may be changed when importing map."), + (("bpy.types.BBP_PG_ballance_map_info.sector_count",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_bmap_encoding/property", "Encoding"), + (("bpy.types.BBP_PG_bmap_encoding.encoding",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The name of BMap used encoding."), + (("bpy.types.BBP_PG_bmap_encoding.encoding",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_bme_adder_cfgs/property", "Boolean Value"), + (("bpy.types.BBP_PG_bme_adder_cfgs.prop_bool",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The field representing a single boolean value."), + (("bpy.types.BBP_PG_bme_adder_cfgs.prop_bool",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_bme_adder_cfgs/property", "Float Point Value"), + (("bpy.types.BBP_PG_bme_adder_cfgs.prop_float",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The field representing a single float point value."), + (("bpy.types.BBP_PG_bme_adder_cfgs.prop_float",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_bme_adder_cfgs/property", "Integral Value"), + (("bpy.types.BBP_PG_bme_adder_cfgs.prop_int",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The field representing a single integral value."), + (("bpy.types.BBP_PG_bme_adder_cfgs.prop_int",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_bme_material/property", "Name"), + (("bpy.types.BBP_PG_bme_material.bme_material_name",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_bme_material/property", "Material"), + (("bpy.types.BBP_PG_bme_material.material_ptr",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "X Position"), + (("bpy.types.BBP_PG_legacy_align_history.align_x",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "Y Position"), + (("bpy.types.BBP_PG_legacy_align_history.align_y",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "Z Position"), + (("bpy.types.BBP_PG_legacy_align_history.align_z",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "Current Object (Active Object)"), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "Min"), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode:'1'", + "bpy.types.BBP_PG_legacy_align_history.target_align_mode:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The min value in specified axis."), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode:'1'", + "bpy.types.BBP_PG_legacy_align_history.target_align_mode:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "Center (Bounding Box)"), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode:'2'", + "bpy.types.BBP_PG_legacy_align_history.target_align_mode:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The bounding box center in specified axis."), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode:'2'", + "bpy.types.BBP_PG_legacy_align_history.target_align_mode:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "Center (Axis)"), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode:'3'", + "bpy.types.BBP_PG_legacy_align_history.target_align_mode:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The object's source point in specified axis."), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode:'3'", + "bpy.types.BBP_PG_legacy_align_history.target_align_mode:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "Max"), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode:'4'", + "bpy.types.BBP_PG_legacy_align_history.target_align_mode:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The max value in specified axis."), + (("bpy.types.BBP_PG_legacy_align_history.current_align_mode:'4'", + "bpy.types.BBP_PG_legacy_align_history.target_align_mode:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_legacy_align_history/property", "Target Objects (Other Objects)"), + (("bpy.types.BBP_PG_legacy_align_history.target_align_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_ptrprop_resolver/property", "Collection"), + (("bpy.types.BBP_PG_ptrprop_resolver.export_collection",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The collection exported. Nested collections allowed."), + (("bpy.types.BBP_PG_ptrprop_resolver.export_collection",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_ptrprop_resolver/property", "Object"), + (("bpy.types.BBP_PG_ptrprop_resolver.export_object",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The object exported"), + (("bpy.types.BBP_PG_ptrprop_resolver.export_object",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_ptrprop_resolver/property", "Material"), + (("bpy.types.BBP_PG_ptrprop_resolver.rail_uv_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The material used for rail"), + (("bpy.types.BBP_PG_ptrprop_resolver.rail_uv_material",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_group/property", "Group Name"), + (("bpy.types.BBP_PG_virtools_group.group_name",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Constant Attenuation"), + (("bpy.types.BBP_PG_virtools_light.constant_attenuation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Defines the constant attenuation factor."), + (("bpy.types.BBP_PG_virtools_light.constant_attenuation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Fall Off"), + (("bpy.types.BBP_PG_virtools_light.falloff",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Sets the light fall off rate."), + (("bpy.types.BBP_PG_virtools_light.falloff",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Fall Off Shape"), + (("bpy.types.BBP_PG_virtools_light.falloff_shape",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Sets the value of the light fall off shape."), + (("bpy.types.BBP_PG_virtools_light.falloff_shape",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Hot Spot"), + (("bpy.types.BBP_PG_virtools_light.hot_spot",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Sets the value of the hot spot of the light."), + (("bpy.types.BBP_PG_virtools_light.hot_spot",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Color"), + (("bpy.types.BBP_PG_virtools_light.light_color",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Defines the red, green and blue components of the light."), + (("bpy.types.BBP_PG_virtools_light.light_color",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Range"), + (("bpy.types.BBP_PG_virtools_light.light_range",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Defines the radius of the lighting area."), + (("bpy.types.BBP_PG_virtools_light.light_range",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Type"), + (("bpy.types.BBP_PG_virtools_light.light_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The type of this light"), + (("bpy.types.BBP_PG_virtools_light.light_type",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Point"), + (("bpy.types.BBP_PG_virtools_light.light_type:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The Light is a point of light "), + (("bpy.types.BBP_PG_virtools_light.light_type:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Spot"), + (("bpy.types.BBP_PG_virtools_light.light_type:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The light is a spotlight "), + (("bpy.types.BBP_PG_virtools_light.light_type:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Directional"), + (("bpy.types.BBP_PG_virtools_light.light_type:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The light is directional light : Lights comes from an infinite point so only direction of light can be given "), + (("bpy.types.BBP_PG_virtools_light.light_type:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Linear Attenuation"), + (("bpy.types.BBP_PG_virtools_light.linear_attenuation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Defines the linear attenuation factor."), + (("bpy.types.BBP_PG_virtools_light.linear_attenuation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_light/property", "Quadratic Attenuation"), + (("bpy.types.BBP_PG_virtools_light.quadratic_attenuation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Defines the quadratic attenuation factor."), + (("bpy.types.BBP_PG_virtools_light.quadratic_attenuation",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Alpha Test Function"), + (("bpy.types.BBP_PG_virtools_material.alpha_func",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Alpha comparision function"), + (("bpy.types.BBP_PG_virtools_material.alpha_func",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Never"), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'1'", + "bpy.types.BBP_PG_virtools_material.z_func:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Always fail the test. "), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'1'", + "bpy.types.BBP_PG_virtools_material.z_func:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Less"), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'2'", + "bpy.types.BBP_PG_virtools_material.z_func:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Accept if value if less than current value. "), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'2'", + "bpy.types.BBP_PG_virtools_material.z_func:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Equal"), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'3'", + "bpy.types.BBP_PG_virtools_material.z_func:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Accept if value if equal than current value. "), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'3'", + "bpy.types.BBP_PG_virtools_material.z_func:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Less Equal"), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'4'", + "bpy.types.BBP_PG_virtools_material.z_func:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Accept if value if less or equal than current value. "), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'4'", + "bpy.types.BBP_PG_virtools_material.z_func:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Greater"), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'5'", + "bpy.types.BBP_PG_virtools_material.z_func:'5'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Accept if value if greater than current value. "), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'5'", + "bpy.types.BBP_PG_virtools_material.z_func:'5'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Not Equal"), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'6'", + "bpy.types.BBP_PG_virtools_material.z_func:'6'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Accept if value if different than current value. "), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'6'", + "bpy.types.BBP_PG_virtools_material.z_func:'6'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Greater Equal"), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'7'", + "bpy.types.BBP_PG_virtools_material.z_func:'7'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Accept if value if greater or equal current value. "), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'7'", + "bpy.types.BBP_PG_virtools_material.z_func:'7'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Always"), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'8'", + "bpy.types.BBP_PG_virtools_material.z_func:'8'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Always accept the test. "), + (("bpy.types.BBP_PG_virtools_material.alpha_func:'8'", + "bpy.types.BBP_PG_virtools_material.z_func:'8'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Alpha Ref Value"), + (("bpy.types.BBP_PG_virtools_material.alpha_ref",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Alpha referential value"), + (("bpy.types.BBP_PG_virtools_material.alpha_ref",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Ambient"), + (("bpy.types.BBP_PG_virtools_material.ambient",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Ambient color of the material"), + (("bpy.types.BBP_PG_virtools_material.ambient",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Destination Blend"), + (("bpy.types.BBP_PG_virtools_material.dest_blend",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Destination blend factor"), + (("bpy.types.BBP_PG_virtools_material.dest_blend",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Zero"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'1'", + "bpy.types.BBP_PG_virtools_material.source_blend:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (0, 0, 0, 0). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'1'", + "bpy.types.BBP_PG_virtools_material.source_blend:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "One"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'2'", + "bpy.types.BBP_PG_virtools_material.source_blend:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (1, 1, 1, 1). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'2'", + "bpy.types.BBP_PG_virtools_material.source_blend:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Src Color"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'3'", + "bpy.types.BBP_PG_virtools_material.source_blend:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (Rs, Gs, Bs, As). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'3'", + "bpy.types.BBP_PG_virtools_material.source_blend:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Inv Src Color"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'4'", + "bpy.types.BBP_PG_virtools_material.source_blend:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (1-Rs, 1-Gs, 1-Bs, 1-As). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'4'", + "bpy.types.BBP_PG_virtools_material.source_blend:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Src Alpha"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'5'", + "bpy.types.BBP_PG_virtools_material.source_blend:'5'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (As, As, As, As). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'5'", + "bpy.types.BBP_PG_virtools_material.source_blend:'5'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Inv Src Alpha"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'6'", + "bpy.types.BBP_PG_virtools_material.source_blend:'6'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (1-As, 1-As, 1-As, 1-As). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'6'", + "bpy.types.BBP_PG_virtools_material.source_blend:'6'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Dest Alpha"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'7'", + "bpy.types.BBP_PG_virtools_material.source_blend:'7'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (Ad, Ad, Ad, Ad). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'7'", + "bpy.types.BBP_PG_virtools_material.source_blend:'7'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Inv Dest Alpha"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'8'", + "bpy.types.BBP_PG_virtools_material.source_blend:'8'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (1-Ad, 1-Ad, 1-Ad, 1-Ad). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'8'", + "bpy.types.BBP_PG_virtools_material.source_blend:'8'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Dest Color"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'9'", + "bpy.types.BBP_PG_virtools_material.source_blend:'9'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (Rd, Gd, Bd, Ad). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'9'", + "bpy.types.BBP_PG_virtools_material.source_blend:'9'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Inv Dest Color"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'10'", + "bpy.types.BBP_PG_virtools_material.source_blend:'10'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (1-Rd, 1-Gd, 1-Bd, 1-Ad). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'10'", + "bpy.types.BBP_PG_virtools_material.source_blend:'10'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Src Alpha Sat"), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'11'", + "bpy.types.BBP_PG_virtools_material.source_blend:'11'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Blend factor is (f, f, f, 1); f = min(As, 1-Ad). "), + (("bpy.types.BBP_PG_virtools_material.dest_blend:'11'", + "bpy.types.BBP_PG_virtools_material.source_blend:'11'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Diffuse"), + (("bpy.types.BBP_PG_virtools_material.diffuse",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Emissive"), + (("bpy.types.BBP_PG_virtools_material.emissive",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Emissive color of the material"), + (("bpy.types.BBP_PG_virtools_material.emissive",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Blend"), + (("bpy.types.BBP_PG_virtools_material.enable_alpha_blend",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether alpha blending is enabled or not."), + (("bpy.types.BBP_PG_virtools_material.enable_alpha_blend",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Alpha Test"), + (("bpy.types.BBP_PG_virtools_material.enable_alpha_test",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether the alpha test is enabled"), + (("bpy.types.BBP_PG_virtools_material.enable_alpha_test",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Perspective Correction"), + (("bpy.types.BBP_PG_virtools_material.enable_perspective_correction",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether texture perspective correction is enabled"), + (("bpy.types.BBP_PG_virtools_material.enable_perspective_correction",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Both Sided"), + (("bpy.types.BBP_PG_virtools_material.enable_two_sided",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether the material is both sided or not"), + (("bpy.types.BBP_PG_virtools_material.enable_two_sided",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Z-Buffer Write"), + (("bpy.types.BBP_PG_virtools_material.enable_z_write",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Whether writing in ZBuffer is enabled."), + (("bpy.types.BBP_PG_virtools_material.enable_z_write",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Fill Mode"), + (("bpy.types.BBP_PG_virtools_material.fill_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Fill mode"), + (("bpy.types.BBP_PG_virtools_material.fill_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Point"), + (("bpy.types.BBP_PG_virtools_material.fill_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Vertices rendering "), + (("bpy.types.BBP_PG_virtools_material.fill_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Wireframe"), + (("bpy.types.BBP_PG_virtools_material.fill_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Edges rendering "), + (("bpy.types.BBP_PG_virtools_material.fill_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Solid"), + (("bpy.types.BBP_PG_virtools_material.fill_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Face rendering "), + (("bpy.types.BBP_PG_virtools_material.fill_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Shade Mode"), + (("bpy.types.BBP_PG_virtools_material.shade_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Shade mode"), + (("bpy.types.BBP_PG_virtools_material.shade_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Flat"), + (("bpy.types.BBP_PG_virtools_material.shade_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Flat Shading "), + (("bpy.types.BBP_PG_virtools_material.shade_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Gouraud"), + (("bpy.types.BBP_PG_virtools_material.shade_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Gouraud Shading "), + (("bpy.types.BBP_PG_virtools_material.shade_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Phong"), + (("bpy.types.BBP_PG_virtools_material.shade_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Phong Shading (Not yet supported by most implementation) "), + (("bpy.types.BBP_PG_virtools_material.shade_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Source Blend"), + (("bpy.types.BBP_PG_virtools_material.source_blend",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Source blend factor"), + (("bpy.types.BBP_PG_virtools_material.source_blend",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Specular"), + (("bpy.types.BBP_PG_virtools_material.specular",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Power"), + (("bpy.types.BBP_PG_virtools_material.specular_power",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Specular highlight power"), + (("bpy.types.BBP_PG_virtools_material.specular_power",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Texture"), + (("bpy.types.BBP_PG_virtools_material.texture",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Texture of the material"), + (("bpy.types.BBP_PG_virtools_material.texture",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Address Mode"), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The address mode controls how the texture coordinates outside the range 0..1"), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Wrap"), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Default mesh wrap mode is used (see CKMesh::SetWrapMode) "), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Mirror"), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Texture coordinates outside the range [0..1] are flipped evenly. "), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Clamp"), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Texture coordinates greater than 1.0 are set to 1.0, and values less than 0.0 are set to 0.0. "), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Border"), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "When texture coordinates are greater than 1.0 or less than 0.0 texture is set to a color defined in CKMaterial::SetTextureBorderColor. "), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Mirror Once"), + (("bpy.types.BBP_PG_virtools_material.texture_address_mode:'5'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Texture Blend"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Texture blend mode"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Decal"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Texture replace any material information "), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Modulate"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Texture and material are combine. Alpha information of the texture replace material alpha component. "), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Decal Alpha"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Alpha information in the texture specify how material and texture are combined. Alpha information of the texture replace material alpha component. "), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Modulate Alpha"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Alpha information in the texture specify how material and texture are combined "), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Decal Mask"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'5'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Modulate Mask"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'6'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Copy"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'7'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Equivalent to DECAL "), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'7'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Add"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'8'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Dot Product 3"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'9'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Perform a Dot Product 3 between texture (normal map) and a referential vector given in VXRENDERSTATE_TEXTUREFACTOR. "), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'9'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Max"), + (("bpy.types.BBP_PG_virtools_material.texture_blend_mode:'10'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Border Color"), + (("bpy.types.BBP_PG_virtools_material.texture_border_color",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The border color is used when the texture address mode is VXTEXTURE_ADDRESSBORDER."), + (("bpy.types.BBP_PG_virtools_material.texture_border_color",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Filter Mag"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Texture filter mode when the texture is magnified"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Nearest"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'1'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "No Filter "), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'1'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'1'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Linear"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'2'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Bilinear Interpolation "), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'2'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'2'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Mip Nearest"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'3'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Mip mapping "), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'3'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'3'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Mip Linear"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'4'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Mip Mapping with Bilinear interpolation "), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'4'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'4'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Linear Mip Nearest"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'5'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'5'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Mip Mapping with Bilinear interpolation between mipmap levels. "), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'5'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'5'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Linear Mip Linear"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'6'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'6'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Trilinear Filtering "), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'6'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'6'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Anisotropic"), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'7'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'7'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Anisotropic filtering "), + (("bpy.types.BBP_PG_virtools_material.texture_mag_mode:'7'", + "bpy.types.BBP_PG_virtools_material.texture_min_mode:'7'"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Filter Min"), + (("bpy.types.BBP_PG_virtools_material.texture_min_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Texture filter mode when the texture is minified"), + (("bpy.types.BBP_PG_virtools_material.texture_min_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_material/property", "Z Compare Function"), + (("bpy.types.BBP_PG_virtools_material.z_func",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Z Comparison function"), + (("bpy.types.BBP_PG_virtools_material.z_func",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_mesh/property", "Lit Mode"), + (("bpy.types.BBP_PG_virtools_mesh.lit_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Lighting mode of the mesh."), + (("bpy.types.BBP_PG_virtools_mesh.lit_mode",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_mesh/property", "Prelit"), + (("bpy.types.BBP_PG_virtools_mesh.lit_mode:'0'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Lighting use color information store with vertices "), + (("bpy.types.BBP_PG_virtools_mesh.lit_mode:'0'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_mesh/property", "Lit"), + (("bpy.types.BBP_PG_virtools_mesh.lit_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Lighting is done by renderer using normals and face material information. "), + (("bpy.types.BBP_PG_virtools_mesh.lit_mode:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "Save Options"), + (("bpy.types.BBP_PG_virtools_texture.save_options",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "When saving a composition textures or sprites can be kept as reference to external files or converted to a given format and saved inside the composition file."), + (("bpy.types.BBP_PG_virtools_texture.save_options",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "Raw Data"), + (("bpy.types.BBP_PG_virtools_texture.save_options:'0'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "External"), + (("bpy.types.BBP_PG_virtools_texture.save_options:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "Image Format"), + (("bpy.types.BBP_PG_virtools_texture.save_options:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "Use Global"), + (("bpy.types.BBP_PG_virtools_texture.save_options:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "Include Original File"), + (("bpy.types.BBP_PG_virtools_texture.save_options:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "Video Format"), + (("bpy.types.BBP_PG_virtools_texture.video_format",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The desired surface pixel format in video memory."), + (("bpy.types.BBP_PG_virtools_texture.video_format",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "32 Bits ARGB8888"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "32-bit ARGB pixel format with alpha "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'1'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "32 Bits RGB888"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "32-bit RGB pixel format without alpha "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'2'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "24 Bits RGB888"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "24-bit RGB pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'3'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits RGB565"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit RGB pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'4'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits RGB555"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'5'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit RGB pixel format (5 bits per color) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'5'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits ARGB1555"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'6'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit ARGB pixel format (5 bits per color + 1 bit for alpha) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'6'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits ARGB4444"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'7'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit ARGB pixel format (4 bits per color) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'7'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "8 Bits RGB332"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'8'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "8-bit RGB pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'8'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "8 Bits ARGB2222"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'9'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "8-bit ARGB pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'9'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "32 Bits ABGR8888"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'10'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "32-bit ABGR pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'10'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "32 Bits RGBA8888"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'11'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "32-bit RGBA pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'11'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "32 Bits BGRA8888"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'12'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "32-bit BGRA pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'12'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "32 Bits BGR888"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'13'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "32-bit BGR pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'13'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "24 Bits BGR888"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'14'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "24-bit BGR pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'14'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits BGR565"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'15'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit BGR pixel format "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'15'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits BGR555"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'16'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit BGR pixel format (5 bits per color) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'16'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits ABGR1555"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'17'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit ABGR pixel format (5 bits per color + 1 bit for alpha) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'17'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits ABGR4444"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'18'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit ABGR pixel format (4 bits per color) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'18'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "DXT1"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'19'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "S3/DirectX Texture Compression 1 "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'19'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "DXT2"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'20'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "S3/DirectX Texture Compression 2 "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'20'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "DXT3"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'21'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "S3/DirectX Texture Compression 3 "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'21'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "DXT4"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'22'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "S3/DirectX Texture Compression 4 "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'22'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "DXT5"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'23'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "S3/DirectX Texture Compression 5 "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'23'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits V8U8"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'24'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit Bump Map format format (8 bits per color) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'24'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "32 Bits V16U16"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'25'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "32-bit Bump Map format format (16 bits per color) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'25'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "16 Bits L6V5U5"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'26'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "16-bit Bump Map format format with luminance "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'26'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "32 Bits X8L8V8U8"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'27'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "32-bit Bump Map format format with luminance "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'27'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "8 Bits ABGR8888 CLUT"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'28'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "8 bits indexed CLUT (ABGR) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'28'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "8 Bits ARGB8888 CLUT"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'29'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "8 bits indexed CLUT (ARGB) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'29'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "4 Bits ABGR8888 CLUT"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'30'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "4 bits indexed CLUT (ABGR) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'30'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PG_virtools_texture/property", "4 Bits ARGB8888 CLUT"), + (("bpy.types.BBP_PG_virtools_texture.video_format:'31'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "4 bits indexed CLUT (ARGB) "), + (("bpy.types.BBP_PG_virtools_texture.video_format:'31'",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Prototype Configurations:"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:246",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Extra Transform"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:280",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Translation"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:282",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Rotation"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:286",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Top"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:269",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Front"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:270",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Left"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:271",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Right"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:273",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Back"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:274",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_bme_struct/draw", "Bottom"), + (("extensions/user_default/bbp_ng/OP_ADDS_bme.py:275",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_nong_ventilator/draw", "Count Source"), + (("extensions/user_default/bbp_ng/OP_ADDS_component.py:330",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_sector_component_pair/draw", "Warning: {0} already exist."), + (("extensions/user_default/bbp_ng/OP_ADDS_component.py:559",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_component/draw", "Warning: {0} already exist."), + (("extensions/user_default/bbp_ng/OP_ADDS_component.py:228",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedExtraTransform/draw", "Extra Transform"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:65",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedExtraTransform/draw", "Translation"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:67",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedExtraTransform/draw", "Rotation"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:71",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedRailCapInputProperty/draw", "Cap Options"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:127",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_ADDS_rail.SharedScrewRailInputProperty/draw", "Flip Options"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:212",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_transition_section/draw", "No Options Available"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:266",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_straight_rail/draw", "Straight Rail"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:289",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_transition_rail/draw", "Transition Rail"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:318",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_side_rail/draw", "Side Rail"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:358",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_arc_rail/draw", "Arc Rail"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:398",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_spiral_rail/draw", "Spiral Rail"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:448",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_add_side_spiral_rail/draw", "Spiral Rail"), + (("extensions/user_default/bbp_ng/OP_ADDS_rail.py:492",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "This feature is not supported yet."), + (("extensions/user_default/bbp_ng/OP_EXPORT_bmfile.py:16", + "extensions/user_default/bbp_ng/OP_IMPORT_bmfile.py:16"), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Virtools File Exporting Finished."), + (("extensions/user_default/bbp_ng/OP_EXPORT_virtools.py:54",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_export_virtools/execute", "Virtools Engine Temporary Directory: {0}"), + (("extensions/user_default/bbp_ng/OP_EXPORT_virtools.py:83",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "No selected target!"), + (("extensions/user_default/bbp_ng/OP_EXPORT_virtools.py:26",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "You can not specify \"Use Global\" as global texture save option!"), + (("extensions/user_default/bbp_ng/OP_EXPORT_virtools.py:32",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "You must specify at least one encoding for file saving (e.g. cp1252, gb2312)!"), + (("extensions/user_default/bbp_ng/OP_EXPORT_virtools.py:38",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Virtools File Importing Finished."), + (("extensions/user_default/bbp_ng/OP_IMPORT_virtools.py:34",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_import_virtools/execute", "Virtools Engine Temporary Directory: {0}"), + (("extensions/user_default/bbp_ng/OP_IMPORT_virtools.py:47",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_import_virtools/execute", "Texture Raw Data Temporary Directory: {0}"), + (("extensions/user_default/bbp_ng/OP_IMPORT_virtools.py:88",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "You must specify at least one encoding for file loading (e.g. cp1252, gb2312)!"), + (("extensions/user_default/bbp_ng/OP_IMPORT_virtools.py:26",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_fix_all_material/draw", "Fix {0}/{1} materials."), + (("extensions/user_default/bbp_ng/OP_MTL_fix_material.py:34",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_legacy_align/draw", "Align Axis (Multi-selection)"), + (("extensions/user_default/bbp_ng/OP_OBJECT_legacy_align.py:182",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_legacy_align/draw", "Current Object (Active Object)"), + (("extensions/user_default/bbp_ng/OP_OBJECT_legacy_align.py:190",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_legacy_align/draw", "Target Objects (Selected Objects)"), + (("extensions/user_default/bbp_ng/OP_OBJECT_legacy_align.py:192",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_legacy_align/draw", "Apply"), + (("extensions/user_default/bbp_ng/OP_OBJECT_legacy_align.py:201",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_legacy_align/draw", "Total {0} applied alignments"), + (("extensions/user_default/bbp_ng/OP_OBJECT_legacy_align.py:203",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_OBJECT_naming_convention._rename_core()", "View console to get more detail"), + (("extensions/user_default/bbp_ng/OP_OBJECT_naming_convention.py:85",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_OBJECT_naming_convention._rename_core()", "All: {0}"), + (("extensions/user_default/bbp_ng/OP_OBJECT_naming_convention.py:86",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/OP_OBJECT_naming_convention._rename_core()", "Failed: {0}"), + (("extensions/user_default/bbp_ng/OP_OBJECT_naming_convention.py:87",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group/draw", "Selection Mode"), + (("extensions/user_default/bbp_ng/OP_OBJECT_virtools_group.py:63",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_select_object_by_virtools_group/draw", "Group Parameters"), + (("extensions/user_default/bbp_ng/OP_OBJECT_virtools_group.py:68",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Grouping objects successfully."), + (("extensions/user_default/bbp_ng/OP_OBJECT_virtools_group.py:142",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Ungrouping objects successfully."), + (("extensions/user_default/bbp_ng/OP_OBJECT_virtools_group.py:168",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Clear objects groups successfully."), + (("extensions/user_default/bbp_ng/OP_OBJECT_virtools_group.py:194",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/draw", "Flatten Method"), + (("extensions/user_default/bbp_ng/OP_UV_flatten_uv.py:182",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/draw", "Scale Mode"), + (("extensions/user_default/bbp_ng/OP_UV_flatten_uv.py:188",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/draw", "Scale Configuration"), + (("extensions/user_default/bbp_ng/OP_UV_flatten_uv.py:193",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_flatten_uv/execute", "[Flatten UV] {0} faces are not be processed correctly because process failed."), + (("extensions/user_default/bbp_ng/OP_UV_flatten_uv.py:175",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_rail_uv/execute", "Rail UV Report"), + (("extensions/user_default/bbp_ng/OP_UV_rail_uv.py:79",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Specified material is empty."), + (("extensions/user_default/bbp_ng/OP_UV_rail_uv.py:26",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Some objects are invalid for this operation. See Console for more details."), + (("extensions/user_default/bbp_ng/OP_UV_rail_uv.py:35",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_OT_rail_uv/execute", "Following objects are not processed by Rail UV because they do not meet the requirements of Rail UV."), + (("extensions/user_default/bbp_ng/OP_UV_rail_uv.py:82",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Reset Ballance elements successfully."), + (("extensions/user_default/bbp_ng/PROP_ballance_element.py:337",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Reset BME materials successfully."), + (("extensions/user_default/bbp_ng/PROP_bme_material.py:234",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBPPreferences/draw", "Ballance Texture Folder"), + (("extensions/user_default/bbp_ng/PROP_preferences.py:42",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBPPreferences/draw", "No Component Collection"), + (("extensions/user_default/bbp_ng/PROP_preferences.py:44",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_groups/draw", "Virtools Group is invalid on non-mesh object!"), + (("extensions/user_default/bbp_ng/PROP_virtools_group.py:392",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_light/draw", "Apply"), + (("extensions/user_default/bbp_ng/PROP_virtools_light.py:287",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_light/draw", "Basics"), + (("extensions/user_default/bbp_ng/PROP_virtools_light.py:292",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_light/draw", "Attenuation"), + (("extensions/user_default/bbp_ng/PROP_virtools_light.py:305",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_light/draw", "Constant"), + (("extensions/user_default/bbp_ng/PROP_virtools_light.py:306",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_light/draw", "Linear"), + (("extensions/user_default/bbp_ng/PROP_virtools_light.py:307",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_light/draw", "Quadratic"), + (("extensions/user_default/bbp_ng/PROP_virtools_light.py:308",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_light/draw", "Spot Cone"), + (("extensions/user_default/bbp_ng/PROP_virtools_light.py:313",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Preset"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1055",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Apply"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1058",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Color Parameters"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1063",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Mode Parameters"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1071",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Texture Parameters"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1077",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Alpha Test Parameters"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1098",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Alpha Blend Parameters"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1105",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Z Write Parameters"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1112",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Fix material successfully."), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:939",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "This material is not suit for fixer."), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:942",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_PT_virtools_material/draw", "Virtools Texture Settings"), + (("extensions/user_default/bbp_ng/PROP_virtools_material.py:1086",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/draw", "Import Parameters"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:201",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/draw", "Name Conflict Strategy"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:205",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/draw", "Object"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:207",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/draw", "Light"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:208",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/draw", "Mesh"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:209",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/draw", "Material"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:210",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ImportParams/draw", "Texture"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:211",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.ExportParams/draw", "Export Parameters"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:256",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/draw", "Virtools Parameters"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:317",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/draw", "Encodings"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:321",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.BallanceParams/draw", "Ballance Parameters"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:369",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.BallanceParams/draw", "Map Sectors: {0}"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:375",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/draw", "Global Texture Save Options"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:328",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_ioport_shared.VirtoolsParams/draw", "Compression"), + (("extensions/user_default/bbp_ng/UTIL_ioport_shared.py:332",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_naming_convension.RenameErrorReporter", "All / Failed - {0} / {1}"), + (("extensions/user_default/bbp_ng/UTIL_naming_convension.py:85",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_naming_convension.RenameErrorReporter", "Rename Report"), + (("extensions/user_default/bbp_ng/UTIL_naming_convension.py:74",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_naming_convension.RenameErrorReporter", "For object \"{0}\""), + (("extensions/user_default/bbp_ng/UTIL_naming_convension.py:110",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_naming_convension.RenameErrorReporter", "For object \"{0}\" (Old name: \"{1}\")"), + (("extensions/user_default/bbp_ng/UTIL_naming_convension.py:113",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_naming_convension.RenameErrorReporter", "ERROR"), + (("extensions/user_default/bbp_ng/UTIL_naming_convension.py:128",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_naming_convension.RenameErrorReporter", "WARN"), + (("extensions/user_default/bbp_ng/UTIL_naming_convension.py:130",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/UTIL_naming_convension.RenameErrorReporter", "INFO"), + (("extensions/user_default/bbp_ng/UTIL_naming_convension.py:132",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BME/UTIL_virtools_types.virtools_name_regulator()", "annoymous"), + (("extensions/user_default/bbp_ng/UTIL_virtools_types.py:266",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_import()", "Virtools File (.nmo/.cmo/.vmo) (experimental)"), + (("extensions/user_default/bbp_ng/__init__.py:130",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_export()", "Virtools File (.nmo/.cmo/.vmo) (experimental)"), + (("extensions/user_default/bbp_ng/__init__.py:143",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_add()", "Ballance"), + (("extensions/user_default/bbp_ng/__init__.py:154",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_grouping()", "Virtools Group"), + (("extensions/user_default/bbp_ng/__init__.py:170",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_grouping()", "Group into..."), + (("extensions/user_default/bbp_ng/__init__.py:172",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_grouping()", "Ungroup from..."), + (("extensions/user_default/bbp_ng/__init__.py:175",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_grouping()", "Clear All Groups"), + (("extensions/user_default/bbp_ng/__init__.py:178",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_snoop_then_conv()", "Ballance"), + (("extensions/user_default/bbp_ng/__init__.py:184",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP/__init__.menu_drawer_naming_convention()", "Ballance"), + (("extensions/user_default/bbp_ng/__init__.py:195",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_View3DMenu/draw", "UV"), + (("extensions/user_default/bbp_ng/__init__.py:42",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_View3DMenu/draw", "Align"), + (("extensions/user_default/bbp_ng/__init__.py:46",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_View3DMenu/draw", "Select"), + (("extensions/user_default/bbp_ng/__init__.py:49",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_View3DMenu/draw", "Material"), + (("extensions/user_default/bbp_ng/__init__.py:52",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddRailMenu/draw", "Sections"), + (("extensions/user_default/bbp_ng/__init__.py:74",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddRailMenu/draw", "Straight Rails"), + (("extensions/user_default/bbp_ng/__init__.py:79",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddRailMenu/draw", "Curve Rails"), + (("extensions/user_default/bbp_ng/__init__.py:85",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddComponentsMenu/draw", "Basic Components"), + (("extensions/user_default/bbp_ng/__init__.py:99",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddComponentsMenu/draw", "Nong Components"), + (("extensions/user_default/bbp_ng/__init__.py:103",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddComponentsMenu/draw", "Series Components"), + (("extensions/user_default/bbp_ng/__init__.py:108",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("BBP_MT_AddComponentsMenu/draw", "Components Pair"), + (("extensions/user_default/bbp_ng/__init__.py:114",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "Ballance Blender Plugin"), + (("Add-on Ballance Blender Plugin info: name",), + ()), + ("zh_HANS", "", + (False, ())), + ), + (("*", "The specialized add-on served for creating game map of Ballance"), + (("Add-on Ballance Blender Plugin info: description",), + ()), + ("zh_HANS", "", + (False, ())), + ), +) translations_dict = {} for msg in translations_tuple: diff --git a/bbp_ng/tools/bme_relatives.py b/bbp_ng/tools/bme_relatives.py index 865045d..6e413bf 100644 --- a/bbp_ng/tools/bme_relatives.py +++ b/bbp_ng/tools/bme_relatives.py @@ -1,6 +1,5 @@ import typing -import collections -import simple_po +import simple_po, bme_utils #region Translation Constant @@ -60,85 +59,84 @@ TOKEN_INSTANCES_TRANSFORM: str = 'transform' #endregion -class Reporter(): +class ReporterWithHierarchy(): """ - General reporter commonly used by BME validator. + BME validator and extractor specifically used reporter + which auotmatically use hierarchy as its context when outputing. """ - def __init__(self): - pass + __mReporter: bme_utils.Reporter + __mHierarchy: bme_utils.Hierarchy - def __report(self, type: str, msg: str, context: str | None) -> None: - strl: str = f'[{type}]' - if context is not None: - strl += f'[{context}]' - strl += ' ' + msg - print(strl) + def __init__(self, reporter: bme_utils.Reporter, hierarchy: bme_utils.Hierarchy): + self.__mReporter = reporter + self.__mHierarchy = hierarchy - def error(self, msg: str, context: str | None = None) -> None: - """ - @brief Report an error. - @param[in] msg The message to show. - @param[in] context The context of this message, e.g. the file path. None if no context. - """ - self.__report('Error', msg, context) + def error(self, msg: str) -> None: + self.__mReporter.error(msg, self.__mHierarchy.build_hierarchy_string()) + def warning(self, msg: str) -> None: + self.__mReporter.warning(msg, self.__mHierarchy.build_hierarchy_string()) + def info(self, msg: str) -> None: + self.__mReporter.info(msg, self.__mHierarchy.build_hierarchy_string()) - def warning(self, msg: str, context: str | None = None) -> None: - """ - @brief Report a warning. - @param[in] msg The message to show. - @param[in] context The context of this message, e.g. the file path. None if no context. - """ - self.__report('Warning', msg, context) - - def info(self, msg: str, context: str | None = None) -> None: - """ - @brief Report a info. - @param[in] msg The message to show. - @param[in] context The context of this message, e.g. the file path. None if no context. - """ - self.__report('Info', msg, context) - -class Hierarchy(): +class UniqueField(): """ - The hierarchy builder for BME validator to build context string representing the location where error happen. - And it can be utilized by BME extractor to generate the context of translation. + Some BME prototype fields should be unique in globl scope. + So BME validator should check this. That's the feature this class provided. + + This class is an abstract class and should not be used directly. + Use child class please. """ - __mStack: collections.deque[str] + __mUniques: set[str] + __mReporter: ReporterWithHierarchy - def __init__(self): - self.__mStack = collections.deque() + def __init__(self, reporter: ReporterWithHierarchy): + self.__mUniques = set() + self.__mReporter = reporter - def push(self, item: str) -> None: + def register(self, entry: str) -> bool: """ - @brief Add an item into this hierarchy. - @param[in] item New added item. - """ - self.__mStack.append(item) - - def push_index(self, index: int) -> None: - """ - @brief Add an integral index into this hierarchy. + @brief Try to register given entry in unique. @details - The difference between this and normal push function is that added item is integral index. - This function will automatically convert it to string with a special format first, then push it into hierarchy. - @param[in] item New added index. + If given entry is not presented in unique set, given entry will be inserted and return True. + If given entry is already available in unique set, this function will use reporter to output an error message and return False. + @param[in] entry The entry to be checked and inserted. + @return True if entry is unique, otherwise false. """ - self.__mStack.append(f'[{index}]') + if entry in self.__mUniques: + self.__mReporter.error(self._get_error_msg(entry)) + return False + else: + self.__mUniques.add(entry) + return True - def pop(self) -> None: + def clear(self) -> None: """ - @brief Remove the top item from hierarchy + @brief Clear this unique set for further using. """ - self.__mStack.pop() + self.__mUniques.clear() - def build_hierarchy_string(self) -> str: + def _get_error_msg(self, err_entry: str) -> str: """ - Build the string which can represent this hierarchy. - @return The built string representing this hierarchy. + @brief Get the error message when error occurs. + @details + This is internal used function to get the error message which will be passed to reporter. + This message is generated by given entry which cause the non-unique issue. + Outer caller should not call this function and every child class should override this function. + @param[in] err_entry The entry cause the error. + @return The error message generated from given error entry. """ - return '/'.join(self.__mStack) + raise NotImplementedError() + +class UniqueIdentifier(UniqueField): + """Specific UniqueField for unique prototype identifier.""" + def _get_error_msg(self, err_entry: str) -> str: + return f'Trying to register multiple prototype with same name: "{err_entry}".' +class UniqueVariable(UniqueField): + """Specific UniqueField for unique variable names within prototype.""" + def _get_error_msg(self, err_entry: str) -> str: + return f'Trying to define multiple variable with same name: "{err_entry}" in the same prototype.' class BMEValidator(): """ @@ -147,19 +145,168 @@ class BMEValidator(): to check then whether have all essential fields BME standard required and whether have any unknown fields. """ - __mPrototypeSet: set[str] - __mHierarchy: Hierarchy - __mReporter: Reporter + __mHierarchy: bme_utils.Hierarchy + __mReporter: ReporterWithHierarchy - def __init__(self, reporter: Reporter): - self.__mPrototypeSet = set() - self.__mHierarchy = Hierarchy() - self.__mReporter = reporter + __mUniqueIdentifier: UniqueIdentifier + __mUniqueVariable: UniqueVariable + + def __init__(self, reporter: bme_utils.Reporter): + self.__mHierarchy = bme_utils.Hierarchy() + self.__mReporter = ReporterWithHierarchy(reporter, self.__mHierarchy) + + self.__mUniqueIdentifier = UniqueIdentifier(self.__mReporter) + self.__mUniqueVariable = UniqueVariable(self.__mReporter) + + _TCheckKey = typing.TypeVar('_TCheckKey') + def __check_key(self, data: dict[str, typing.Any], key: str, expected_type: type[_TCheckKey]) -> _TCheckKey | None: + """ + @brief Check the existance and tyoe of value stored in given dict and key. + @param[in] data The dict need to be checked + @param[in] key The key for fetching value. + @param[in] expected_type The expected type of fetched value. + @return None if error occurs, otherwise the value stored in given dict and key. + """ + gotten_value = data[key] + if gotten_value is None: + # report no key error + self.__mReporter.error(f'Can not find key "{key}". Did you forget it?') + elif not isinstance(gotten_value, expected_type): + # get the type of value + value_type = type(gotten_value) + # format normal error message + err_msg: str = f'The type of value stored inside key "{key}" is incorrect. ' + err_msg += f'Expect "{expected_type.__name__}" got "{value_type.__name__}". ' + # add special note for easily confusing types + # e.g. forget quote number (number literal are recognise as number accidently) + if issubclass(expected_type, str) and issubclass(type(data), (int, float)): + err_msg += 'Did you forgot quote the number?' + # report type error + self.__mReporter.error(err_msg) + else: + # no error, return value + return gotten_value + # error occurs, return null + return None + + def __check_self(self, data: typing.Any, expected_type: type) -> bool: + """ + @brief Check the type of given data. + @return True if type matched, otherwise false. + """ + if data is None: + self.__mReporter.error('Data is unexpected null.') + elif not isinstance(data, expected_type): + # usually this function is checking list or dict, so no scenario that user forget quote literal number. + self.__mReporter.error(f'The type of given data is not expected. Expect "{expected_type.__name__}" got "{type(data).__name__}".') + else: + # no error, return okey + return True + # error occurs, return failed + return False + + # 按层次递归调用检查。 + # 每个层次只负责当前层次的检查。 + # 如果值为列表，字典，则在当前层次检查完其类型（容器本身，对每一项不检查），然后对每一项调用对应层次检查。 + # 如果值不是上述类型（例如整数，浮点数，字符串等），在当前层次检查。 def validate(self, assoc_file: str, prototypes: typing.Any) -> None: - self.__mHierarchy.push(assoc_file) + # reset hierarchy + self.__mHierarchy.clear() + # start to validate + with self.__mHierarchy.safe_push(assoc_file): + self.__validate_prototypes(prototypes) + + def __validate_prototypes(self, prototypes: typing.Any) -> None: + # the most outer structure must be a list + if not self.__check_self(prototypes, list): return + cast_prototypes = typing.cast(list[typing.Any], prototypes) + # iterate prototype + for prototype_index, prototype in enumerate(cast_prototypes): + with self.__mHierarchy.safe_push(prototype_index) as layer: + self.__validate_prototype(layer, prototype) + + def __validate_prototype(self, layer: bme_utils.HierarchyLayer, prototype: typing.Any) -> None: + # check whether self is a dict + if not self.__check_self(prototype, dict): return + cast_prototype = typing.cast(dict[str, typing.Any], prototype) + + # check identifier + identifier = self.__check_key(cast_prototype, TOKEN_IDENTIFIER, str) + if identifier is not None: + # replace hierarchy + layer.emplace(identifier) + # check unique + self.__mUniqueIdentifier.register(identifier) + + # check showcase but don't use check function + # because it is optional. + showcase = cast_prototype[TOKEN_SHOWCASE] + if showcase is not None: + # we only check non-template prototype + with self.__mHierarchy.safe_push(TOKEN_SHOWCASE): + self.__validate_showcase(typing.cast(dict[str, typing.Any], showcase)) + + # check params, vars, vertices, faces, instances + # they are all list + params = self.__check_key(cast_prototype, TOKEN_PARAMS, list) + if params is not None: + cast_params = typing.cast(list[typing.Any], params) + with self.__mHierarchy.safe_push(TOKEN_PARAMS): + for param_index, param in enumerate(cast_params): + with self.__mHierarchy.safe_push(param_index): + self.__validate_param(param) + + vars = self.__check_key(cast_prototype, TOKEN_VARS, list) + if vars is not None: + cast_vars = typing.cast(list[typing.Any], vars) + with self.__mHierarchy.safe_push(TOKEN_VARS): + for var_index, var in enumerate(cast_vars): + with self.__mHierarchy.safe_push(var_index): + self.__validate_var(var) + + vertices = self.__check_key(cast_prototype, TOKEN_VERTICES, list) + if vertices is not None: + cast_vertices = typing.cast(list[typing.Any], vertices) + with self.__mHierarchy.safe_push(TOKEN_VERTICES): + for vertex_index, vertex in enumerate(cast_vertices): + with self.__mHierarchy.safe_push(vertex_index): + self.__validate_vertex(vertex) + + faces = self.__check_key(cast_prototype, TOKEN_FACES, list) + if faces is not None: + cast_faces = typing.cast(list[typing.Any], faces) + with self.__mHierarchy.safe_push(TOKEN_FACES): + for face_index, face in enumerate(cast_faces): + with self.__mHierarchy.safe_push(face_index): + self.__validate_face(face) + + instances = self.__check_key(cast_prototype, TOKEN_INSTANCES, list) + if instances is not None: + cast_instances = typing.cast(list[typing.Any], instances) + with self.__mHierarchy.safe_push(TOKEN_INSTANCES): + for instance_index, instance in enumerate(cast_instances): + with self.__mHierarchy.safe_push(instance_index): + self.__validate_instance(instance) + + def __validate_showcase(self, showcase: dict[str, typing.Any]) -> None: + pass + + def __validate_param(self, param: typing.Any) -> None: + pass + + def __validate_var(self, param: typing.Any) -> None: + pass + + def __validate_vertex(self, param: typing.Any) -> None: + pass + + def __validate_face(self, param: typing.Any) -> None: + pass + + def __validate_instance(self, param: typing.Any) -> None: + pass - self.__mHierarchy.pop() class BMEExtractor(): """ @@ -175,12 +322,12 @@ class BMEExtractor(): """ __mAssocFile: str - __mHierarchy: Hierarchy + __mHierarchy: bme_utils.Hierarchy __mPoWriter: simple_po.PoWriter def __init__(self, po_writer: simple_po.PoWriter): self.__mAssocFile = '' - self.__mHierarchy = Hierarchy() + self.__mHierarchy = bme_utils.Hierarchy() self.__mPoWriter = po_writer def extract(self, assoc_file: str, prototypes: list[dict[str, typing.Any]]) -> None: @@ -198,14 +345,11 @@ class BMEExtractor(): def __extract_prototype(self, prototype: dict[str, typing.Any]) -> None: # get identifier first identifier: str = prototype[TOKEN_IDENTIFIER] - self.__mHierarchy.push(identifier) - - # get showcase node and only write PO file if it is not template prototype - showcase: dict[str, typing.Any] | None = prototype[TOKEN_SHOWCASE] - if showcase is not None: - self.__extract_showcase(showcase) - - self.__mHierarchy.pop() + with self.__mHierarchy.safe_push(identifier): + # get showcase node and only write PO file if it is not template prototype + showcase: dict[str, typing.Any] | None = prototype[TOKEN_SHOWCASE] + if showcase is not None: + self.__extract_showcase(showcase) def __extract_showcase(self, showcase: dict[str, typing.Any]) -> None: # export self name first @@ -217,14 +361,13 @@ class BMEExtractor(): self.__extract_showcase_cfg(cfg_index, cfg) def __extract_showcase_cfg(self, index: int, cfg: dict[str, typing.Any]) -> None: - self.__mHierarchy.push_index(index) + # push cfg index + with self.__mHierarchy.safe_push(index): + # extract field title and description + title: str = cfg[TOKEN_SHOWCASE_CFGS_TITLE] + desc: str = cfg[TOKEN_SHOWCASE_CFGS_DESC] - # extract field title and description - title: str = cfg[TOKEN_SHOWCASE_CFGS_TITLE] - desc: str = cfg[TOKEN_SHOWCASE_CFGS_DESC] + # and export them respectively + self.__add_translation(title) + self.__add_translation(desc) - # and export them respectively - self.__add_translation(title) - self.__add_translation(desc) - - self.__mHierarchy.pop() diff --git a/bbp_ng/tools/bme_utils.py b/bbp_ng/tools/bme_utils.py new file mode 100644 index 0000000..b5c062d --- /dev/null +++ b/bbp_ng/tools/bme_utils.py @@ -0,0 +1,141 @@ +import typing +import collections + +class Reporter(): + """ + General reporter with context support for convenient logging. + """ + + def __init__(self): + pass + + def __report(self, type: str, msg: str, context: str | None) -> None: + strl: str = f'[{type}]' + if context is not None: + strl += f'[{context}]' + strl += ' ' + msg + print(strl) + + def error(self, msg: str, context: str | None = None) -> None: + """ + @brief Report an error. + @param[in] msg The message to show. + @param[in] context The context of this message, e.g. the file path. None if no context. + """ + self.__report('Error', msg, context) + + def warning(self, msg: str, context: str | None = None) -> None: + """ + @brief Report a warning. + @param[in] msg The message to show. + @param[in] context The context of this message, e.g. the file path. None if no context. + """ + self.__report('Warning', msg, context) + + def info(self, msg: str, context: str | None = None) -> None: + """ + @brief Report a info. + @param[in] msg The message to show. + @param[in] context The context of this message, e.g. the file path. None if no context. + """ + self.__report('Info', msg, context) + +class Hierarchy(): + """ + The hierarchy for BME validator and BME extractor. + In BME validator, it build human-readable string representing the location where error happen. + In BME extractor, it build the string used as the context of translation. + """ + + __mStack: collections.deque[str] + + def __init__(self): + self.__mStack = collections.deque() + + def push(self, item: str | int) -> None: + """ + @brief Add an item into the top of this hierarchy. + @details + If given item is string, it will be push into hierarchy directly. + If given item is integer, this function will treat it as a special case, the index. + Function will push it into hierarchy after formatting it (add a pair of bracket around it). + @param[in] item New added item. + """ + if isinstance(item, str): + self.__mStack.append(item) + elif isinstance(item, int): + self.__mStack.append(f'[{item}]') + else: + raise Exception('Unexpected type of item when pushing into hierarchy.') + + def pop(self) -> None: + """ + @brief Remove the top item from hierarchy + """ + self.__mStack.pop() + + def safe_push(self, item: str | int) -> 'HierarchyLayer': + """ + @brief The safe version of push function. + @return A with-context-supported instance which can make sure pushed item popped when leaving scope. + """ + return HierarchyLayer(self, item) + + def clear(self) -> None: + """ + @brief Clear this hierarchy. + """ + self.__mStack.clear() + + def depth(self) -> int: + """ + @brief Return the depth of this hierarchy. + @return The depth of this hierarchy. + """ + return len(self.__mStack) + + def build_hierarchy_string(self) -> str: + """ + @brief Build the string which can represent this hierarchy. + @details It just join every items with `/` as separator. + @return The built string representing this hierarchy. + """ + return '/'.join(self.__mStack) + +class HierarchyLayer(): + """ + An with-context-supported class for Hierarchy which can automatically pop item when leaving scope. + This is convenient for keeping the balance of Hierarchy (avoid programmer accidently forgetting to pop item). + """ + + __mHasPop: bool + __mAssocHierarchy: Hierarchy + + def __init__(self, assoc_hierarchy: Hierarchy, item: str | int): + self.__mAssocHierarchy = assoc_hierarchy + self.__mHasPop = False + self.__mAssocHierarchy.push(item) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() + + def close(self) -> None: + if not self.__mHasPop: + self.__mAssocHierarchy.pop() + self.__mHasPop = True + + def emplace(self, new_item: str | int) -> None: + """ + @brief Replace the content of top item in-place. + @details + In some cases, caller need to replace the content of top item. + For example, at the beginning, we only have index info. + After validating something, we can fetching a more human-readable info, such as name, + now we need replace the content of top item. + @param[in] new_item The new content of top item. + """ + self.__mAssocHierarchy.pop() + self.__mAssocHierarchy.push(new_item)