def eval_planet_rotation(scn_name, obj_name, index=None, time=None): """Evaluate the planets rotation, used by driver. scn_name = Name of a scene which contains the object obj_name = Name of the object to simulate index = index of the rotation channel, usually only z-axis (index=2) changes time = time when to calculate, if not given use current scene time time is in seconds of the simulation returns an Euler in mode ZYX or, if index given, an angle in radians """ scn = bpy.data.scenes.get(scn_name) obj = bpy.data.objects.get(obj_name) if not obj or not scn: errmsg = "DRIVER ERROR: Invalid obj_name ({}) or scn_name ({})" print(errmsg.format(obj_name, scn_name)) return 0 simscn = scn.sssim_scn simrot = obj.sssim_rotation # time = time in seconds, if None use current scene time if time is None: time = simscn.time # rotation_period is also in seconds rotation_period = simrot.rotation_period if rotation_period != 0: rot_z = 2 * pi * time / rotation_period else: # invalid input -> no rotation rot_z = 0 tilt = simrot.axis_tilt planet_rot = Euler((tilt, 0.0, 0.0), 'ZYX') # note that mode is 'ZYX' # rotate around global (not local) z-axis direction = simrot.axis_direction planet_rot.rotate(Euler((0.0, 0.0, direction), 'XYZ')) # rotate around local z-axis # NOTE: we won't use planet_rot.rotate_axis('Z', rot_z) because then # all rotations are between -180 and 180 and for the rotation around # z we need a continous motion with increasing z values planet_rot.z += rot_z if simrot.relative_to_orbit and obj.sssim_obj.object_type == 'PLANET': planet_rot = orbit_rotate(planet_rot, obj.sssim_orbit) if index is None: return planet_rot else: return planet_rot[index]
def getOculusOri(self): self.pyrift.poll() oculus_ori = Quaternion( (self.pyrift.rotation[0], self.pyrift.rotation[1], self.pyrift.rotation[2], self.pyrift.rotation[3])) eu = oculus_ori.to_euler() eu = oculus_ori.to_euler() fix = Euler((-math.pi / 2, 0., math.pi / 2), 'XYZ') ori = Euler((-eu.z, eu.y, -eu.x), 'XYZ') ori.rotate(fix) return ori
def execute(self, context): with open(self.filepath, 'r') as f: lines = f.readlines() if 'Sockets' not in bpy.data.collections: sockets = bpy.data.collections.new('Sockets') else: sockets = bpy.data.collections['Sockets'] if 'Sockets' not in context.scene.collection.children: context.scene.collection.children.link(sockets) set_active_collection('Sockets') for i, line in enumerate(lines): match = socket_regex.match(line.strip()) if match: rotator_match = rotator_regex.match(lines[i + 1]) mesh_name = match.group('mesh') bone_name = match.group('bone') tag = match.group('tag') x = float(match.group('x')) y = float(match.group('y')) z = float(match.group('z')) mesh = context.scene.objects[mesh_name + '.ao'] bone = mesh.data.bones[bone_name] socket_location = mesh.location + bone.head_local + Vector( (x, -y, z)) pitch = rotator_to_deg(float(rotator_match.group('pitch'))) yaw = rotator_to_deg(float(rotator_match.group('yaw'))) roll = rotator_to_deg(float(rotator_match.group('roll'))) rotation = Euler((roll, -pitch, yaw), 'XYZ') rotation.rotate(mesh.rotation_euler) rotation.rotate(bone.matrix) bpy.ops.object.empty_add(type='CUBE', location=socket_location[:], rotation=rotation[:]) bpy.context.active_object.name = tag return {'FINISHED'}
def passive_rotation(data): rotation = Euler((radians(90.0), 0.0, 0.0)) rotation.rotate(data.rotation) return rotation
def import_animations(mdl: MdlV44, armature, scale): bpy.ops.object.select_all(action="DESELECT") armature.select_set(True) bpy.context.view_layer.objects.active = armature bpy.ops.object.mode_set(mode='POSE') if not armature.animation_data: armature.animation_data_create() # for var_pos in ['XYZ', 'YXZ', ]: # for var_rot in ['XYZ', 'XZY', 'YZX', 'ZYX', 'YXZ', 'ZXY', ]: for var_pos in ['XYZ']: for var_rot in ['XYZ']: for anim_desc in mdl.anim_descs: anim_name = f'pos_{var_pos}_rot_{var_rot}_{anim_desc.name}' action = bpy.data.actions.new(anim_name) armature.animation_data.action = action curve_per_bone = {} for bone in anim_desc.anim_bones: if bone.bone_id == -1: continue bone_name = mdl.bones[bone.bone_id].name bone_string = f'pose.bones["{bone_name}"].' group = action.groups.new(name=bone_name) pos_curves = [] rot_curves = [] for i in range(3): pos_curve = action.fcurves.new(data_path=bone_string + "location", index=i) pos_curve.keyframe_points.add(anim_desc.frame_count) pos_curves.append(pos_curve) pos_curve.group = group for i in range(3): # rot_curve = action.fcurves.new(data_path=bone_string + "rotation_quaternion", index=i) rot_curve = action.fcurves.new(data_path=bone_string + "rotation_euler", index=i) rot_curve.keyframe_points.add(anim_desc.frame_count) rot_curves.append(rot_curve) rot_curve.group = group curve_per_bone[bone_name] = pos_curves, rot_curves for bone in anim_desc.anim_bones: if bone.bone_id == -1: continue mdl_bone = mdl.bones[bone.bone_id] bl_bone = armature.pose.bones.get(mdl_bone.name) bl_bone.rotation_mode = 'XYZ' pos_scale = mdl_bone.position_scale rot_scale = mdl_bone.rotation_scale if bone.is_raw_pos: pos_frames = [ Vector( np.multiply(np.multiply(bone.pos, pos_scale), scale)) ] elif bone.is_anim_pos: pos_frames = [ Vector( np.multiply(np.multiply(pos, pos_scale), scale)) for pos in bone.pos_anim ] else: pos_frames = [] if bone.is_raw_rot: rot_frames = [ Euler( np.multiply( Quaternion(bone.quat).to_euler('XYZ'), rot_scale)) ] elif bone.is_anim_rot: rot_frames = [ Euler(np.multiply(rot, rot_scale)) for rot in bone.vec_rot_anim ] else: rot_frames = [] pos_curves, rot_curves = curve_per_bone[mdl_bone.name] for n, pos_frame in enumerate(pos_frames): pos = __swap_components(pos_frame, var_pos) for i in range(3): pos_curves[i].keyframe_points.add(1) pos_curves[i].keyframe_points[-1].co = (n, pos[i]) for n, rot_frame in enumerate(rot_frames): fixed_rot = rot_frame if mdl_bone.parent_bone_index == -1: fixed_rot.x += math.radians(-90) fixed_rot.y += math.radians(180) fixed_rot.z += math.radians(-90) fixed_rot = Euler(__swap_components( fixed_rot, var_rot)) # qx = Quaternion([1, 0, 0], fixed_rot[0]) # qy = Quaternion([0, 1, 0], -fixed_rot[1]) # qz = Quaternion([0, 0, 1], -fixed_rot[2]) # fixed_rot: Euler = (qx @ qy @ qz).to_euler() # fixed_rot.x += mdl_bone.rotation[0] # fixed_rot.y += mdl_bone.rotation[1] # fixed_rot.z += mdl_bone.rotation[2] fixed_rot.rotate( Euler([ math.radians(90), math.radians(0), math.radians(0) ])) fixed_rot.rotate( Euler([ math.radians(0), math.radians(0), math.radians(90) ])) fixed_rot = ( fixed_rot.to_matrix().to_4x4() @ bl_bone.rotation_euler.to_matrix().to_4x4() ).to_euler() for i in range(3): rot_curves[i].keyframe_points.add(1) rot_curves[i].keyframe_points[-1].co = ( n, fixed_rot[i]) bpy.ops.object.mode_set(mode='OBJECT')
def _core(self, context, ob, verts, to_del=[]): if len(verts) < 2: self.report({'ERROR_INVALID_INPUT'}, "Select at least 2 vertices") return mat_wrld = np.array(ob.matrix_world) in_editmode = context.mode == 'EDIT_MESH' if self.align_to_axes: # If we align sources to world axes, we are interested in # the bounds in world coordinates. verts = sbt.transf_vecs(mat_wrld, verts) # If we align sources to axes, we ignore ob's rotation. rotation = Euler() bounds, center = sbio.get_bounds_and_center(verts) if not self.align_to_axes: # Even though we want the ob bounds in object space if align # to axes is false, we still are interested in world scale # and center. bounds *= np.array(ob.matrix_world.to_scale()) center = sbt.transf_point(mat_wrld, center) rotation = ob.matrix_world.to_euler() if self.delete_original and in_editmode: mode = context.tool_settings.mesh_select_mode if mode[0]: del_type = 'VERTS' elif mode[1]: del_type = 'EDGES' else: del_type = 'FACES' for o in to_del: sbmm.remove_selection(o.data, type=del_type) if self.replace_by == 'CYLINDER_Z': bpy.ops.mesh.primitive_cylinder_add( {'active_object': ob}, vertices=self.resolution, radius=self.metric(bounds[:2]) * 0.5, depth=bounds[2], end_fill_type='TRIFAN', location=center, rotation=rotation) elif self.replace_by == 'CYLINDER_Y': rotation.rotate(Euler((1.57, 0.0, 0.0))) bpy.ops.mesh.primitive_cylinder_add( {'active_object': ob}, vertices=self.resolution, radius=self.metric(bounds[::2]) * 0.5, depth=bounds[1], end_fill_type='TRIFAN', location=center, rotation=rotation) elif self.replace_by == 'CYLINDER_X': rotation.rotate(Euler((0.0, 1.57, 0.0))) bpy.ops.mesh.primitive_cylinder_add( {'active_object': ob}, vertices=self.resolution, radius=self.metric(bounds[1:]) * 0.5, depth=bounds[0], end_fill_type='TRIFAN', location=center, rotation=rotation) elif self.replace_by == 'CUBOID': if in_editmode: sbmm.add_box_to_obj(ob=ob, location=center, rotation=rotation, size=bounds) else: sbmm.add_box_to_scene(context, center, rotation, bounds) elif self.replace_by == 'SPHERE': bpy.ops.mesh.primitive_uv_sphere_add({'active_object': ob}, segments=self.resolution * 2, ring_count=self.resolution, radius=self.metric(bounds) * 0.5, location=center, rotation=rotation) if not in_editmode: # apply material if existent in original try: mat = ob.data.materials[0] except IndexError: pass else: context.object.data.materials.append(mat) if self.delete_original: for o in to_del: bpy.data.objects.remove(o)
def BlockDrawTypeLineType(self, block: Block, component: Component, vanilla_skins=False) -> 'Object': ''' This is the draw type intended for line type blocks. These blocks have a position, scale, rotation, start position, end position, start rotation and end rotation. These values are used to draw a block that connects 2 points. Parameters block : Block : Block to import component : Component : Component to import vanilla_skins : Bool : Import vanilla skins Returns : Object Exceptions : None ''' # Import the connector, start and end objects connector = self.ImportCustomModel(component.line_type_middle) start = self.ImportCustomModel(component.line_type_end) end = self.ImportCustomModel(component.line_type_start) # Set the material for models if self.setting_GenerateMaterial: material = self.GenerateMaterial( block, component, component.skin_name ) #if not self.setting_use_vanilla_skin else self.GenerateMaterial(block, component, "TemplateB") start.active_material = material end.active_material = material connector.active_material = material # Create the empty object. We'll be using it as # a parent parent = bpy.data.objects.new("empty", None) parent.empty_display_size = 0.25 parent.empty_display_type = 'CUBE' bpy.data.collections[bpy.context.view_layer.active_layer_collection. name].objects.link(parent) # Set the location of the blocks start.location = Vector(block.GetLineStartPosition()) end.location = Vector(block.GetLineEndPosition()) connector.location = Vector(block.GetLineStartPosition()) parent.location = Vector((block.getVectorPosition())) # Set parents of the start, end # and connector block to the empty object start.parent = parent end.parent = parent # Set the rotation of the parent, So it'll # transforming the other child blocks as well parent.rotation_mode = 'QUATERNION' parent.rotation_quaternion = Quaternion( block.getQuarternion()).inverted() parent.rotation_mode = 'XYZ' # Set the name of the blocks. We'll be # using the GUID in the name so it'll be # easier to debug parent.name = "LineType_" + block.guid start.name = "StartPoint_" + block.guid end.name = "EndPoint_" + block.guid connector.name = "Connector_" + block.guid # Reset the parent transformation data so that # the rotation is (0,0,0). Basically doing # parenting an object while keeping the transformation self.ResetParentTransformRotation(end, parent) self.ResetParentTransformRotation(start, parent) # Set the rotation of the start block start_rot = Euler(block.GetLineStartRotation()) start_rot.rotate(block.GetGlobalMachineRotation().inverted()) start.rotation_euler = start_rot start.rotation_mode = 'ZXY' self.InvertRotation(start) # Set the rotation of the end block end_rot = Euler(block.GetLineEndRotation()) end_rot.rotate(block.GetGlobalMachineRotation().inverted()) end.rotation_euler = end_rot end.rotation_mode = 'ZXY' self.InvertRotation(end) # Set the scale of the parent object, # which will deform the blocks parent.scale = block.getScale() # We'll be using a Track-To contraint to point the start block at the end block. # So here we'll be creating the contraint and configuring it to point at the end # block connector.parent = parent self.ResetParentTransformRotation(connector, parent) constraint = connector.constraints.new('TRACK_TO') constraint.track_axis = "TRACK_Y" constraint.up_axis = "UP_X" constraint.target = end distance = self.GetDistance([start, end]) connector.dimensions[1] = distance # If the length between the starting and end block is less than a specific value # the end and the connector block will be deleted. This specific value... we dont # know if distance < self.setting_brace_threshhold: bpy.data.objects.remove(connector) bpy.data.objects.remove(end) if self.setting_join_line_components: for obj in list(bpy.context.selected_objects): obj.select_set(False) bpy.context.view_layer.objects.active = start start.select_set(True) if not distance < self.setting_brace_threshhold: connector.select_set(True) end.select_set(True) bpy.ops.object.join() current_obj = bpy.context.selected_objects[0] if self.setting_clean_up_action == 'DELETE_EMPTIES': self.UnparentKeepTransform(current_obj) bpy.data.objects.remove(parent) elif self.setting_clean_up_action == 'HIDE_EMPTIES': parent.hide_set(True) return current_obj return parent
import time from rift import PyRift from mathutils import Quaternion, Euler, Vector # Functions def poll(): bge.logic.rift.pollSensor() bge.logic.rotation = Quaternion((bge.logic.rift.headPose[3], bge.logic.rift.headPose[4], bge.logic.rift.headPose[5], bge.logic.rift.headPose[6])) bge.logic.position = Vector((bge.logic.rift.headPose[0],bge.logic.rift.headPose[1],bge.logic.rift.headPose[2])) # Main try: eu = bge.logic.rotation.to_euler() fix = Euler((-1.57, 0, 0), 'XYZ') rot = Euler((-eu.z, eu.y, -eu.x), 'XYZ') rot.rotate(fix) bge.logic.prev_orientation = rot; poll() except: bge.logic.rift = PyRift() bge.logic.rift.connect() scene_e = bge.logic.getCurrentScene() cam_e = scene_e.active_camera bge.logic.init_position = Vector((cam_e.localPosition[0],cam_e.localPosition[1],cam_e.localPosition[2])) bge.logic.init_orientation = cam_e.localOrientation.to_euler() eu = Euler() fix = Euler((1.57, 0, 0), 'XYZ')
def hitbox_rotation(data): rotation = Euler((radians(90.0), 0.0, 0.0)) rotation.rotate(data.rotation) return rotation