def decode(self, tex0, dest_file, overwrite=None, num_mips=0):
if overwrite is None:
overwrite = self.OVERWRITE_IMAGES
if not dest_file:
dest_file = tex0.name + '.png'
elif os.path.isdir(dest_file):
dest_file = os.path.join(dest_file, tex0.name + '.png')
elif os.path.splitext(
os.path.basename(dest_file))[1].lower() != '.png':
dest_file += '.png'
if not overwrite and os.path.exists(dest_file):
AutoFix.warn('File {} already exists!'.format(dest_file))
return None
tmp = self.get_temp_dest()
f = BinFile(tmp, 'w')
tex0.pack(f)
f.commitWrite()
if num_mips == 0:
mips = '--no-mipmaps'
elif num_mips == -1:
mips = '--n-mm=auto'
else:
mips = '--n-mm=' + str(num_mips)
result = subprocess.call(
[self.converter, 'decode', tmp, '-d', dest_file, mips, '-qo'],
startupinfo=self.si)
if tmp != dest_file:
os.remove(tmp)
if result:
raise DecodeError('Failed to decode {}'.format(tex0.name))
return dest_file
def save(self, dest, overwrite):
if dest is None:
dest = self.name
ext = '.' + self.EXT
if not dest.endswith(ext):
dest += ext
if os.path.exists(dest) and not overwrite and not self.OVERWRITE_MODE:
AutoFix.get().error('{} already exists!'.format(dest))
return
bin = BinFile(dest, 'w')
self.pack(bin)
bin.commitWrite()
return dest
def convert(self, tex0, tex_format):
tmp = self.get_temp_dest()
f = BinFile(tmp, 'w')
tex0.pack(f)
f.commitWrite()
result = subprocess.call(
[self.converter, 'encode', tmp, '-oq', '-x', tex_format],
startupinfo=self.si)
if result:
os.remove(tmp)
raise EncodeError('Failed to encode {}'.format(tex0.name))
t = Tex0(tex0.name, tex0.parent, BinFile(tmp))
os.remove(tmp)
return t
def __init__(self, name, parent=None, readFile=True):
"""
initialize brres
name - the brres name, or filename
parent - optional for supporting containing files in future
readfile - optional start reading and unpacking file
"""
# self.folders = {}
name = os.path.abspath(name)
self.is_modified = False
self.has_new_model = False
self.models = []
self.texture_map = {}
self.textures = []
self.srt0 = []
self.pat0 = []
self.chr0 = []
self.scn0 = []
self.shp0 = []
self.clr0 = []
binfile = BinFile(name) if readFile else None
super(Brres, self).__init__(name, parent, binfile)
self.add_open_file(self)
if binfile:
self.unpack(binfile)
def save(self, filename=None, overwrite=None, check=True):
if not filename:
filename = self.name
if overwrite is None:
overwrite = self.OVERWRITE
if not overwrite and os.path.exists(filename):
AutoFix.get().error('File {} already exists!'.format(filename), 1)
else:
if check:
self.check()
f = BinFile(filename, mode="w")
self.pack(f)
if f.commitWrite():
AutoFix.get().info("Wrote file '{}'".format(filename), 2)
self.rename(filename)
self.has_new_model = False
self.mark_unmodified()
return True
return False
def batch_encode(self,
files,
brres,
tex_format=None,
num_mips=-1,
check=False,
overwrite=None):
"""Batch encode, faster than single encode when doing multiple files"""
if overwrite is None:
overwrite = self.OVERWRITE_IMAGES
mips = '--n-mm=' + str(
num_mips) if num_mips >= 0 else '--n-mm=auto'
if not tex_format:
tex_format = self.IMG_FORMAT
t_files = []
for x in files:
try:
t_files.append(self.find_file(x))
except EncodeError:
AutoFix.warn('Failed to find image {}'.format(x))
# tmp = 'abmatt-tmp'
# create a new dir to work in
tmp = self._move_to_temp_dir(t_files)
t_files = [os.path.basename(x) for x in t_files]
path_set = set()
textures = brres.get_texture_map()
for x in t_files:
path, name = self.convert_png(os.path.join(tmp, x),
remove_old=True)
if overwrite or name not in textures:
path_set.add(path)
else:
os.remove(path)
if not len(path_set):
self._move_out_of_temp_dir(tmp)
return None
if check:
for x in path_set:
self.check_image_dimensions(x)
args = [self.converter, '-x', tex_format, mips, '-qo', 'encode']
file_names = [os.path.basename(x) for x in path_set]
args.extend(file_names)
result = subprocess.call(args, cwd=tmp, startupinfo=self.si)
if result:
self._move_out_of_temp_dir(tmp)
raise EncodeError('Failed to encode images {}'.format(files))
tex0s = []
new_files = [x for x in os.listdir(tmp) if x not in file_names]
for x in new_files:
t = Tex0(x, brres, BinFile(os.path.join(tmp, x)))
tex0s.append(t)
brres.add_tex0(t)
self._move_out_of_temp_dir(tmp) # cleanup
return tex0s
def batch_decode(self, tex0s, dest_dir=None, overwrite=None):
if not tex0s:
return
if overwrite is None:
overwrite = self.OVERWRITE_IMAGES
use_temp_dir = True
if dest_dir is not None:
if not os.path.exists(dest_dir):
os.mkdir(dest_dir)
tmp_dir = dest_dir
use_temp_dir = False
# os.chdir(dest_dir)
if use_temp_dir: # use a temporary directory if this one already has stuff
tmp_dir = self._move_to_temp_dir()
files = []
base_names = []
for tex in tex0s:
name = tex.name
if overwrite or not os.path.exists(
os.path.join(tmp_dir, name + '.png')):
f = BinFile(os.path.join(tmp_dir, name), 'w')
tex.pack(f)
base_names.append(name)
files.append(f)
if not files: # our work is already done!
return files
for x in files:
x.commitWrite()
args = [self.converter, '--no-mipmaps', '-qo', 'decode']
args.extend(base_names)
result = subprocess.call(args, cwd=tmp_dir, startupinfo=self.si)
if result:
if use_temp_dir:
self._move_out_of_temp_dir(tmp_dir)
raise DecodeError('Failed to decode images')
for x in files:
try:
os.remove(x.filename)
except FileNotFoundError:
pass
files = os.listdir(tmp_dir)
if use_temp_dir:
self._move_out_of_temp_dir(tmp_dir, files)
return files
def __init__(self, brres_files, max_err_out=5, ignore_offsets=None, start_at=None, target=None):
brres1, brres2 = brres_files
bin1 = BinFile(brres1.name, 'w')
bin2 = BinFile(brres2.name, 'w')
if ignore_offsets is None:
ignore1 = set()
ignore2 = set()
else:
ignore1 = {x for x in ignore_offsets[0]}
ignore2 = {x for x in ignore_offsets[1]}
if start_at is None:
start_at1 = 0
start_at2 = 0
else:
start_at1, start_at2 = start_at
if target is not None:
target1, target2 = target
else:
target1 = []
target2 = []
bin1.target = target1
bin2.target = target2
brres1.pack(bin1)
brres2.pack(bin2)
ignore1 = self.extend_ignored(ignore1.union({x for x in bin1.linked_offsets}))
ignore2 = self.extend_ignored(ignore2.union({x for x in bin2.linked_offsets}))
self.bin1 = bin1
self.bin2 = bin2
self.target1 = target1
self.target2 = target2
self.brres1 = brres1
self.brres2 = brres2
self.ignore1 = ignore1
self.ignore2 = ignore2
self.start_at1 = start_at1
self.start_at2 = start_at2
self.max_err_out = max_err_out
self.poly_offset1 = [x[0] for x in bin1.polygon_offsets]
self.poly_offset2 = [x[0] for x in bin2.polygon_offsets]
self.poly_names1 = [x[1] for x in bin1.polygon_offsets]
self.poly_names2 = [x[1] for x in bin2.polygon_offsets]
self.section_offset1 = [x[0] for x in bin1.section_offsets]
self.section_offset2 = [x[0] for x in bin2.section_offsets]
self.section_names1 = [x[1] for x in bin1.section_offsets]
self.section_names2 = [x[1] for x in bin2.section_offsets]
self.poly_i = 0
self.max_poly_i = max(len(self.poly_offset1), len(self.poly_offset2))
self.section_i = 0
self.max_section_i = len(self.section_offset1)
def encode(self,
img_file,
brres,
tex_format=None,
num_mips=-1,
check=False,
overwrite=None):
if overwrite is None:
overwrite = self.OVERWRITE_IMAGES
img_file, name = self.convert_png(self.find_file(img_file))
if not overwrite and brres is not None and name in brres.get_texture_map(
):
AutoFix.warn(f'Tex0 {name} already exists!')
return None
if check:
self.check_image_dimensions(img_file)
# encode
mips = '--n-mm=' + str(
num_mips) if num_mips >= 0 else '--n-mm=auto'
if not tex_format:
tex_format = self.IMG_FORMAT
dest = self.get_temp_dest()
result = subprocess.call([
self.converter, 'encode', img_file, '-d', dest, '-x',
tex_format, mips, '-qo'
],
startupinfo=self.si)
if result:
raise EncodeError('Failed to encode {}'.format(img_file))
t = Tex0(name, brres, BinFile(dest))
t.name = name
if brres is not None:
brres.add_tex0(t)
os.remove(dest)
t.name = name
return t