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)
