def execute(self, context): keywords = self.as_keywords(ignore=('filter_glob',)) print("executing", keywords["filepath"]) data = {} with open(os.fsencode(keywords["filepath"]), "r") as file: exec(file.read(), data) del data["__builtins__"] if "points" not in data or "boxes" not in data: return {'CANCELLED'} scene = bpy.context.scene points_obj = bpy.data.objects.new("points", None) points_obj.matrix_world = axis_conversion(from_forward='-Z', from_up='Y').to_4x4() scene.objects.link(points_obj) scene.update() points_obj.layers = tuple([i == 1 for i in range(20)]) boxes_obj = bpy.data.objects.new("boxes", None) boxes_obj.matrix_world = axis_conversion(from_forward='-Z', from_up='Y').to_4x4() scene.objects.link(boxes_obj) scene.update() boxes_obj.layers = tuple([i == 1 for i in range(20)]) def makeBox(middle, scale): bpy.ops.mesh.primitive_cube_add(location=middle) cube = scene.objects.active cube.scale = scale cube.show_name = True cube.show_wire = True cube.draw_type = 'WIRE' return cube for key, pos in data["points"].items(): if len(pos) == 6: # spawn points with random variance middle, size = Vector(pos[:3]), Vector(pos[3:]) if "spawn" in key.lower(): size.y = 0.05 cube = makeBox(middle, size) cube.parent = points_obj cube.name = key else: empty = bpy.data.objects.new(key, None) empty.location = pos[:3] empty.empty_draw_size = 0.45 empty.parent = points_obj empty.show_name = True scene.objects.link(empty) for key, pos in data["boxes"].items(): middle, size = Vector(pos[:3]), flpV(Vector(pos[6:9])) cube = makeBox(middle, size) cube.parent = boxes_obj cube.name = key scene.update() return {'FINISHED'}
def savecob(operator, context, filepath, triangulate, check_existing): print("exporting", filepath) global_matrix = axis_conversion(to_forward='-Z', to_up='Y').to_4x4() scene = context.scene obj = scene.objects.active mesh = obj.to_mesh(scene, True, 'PREVIEW') mesh.transform(global_matrix * obj.matrix_world) # inverse transformation if triangulate or any([len(face.vertices) != 3 for face in mesh.tessfaces]): print("triangulating...") with to_bmesh(mesh, save=True) as bm: bmesh.ops.triangulate(bm, faces=bm.faces) mesh.update(calc_edges=True, calc_tessface=True) with open(os.fsencode(filepath), 'wb') as file: def writestruct(s, *args): file.write(struct.pack(s, *args)) writestruct('I', COB_FILE_ID) writestruct('I', len(mesh.vertices)) writestruct('I', len(mesh.tessfaces)) for i, vert in enumerate(mesh.vertices): writestruct('fff', *vert.co) for face in mesh.tessfaces: assert len(face.vertices) == 3 for vertid in face.vertices: writestruct('I', vertid) for face in mesh.tessfaces: writestruct('fff', *face.normal) return {'FINISHED'}
def execute(self, context): from . import stl_utils from . import blender_utils from mathutils import Matrix paths = [os.path.join(self.directory, name.name) for name in self.files] scene = context.scene # Take into account scene's unit scale, so that 1 inch in Blender gives 1 inch elsewhere! See T42000. global_scale = self.global_scale if scene.unit_settings.system != 'NONE' and self.use_scene_unit: global_scale /= scene.unit_settings.scale_length global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() * Matrix.Scale(global_scale, 4) if not paths: paths.append(self.filepath) if bpy.ops.object.mode_set.poll(): bpy.ops.object.mode_set(mode='OBJECT') if bpy.ops.object.select_all.poll(): bpy.ops.object.select_all(action='DESELECT') for path in paths: objName = bpy.path.display_name(os.path.basename(path)) tris, pts = stl_utils.read_stl(path) blender_utils.create_and_link_mesh(objName, tris, pts, global_matrix) return {'FINISHED'}
def __init__(self, xml, sensor): self.id = int(xml.attrib["id"]) self.label = xml.attrib["label"] self.sensor_id = int(xml.attrib["sensor_id"]) if(xml.attrib["enabled"] == "true"): self.enabled = True else: self.enabled = False self.resolution = {"width": sensor.resolution['width'], "height": sensor.resolution['height'], } try: t = xml.find("transform").text l = t.split(" ") v = [] for i in range(len(l)): v.append(float(l[i])) m = [] i = 0 while(i < 16): m.append(tuple([v[i], v[i + 1], v[i + 2], v[i + 3]])) i += 4 matrix = Matrix((m[0], m[1], m[2], m[3])) self.transform = t except Exception as e: matrix = Matrix() self.transform = None self.enabled = False conversion_matrix = axis_conversion(from_forward='Z', from_up='-Y', to_forward='-Z', to_up='Y').to_4x4() # self.matrix = matrix * conversion_matrix self.matrix = matrix @ conversion_matrix self._xml = xml
def execute(self, context): from mathutils import Matrix global_matrix = (Matrix.Scale(self.global_scale, 4) * axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4()) return write_json_file(context, self.filepath, global_matrix)
def execute(self, context): # print("Selected: " + context.active_object.name) from . import import_obj if self.split_mode == 'OFF': self.use_split_objects = False self.use_split_groups = False else: self.use_groups_as_vgroups = False keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "filter_glob", "split_mode", )) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix if bpy.data.is_saved and context.preferences.filepaths.use_relative_paths: import os keywords["relpath"] = os.path.dirname(bpy.data.filepath) return import_obj.load(context, **keywords)
def execute(self, context): from mathutils import Matrix if not self.filepath: raise Exception("filepath not set") global_matrix = Matrix() global_matrix[0][0] = \ global_matrix[1][1] = \ global_matrix[2][2] = self.global_scale if not self.use_rotate_workaround: global_matrix = (global_matrix * axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4()) keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "global_scale", "check_existing", "filter_glob", "xna_validate", )) keywords["global_matrix"] = global_matrix from . import export_fbx return export_fbx.save(self, context, **keywords)
def execute(self, context): from . import import_x if self.split_mode == 'OFF': self.use_split_objects = False self.use_split_groups = False else: self.use_groups_as_vgroups = False keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "filter_glob", "split_mode", )) keywords["naming_method"] = int(self.naming_method) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix bel.fs.saveOptions(self,'import_scene.x', self.as_keywords(ignore=( "filter_glob", "filepath", ))) return import_x.load(self, context, **keywords)
def bone_transform(joint_matrix): m = mathutils.Matrix(joint_matrix) m = m.inverted().transposed() rot = axis_conversion(from_forward='-Z', from_up='Y').to_4x4() m = rot * m m[0][3] = -m[0][3] # flip across x axis return m
def execute(self, context): warnings.resetwarnings() # Get the matrix to transform the model to "WCP/SO" orientation wc_orientation_matrix = axis_conversion( self.axis_forward, self.axis_up, "Z", "Y" ).to_4x4() # Create the output file if it doesn't already exist try: outfile = open(self.filepath, "x") outfile.close() except FileExistsError: self.report({"INFO"}, "File already exists!") # NOTE: BSP Tree generation is not implemented! # As a fallback measure, I'm hard-coding this attribute self.generate_bsp = False exporter = getattr(export_iff, self.backend_class_name)( self.filepath, self.texnum, self.apply_modifiers, self.active_as_lod0, self.use_facetex, wc_orientation_matrix, self.generate_bsp ) exporter.export() with warnings.catch_warnings(record=True) as wlist: for warning in wlist: self.report({"WARNING"}, warning.message) return {"FINISHED"}
def execute(self, context): if context.active_object: if context.active_object.mode == 'EDIT': print("AC3D was not exported due to being in edit mode.") bpy.ops.error.message('INVOKE_DEFAULT', type = "Error", message = 'Cannot export AC3D in edit mode.') return {'FINISHED'} from . import export_ac3d keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "filter_glob", "check_existing", "export_rots", )) global_matrix = axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ) keywords["global_matrix"] = global_matrix ex_rot = False if self.export_rots == 'export': ex_rot = True keywords["export_rot"] = ex_rot t = time.mktime(datetime.datetime.now().timetuple()) export_ac3d.ExportAC3D(self, context, **keywords) t = time.mktime(datetime.datetime.now().timetuple()) - t print('Finished exporting in', t, 'seconds') return {'FINISHED'}
def execute(self, context): from . import stl_utils from . import blender_utils import itertools from mathutils import Matrix keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "global_scale", "check_existing", "filter_glob", "use_scene_unit", "use_mesh_modifiers", )) scene = context.scene # Take into account scene's unit scale, so that 1 inch in Blender gives 1 inch elsewhere! See T42000. global_scale = self.global_scale if scene.unit_settings.system != 'NONE' and self.use_scene_unit: global_scale *= scene.unit_settings.scale_length global_matrix = axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() * Matrix.Scale(global_scale, 4) faces = itertools.chain.from_iterable( blender_utils.faces_from_mesh(ob, global_matrix, self.use_mesh_modifiers) for ob in context.selected_objects) stl_utils.write_stl(faces=faces, **keywords) return {'FINISHED'}
def execute(self, context): #from . import import_off keywords = self.as_keywords(ignore=('axis_forward', 'axis_up', 'filter_glob', )) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() mesh = load(self, context, **keywords) if not mesh: return {'CANCELLED'} scene = bpy.context.scene obj = bpy.data.objects.new(mesh.name, mesh) scene.objects.link(obj) scene.objects.active = obj obj.select = True obj.matrix_world = global_matrix scene.update() return {'FINISHED'}
def execute(self, context): from . import decode decode.import_world(self.properties.filepath, axis_conversion(to_up = self.up_axis, to_forward = self.forward_axis).to_4x4() * self.scale, self.include_objects, self.include_models, self.include_hitboxes, self.hide_hitboxes) context.scene.revolt_world.scale = self.scale context.scene.revolt_world.up_axis = self.up_axis context.scene.revolt_world.forward_axis = self.forward_axis return {'FINISHED'}
def execute(self, context): from . import import_x3d keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "filter_glob")) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up).to_4x4() keywords["global_matrix"] = global_matrix return import_x3d.load(self, context, **keywords)
def transform_matrix(self, matrix): # Blender is Z up but Mitsuba is Y up, convert the matrix global_matrix = axis_conversion(to_forward="-Z", to_up="Y").to_4x4() l = matrix_to_list(global_matrix * matrix) mat = Matrix4x4(l) transform = Transform(mat) return transform
def execute(self, context): from . import import_mpet matrix = axis_conversion( from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() return import_mpet.load(self, context, self.filepath, matrix)
def execute(self, context): keywords = self.as_keywords(ignore=('axis_forward', 'axis_up', 'filter_glob', 'check_existing', )) global_matrix = axis_conversion().to_4x4() keywords['global_matrix'] = global_matrix return save(self, context, **keywords)
def execute(self, context): from . import export_i0r from mathutils import Matrix keywords = self.as_keywords(ignore=("filter_glob","path_mode","filepath","check_existing",)) global_matrix = (Matrix.Scale(1.0, 4) * axis_conversion(to_forward='-Z',to_up='Y',).to_4x4()) keywords["global_matrix"] = global_matrix keywords["version"] = version return export_i0r.save(self.filepath, **keywords)
def execute(self, context): from . import export_ogf from mathutils import Matrix # Calculate the global transform global_rotation = axis_conversion(to_forward = self.axis_forward, to_up = self.axis_up).to_4x4() global_matrix = Matrix() global_matrix[2][2] = self.global_scale global_matrix = global_matrix * global_rotation return export_ogf.write(context, self.filepath, self.use_apply_modifiers, self.include_normals, self.include_tangents, self.include_bitangents, self.include_uvs, self.include_colors, self.include_weights, self.bones_per_vertex, global_matrix, self.export_skeleton, self.export_materials, self.copy_images, self.float_precision)
def execute(self, context): from . import export_x3d from mathutils import Matrix keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "global_scale", "check_existing", "filter_glob")) global_matrix = axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up).to_4x4() * Matrix.Scale( self.global_scale, 4 ) keywords["global_matrix"] = global_matrix return export_x3d.save(self, context, **keywords)
def execute(self, context): keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "filter_glob")) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix print(keywords) importCSV(**keywords) return {'FINISHED'}
def obj_export(scale, obj_path): if len(bpy.context.selected_objects) == 0: return() from mathutils import Matrix global_matrix = (Matrix.Scale(scale, 4) * axis_conversion(to_forward= '-Z', to_up='Y', ).to_4x4()) export_obj.save(bpy.context, filepath = obj_path, global_matrix = global_matrix, use_triangles = True, use_selection = True, path_mode = 'STRIP')
def _create_region(self, id, region, empty): center = region["center"] size = region["size"] r = region["R"] # 1 unit cube l = 1.0 / 2 dv = [(+l, +l, -l), (+l, -l, -l), (-l, -l, -l), (-l, +l, -l), (+l, +l, +l), (+l, -l, +l), (-l, -l, +l), (-l, +l, +l), ] df = [(0, 1, 2, 3), (4, 7, 6, 5), (0, 4, 5, 1), (1, 5, 6, 2), (2, 6, 7, 3), (4, 0, 3, 7), ] me = bpy.data.meshes.new("{0}_region".format(id)) me.from_pydata(dv, [], df) conversion_matrix = axis_conversion(from_forward='Z', from_up='-Y', to_forward='-Z', to_up='Y').to_4x4() o = add_object("{0}_region".format(id), me) mt = Matrix.Translation(Vector(center)).to_4x4() mr = Matrix(r.to_4x4() @ conversion_matrix).inverted() ms = Matrix(((size[0], 0, 0), (0, size[1], 0), (0, 0, size[2]), )).to_4x4() m = mt @ mr @ ms o.matrix_world = m o.parent = empty o.display_type = 'WIRE' # delete faces, why are they even created? because i am lazy me = o.data bm = bmesh.new() bm.from_mesh(me) for f in bm.faces: f.select_set(True) # DEL_ONLYFACES > context=3 # bmesh.ops.delete(bm, geom=bm.faces, context='FACES', ) bmesh.ops.delete(bm, geom=bm.faces, context='FACES_ONLY', ) o.data = bm.to_mesh(me) return o
def execute(self, context): from . import export_x3d keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "check_existing", "filter_glob", )) global_matrix = axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix return export_x3d.save(self, context, **keywords)
def execute(self, context): fnames = [f.name for f in self.files] if len(fnames) == 0 or not os.path.isfile(os.path.join(self.directory,fnames[0])): self.report({'ERROR'}, 'No file is selected for import') return {'FINISHED'} matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up) if self.flip_x_axis: matrix = Matrix.Scale(-1, 3, (1.0, 0.0, 0.0)) * matrix conv = RipConversion() conv.matrix = matrix conv.flip_winding = self.flip_winding conv.use_normals = self.use_normals conv.use_weights = self.use_weights conv.filter_unused_attrs = self.filter_unused_attrs conv.filter_unused_textures = self.filter_unused_textures conv.normal_max_int = self.normal_int conv.normal_scale = list(map(self.get_normal_scale, range(3))) conv.uv_max_int = self.uv_int conv.uv_scale = list(map(self.get_uv_scale, range(2))) if self.detect_duplicates: conv.dedup = DuplicateTracker() conv.dedup.hash_missing_textures = not self.notex_duplicates if self.cross_duplicates: conv.dedup.init_duplicate_tables() conv.filter_duplicates = self.skip_duplicates if self.override_attrs: table = {} for tag, prop in self.override_props: vals = getattr(self, prop).split(',') nums = map(int, filter(lambda s: re.fullmatch(r'^\d+$',s), vals)) table[tag] = list(nums) conv.attr_override_table = table riplog = RipLogInfo() if self.use_shaders else None for file in sorted(fnames): rf = RipFile(os.path.join(self.directory, file), riplog) rf.parse_file() if self.use_shaders: rf.parse_shaders() if self.skip_untextured and not rf.has_textures(): continue conv.convert_object(rf, context.scene, file) return {'FINISHED'}
def execute(self, context): from mathutils import Matrix keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "global_scale", "check_existing", "filter_glob", )) scale_mt = Matrix.Scale(self.global_scale, 4) global_matrix = (scale_mt * axis_conversion(to_forward='-Z', to_up='Y').to_4x4()) keywords["global_matrix"] = global_matrix return save(self, context, **keywords)
def execute(self, context): keywords = self.as_keywords(ignore=('filter_glob',)) mesh = load(self, context, **keywords) if not mesh: return {'CANCELLED'} scene = bpy.context.scene obj = bpy.data.objects.new(mesh.name, mesh) scene.objects.link(obj) scene.objects.active = obj obj.select = True obj.matrix_world = axis_conversion(from_forward='-Z', from_up='Y').to_4x4() scene.update() return {'FINISHED'}
def execute(self, context): keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "filter_glob", )) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix from . import import_bvh return import_bvh.load(context, report=self.report, **keywords)
def execute(self, context): print("Selected: " + context.active_object.name) if not self.properties.filepath: raise Exception("filename not set") global_matrix = (axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4()) keywords = self.as_keywords(ignore=("filter_glob", "check_existing", "filter_glob", )) keywords["global_matrix"] = global_matrix return save(self, context, **keywords)
def execute(self, context): from mathutils import Matrix if not self.filepath: raise Exception("filepath not set") global_matrix = Matrix() global_matrix[0][0] = \ global_matrix[1][1] = \ global_matrix[2][2] = self.global_scale global_matrix = (global_matrix * axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up,).to_4x4()) keywords = self.as_keywords(ignore=("check_existing", "filter_glob", "axis_forward", "axis_up")) keywords["global_matrix"] = global_matrix from . import export_fbx return export_fbx.save(self, context, **keywords)
def execute(self, context): from . import import_dn_msh, import_dn_ani keywords = self.as_keywords(ignore=( "axis_forward", "axis_up", "filter_glob", )) keywords["global_matrix"] = axis_conversion( from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() if keywords["filepath"].lower().endswith(".msh"): return import_dn_msh.load(context, **keywords) return import_dn_ani.load(context, **keywords)
def execute(self, context): scene = { 'actions': list(bpy.data.actions), 'cameras': list(bpy.data.cameras), 'lamps': list(bpy.data.lamps), 'images': list(bpy.data.images), 'materials': list(bpy.data.materials), 'meshes': list(bpy.data.meshes), 'objects': list(bpy.data.objects), 'scenes': list(bpy.data.scenes), 'textures': list(bpy.data.textures), } # Copy properties to settings settings = self.as_keywords(ignore=( "filter_glob", "axis_up", "axis_forward", )) # Set the output directory based on the supplied file path settings['gltf_output_dir'] = os.path.dirname(self.filepath) # Calculate a global transform matrix to apply to a root node settings['nodes_global_matrix'] = axis_conversion( to_forward=self.axis_forward, to_up=self.axis_up).to_4x4() gltf = blendergltf.export_gltf(scene, settings) with open(self.filepath, 'w') as fout: # Figure out indentation if self.pretty_print: indent = 4 else: indent = None # Dump the JSON json.dump(gltf, fout, indent=indent, sort_keys=True, check_circular=False) if self.pretty_print: # Write a newline to the end of the file fout.write('\n') return {'FINISHED'}
def execute(self, context): from . import export_i0r from mathutils import Matrix keywords = self.as_keywords(ignore=( "filter_glob", "path_mode", "filepath", "check_existing", )) global_matrix = (Matrix.Scale(1.0, 4) * axis_conversion( to_forward='-Z', to_up='Y', ).to_4x4()) keywords["global_matrix"] = global_matrix keywords["version"] = version return export_i0r.save(self.filepath, **keywords)
def execute(self, context): from . import stl_utils from . import blender_utils import itertools from mathutils import Matrix keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "use_selection", "global_scale", "check_existing", "filter_glob", "use_scene_unit", "use_mesh_modifiers", "batch_mode" )) scene = context.scene if self.use_selection: data_seq = context.selected_objects else: data_seq = scene.objects # Take into account scene's unit scale, so that 1 inch in Blender gives 1 inch elsewhere! See T42000. global_scale = self.global_scale if scene.unit_settings.system != 'NONE' and self.use_scene_unit: global_scale *= scene.unit_settings.scale_length global_matrix = axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() @ Matrix.Scale(global_scale, 4) if self.batch_mode == 'OFF': faces = itertools.chain.from_iterable( blender_utils.faces_from_mesh(ob, global_matrix, self.use_mesh_modifiers) for ob in data_seq) stl_utils.write_stl(faces=faces, **keywords) elif self.batch_mode == 'OBJECT': prefix = os.path.splitext(self.filepath)[0] keywords_temp = keywords.copy() for ob in data_seq: faces = blender_utils.faces_from_mesh(ob, global_matrix, self.use_mesh_modifiers) keywords_temp["filepath"] = prefix + bpy.path.clean_name(ob.name) + ".stl" stl_utils.write_stl(faces=faces, **keywords_temp) return {'FINISHED'}
def execute(self, context): from . import export_x3d from mathutils import Matrix keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "global_scale", "check_existing", "filter_glob", )) global_matrix = axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() @ Matrix.Scale(self.global_scale, 4) keywords["global_matrix"] = global_matrix return export_x3d.save(context, **keywords)
def execute(self, context): from . import stl_utils from . import blender_utils import itertools from mathutils import Matrix global_matrix = axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() * Matrix.Scale(self.global_scale, 4) faces = itertools.chain.from_iterable( blender_utils.faces_from_mesh(ob, global_matrix, self.use_mesh_modifiers) for ob in context.selected_objects) stl_utils.write_stl(self.filepath, faces, self.ascii) return {'FINISHED'}
def _load_obj(self, context, obj_file_path): # We just use Blender's existing obj importer. The obj should not have # a corresponding .mtl file, since we will get materials from the dson # file. Didn't see a way to make mtl loading optional, so we just hope # there isn't a mtl file loaded and there are issues materials. from io_scene_obj.import_obj import load as load_obj # Blender and DAZStudio use different axis orientations, so adjust obj # to work with Blender (same as native obj importer). global_matrix = axis_conversion(from_forward='-Z', from_up='Y').to_4x4() load_obj(self, context, obj_file_path, use_split_groups=False, use_image_search=False, global_matrix=global_matrix)
def __init__(self, xml, id): self.xml = xml self.id = id self.sensors = [] self.cameras = [] sens = self.xml.findall(".//sensor") for s in sens: sd = PSCSensor(s) self.sensors.append(sd) self.cameras = [] cams = self.xml.findall(".//camera") for c in cams: sensor = self.sensors[int(c.attrib["sensor_id"])] cam = PSCCamera(c, sensor) self.cameras.append(cam) self.region = {} reg = self.xml.find(".//region") c = reg.find("center").text.split(" ") cf = [float(v) for v in c] self.region['center'] = cf s = reg.find("size").text.split(" ") sf = [float(v) for v in s] self.region['size'] = sf r = reg.find("R").text.split(" ") rf = [float(v) for v in r] m = [] i = 0 while (i < 9): m.append(tuple([rf[i], rf[i + 1], rf[i + 2]])) i += 3 matrix = Matrix((m[0], m[1], m[2])) conversion_matrix = axis_conversion(from_forward='Z', from_up='-Y', to_forward='-Z', to_up='Y').to_3x3() matrix = matrix @ conversion_matrix self.region['R'] = matrix
def execute(self, context): from . import delta_export from mathutils import Matrix keywords = self.as_keywords(ignore=( "axis_forward", "axis_up", "check_existing", "filter_glob", )) global_matrix = axis_conversion( to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix return delta_export.write_scene_file(context, **keywords)
def execute(self, context): import imp from . import import_mc imp.reload(import_mc) keywords = self.as_keywords(ignore=( "forward_axis", "up_axis", "filter_glob", )) global_matrix = axis_conversion( from_forward=self.forward_axis, from_up=self.up_axis, ).to_4x4() keywords["global_matrix"] = global_matrix return import_mc.load(self, context, **keywords)
def execute(self, context): from . import import_cao keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "filter_glob" )) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix if bpy.data.is_saved and context.user_preferences.filepaths.use_relative_paths: import os keywords["relpath"] = os.path.dirname((bpy.data.path_resolve("filepath", False).as_bytes())) return import_cao.load(self, context, **keywords)
def execute(self, context): paths = [ os.path.join(self.directory, name.name) for name in self.files ] if not paths: paths.append(self.filepath) from mathutils import Matrix from . import import_forsaken_cob global_matrix = (Matrix.Scale(1.0 / 256.0, 4) * axis_conversion( to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4()) import_forsaken_cob.load(self, context, self.filepath, global_matrix) return {'FINISHED'}
def execute(self, context): from mathutils import Matrix if not self.filepath: raise Exception("filepath not set") global_matrix = (axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4()) keywords = self.as_keywords(ignore=("check_existing", "filter_glob", "ui_tab", )) keywords["global_matrix"] = global_matrix from . import export_fbx_bin return export_fbx_bin.save(self, context, **keywords)
def execute(self, context): # print("Selected: " + context.active_object.name) from . import import_obj keywords = self.as_keywords(ignore=( "axis_forward", "axis_up", "filter_glob", "split_mode", )) global_matrix = axis_conversion( from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix return import_obj.load(self, context, **keywords)
def execute(self, context): from . import export_crown from mathutils import Matrix keywords = self.as_keywords(ignore=( "axis_forward", "axis_up", "global_scale", "check_existing", "filter_glob", )) scale_mt = Matrix.Scale(self.global_scale, 4) global_matrix = (scale_mt * axis_conversion(to_forward='-Z', to_up='Y').to_4x4()) keywords["global_matrix"] = global_matrix return export_crown.save(self, context, **keywords)
def execute(self, context): from . import export_lvl from mathutils import Matrix keywords = self.as_keywords(ignore=("global_scale", "check_existing", "filter_glob", "axis_forward", "axis_up", )) global_matrix = (Matrix.Scale(self.global_scale, 4) @ axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4()) keywords["global_matrix"] = global_matrix keywords["export_format"] = 'SA2BLVL' return export_lvl.write(context, **keywords)
def execute(self, context): from . import import_ac3d keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "filter_glob", )) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix t = time.mktime(datetime.datetime.now().timetuple()) import_ac3d.ImportAC3D(self, context, **keywords) t = time.mktime(datetime.datetime.now().timetuple()) - t print('Finished importing in', t, 'seconds') return {'FINISHED'}
def execute(self, context): warnings.resetwarnings() # WIP wc_orientation_matrix = axis_conversion("Z", "Y").to_4x4() self.import_bsp = False importer = getattr(import_iff, self.backend_class_name)(self.filepath, self.texname, wc_orientation_matrix, self.import_bsp) importer.load() with warnings.catch_warnings(record=True) as wlist: for warning in wlist: self.report({"WARNING"}, warning.message) return {"FINISHED"}
def execute(self, context): from mathutils import Matrix keywords = self.as_keywords(ignore=( "axis_forward", "axis_up", "global_scale", "check_existing", "filter_glob", )) keywords["use_selection"] = context.scene.pbd_prop.use_selection keywords["use_order"] = context.scene.pbd_prop.use_draw_order keywords["use_animation"] = context.scene.pbd_prop.use_animation global_matrix = (Matrix.Scale(self.global_scale, 4) * axis_conversion( to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4()) keywords["global_matrix"] = global_matrix input_path = keywords["filepath"] export_obj.save(context, **keywords) if context.scene.pbd_prop.convert_to_json: export_json.save( context, export_type=context.scene.pbd_prop.json_export_type, input_path=input_path, output_path=context.scene.pbd_prop.json_output_path, asset_root=context.scene.pbd_prop.json_asset_root, script_path=context.user_preferences. addons["bracket_io_scene_pbd"].preferences.script_path, precision=context.scene.pbd_prop.json_precision, ignore_normals=context.scene.pbd_prop.json_ignore_normals, include_meta=context.scene.pbd_prop.json_include_meta, force_texture=context.scene.pbd_prop.json_force_texture, addition_option=context.scene.pbd_prop.json_additional_option, ) return {"FINISHED"}
def export(filepath, use_mesh_modifiers=True, batch_mode='OFF'): global_matrix = axis_conversion( to_forward='Y', to_up='Z', ).to_4x4() * Matrix.Scale(1.0, 4) if batch_mode == 'OFF': faces = itertools.chain.from_iterable( blender_utils.faces_from_mesh(ob, global_matrix, use_mesh_modifiers) for ob in context.scene.objects) stl_utils.write_stl(faces=faces, filepath=filepath) elif batch_mode == 'OBJECT': prefix = os.path.splitext(filepath)[0] for ob in context.scene.objects: faces = blender_utils.faces_from_mesh(ob, global_matrix, use_mesh_modifiers) stl_utils.write_stl(faces=faces, filepath=filepath)
def __init__(self, xml, sensor): self.id = int(xml.attrib["id"]) self.label = xml.attrib["label"] self.sensor_id = int(xml.attrib["sensor_id"]) # if(xml.attrib["enabled"] == "true"): # self.enabled = True # else: # self.enabled = False self.enabled = True self.resolution = { "width": sensor.resolution['width'], "height": sensor.resolution['height'], } try: t = xml.find("transform").text l = t.split(" ") v = [] for i in range(len(l)): v.append(float(l[i])) m = [] i = 0 while (i < 16): m.append(tuple([v[i], v[i + 1], v[i + 2], v[i + 3]])) i += 4 matrix = Matrix((m[0], m[1], m[2], m[3])) self.transform = t except Exception as e: matrix = Matrix() self.transform = None self.enabled = False conversion_matrix = axis_conversion(from_forward='Z', from_up='-Y', to_forward='-Z', to_up='Y').to_4x4() # self.matrix = matrix * conversion_matrix self.matrix = matrix @ conversion_matrix self._xml = xml
def execute(self, context): #from . import import_off keywords = self.as_keywords(ignore=('axis_forward', 'axis_up', 'filter_glob', )) global_matrix = axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4() mesh = load(self, context, **keywords) if not mesh: return {'CANCELLED'} scene = bpy.context.scene obj = object_data_add(context, mesh) obj.matrix_world = global_matrix return {'FINISHED'}
def execute(self, context): from mathutils import Matrix keywords = self.as_keywords(ignore=( "axis_forward", "axis_up", "global_scale", "filter_glob", "directory", )) global_matrix = (Matrix.Scale(self.global_scale, 4) * axis_conversion( from_forward=self.axis_forward, from_up=self.axis_up, ).to_4x4()) keywords["global_matrix"] = global_matrix keywords["use_cycles"] = (context.scene.render.engine == 'CYCLES') from . import import_fbx return import_fbx.load(self, context, **keywords)
def execute(self, context): from . import export_ply from mathutils import Matrix keywords = self.as_keywords(ignore=("axis_forward", "axis_up", "global_scale", "check_existing", "filter_glob", )) global_matrix = axis_conversion(to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() * Matrix.Scale(self.global_scale, 4) keywords["global_matrix"] = global_matrix filepath = self.filepath filepath = bpy.path.ensure_ext(filepath, self.filename_ext) return export_ply.save(self, context, **keywords)
def execute(self, context): filepath = self.filepath filepath = bpy.path.ensure_ext(filepath, self.filename_ext) settings: War3ExportSettings = War3ExportSettings() settings.global_matrix = axis_conversion( to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() @ Matrix.Scale(self.global_scale, 4) settings.use_selection = self.use_selection settings.optimize_animation = self.optimize_animation settings.optimize_tolerance = self.optimize_tolerance settings.use_actions = self.use_actions settings.use_skinweights = self.use_skinweights from ..export_mdl import export_mdl export_mdl.save(self, context, settings, filepath=filepath, mdl_version=800) return {'FINISHED'}
def execute(self, context): warnings.resetwarnings() # Get the matrix to transform the model to "WCP/SO" orientation wc_orientation_matrix = axis_conversion(self.axis_forward, self.axis_up, "Z", "Y").to_4x4() # self.output_version = "12" exporter = getattr(export_iff, self.backend_class_name)( self.filepath, self.texnum, self.apply_modifiers, self.active_as_lod0, self.use_facetex, wc_orientation_matrix, self.include_far_chunk, self.drang_increment, self.generate_bsp, self.test_run) exporter.export() with warnings.catch_warnings(record=True) as wlist: for warning in wlist: self.report({"WARNING"}, warning.message) return {"FINISHED"}
def execute(self, context): from . import export_ska keywords = self.as_keywords(ignore=( "axis_forward", "axis_up", "filter_glob", "check_existing", )) global_matrix = axis_conversion( to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() keywords["global_matrix"] = global_matrix return export_ska.save(self, context, **keywords) #file = open(self.filepath, 'w') #file.write("Hello World " + context.object.name) return {'FINISHED'}
def write_matrix3x4(file, matrix): # passed by ref, don't mess that up matrix = matrix.copy() # convert coordinate space mat_rot = mathutils.Matrix.Rotation(math.radians(-180.0), 4, 'Y') @ mathutils.Matrix.Rotation( math.radians(-90.0), 4, 'X') matrix @= mat_rot mtx_convert = axis_conversion(from_forward='-Y', from_up='Z', to_forward='-Z', to_up='Y').to_4x4() matrix = mtx_convert @ matrix #write 3x3 file.write(struct.pack('<fff', matrix[0][0], matrix[1][0], matrix[2][0])) file.write(struct.pack('<fff', matrix[0][1], matrix[1][1], matrix[2][1])) file.write(struct.pack('<fff', matrix[0][2], matrix[1][2], matrix[2][2])) file.write(struct.pack('<fff', matrix[0][3], matrix[1][3], matrix[2][3]))
def execute(self, context): keywords = self.as_keywords( ignore=( "axis_forward", "axis_up", "check_existing", "global_scale", "filter_glob", ) ) global_matrix = ( Matrix.Scale(self.global_scale, 4) @ axis_conversion( to_forward=self.axis_forward, to_up=self.axis_up, ).to_4x4() ) keywords["global_matrix"] = global_matrix return save(context, **keywords)