def read_vmdtext_boneframe(rawlist_text: List[list]) -> List[vmdstruct.VmdBoneFrame]:
#############################
# bone frames
global readfrom_line
bone_list = []
# first, check for bad format
check2_match_first_item(rawlist_text, keystr_boneframect)
boneframe_ct = rawlist_text[readfrom_line][1]
readfrom_line += 1
core.MY_PRINT_FUNC("...# of boneframes = %d" % boneframe_ct)
if boneframe_ct > 0:
# ensure the key-line is where i think it is
check3_match_keystr(rawlist_text, keystr_boneframekey)
# if it is indeed here, then inc the readpointer
readfrom_line += 1
for i in range(boneframe_ct):
# ensure it has the right # of items on the line
check1_match_len(rawlist_text, len(keystr_boneframekey))
# the nicelist has angles in euler format, don't convert the values here
r = rawlist_text[readfrom_line]
newframe = vmdstruct.VmdBoneFrame(name=r[0], f=r[1], pos=r[2:5], rot=r[5:8], phys_off=r[8], interp=r[9:])
bone_list.append(newframe)
# increment the readfrom_line pointer
readfrom_line += 1
# progress tracker just because
core.print_progress_oneline(i / boneframe_ct)
return bone_list
def parse_vmd_boneframe(raw:bytearray, moreinfo:bool) -> List[vmdstruct.VmdBoneFrame]:
# get all the bone-frames, store in a list of lists
boneframe_list = []
# verify that there is enough file left to read a single number
if (len(raw) - core.get_readfrom_byte()) < struct.calcsize(fmt_number):
core.MY_PRINT_FUNC("Warning: expected boneframe_ct field but file ended unexpectedly! Assuming 0 boneframes and continuing...")
return boneframe_list
############################
# get the number of bone-frames
boneframe_ct = core.my_unpack(fmt_number, raw)
if moreinfo: core.MY_PRINT_FUNC("...# of boneframes = %d" % boneframe_ct)
for z in range(boneframe_ct):
try:
# unpack the bone-frame into variables
(bname_str, f, xp, yp, zp, xrot_q, yrot_q, zrot_q, wrot_q) = core.my_unpack(fmt_boneframe_no_interpcurve, raw)
# break inter_curve into its individual pieces, knowing that the 3rd and 4th bytes in line1 are overwritten with phys
# therefore we need to get their data from line2 which is left-shifted by 1 byte, but otherwise a copy
(x_ax, y_ax, phys1, phys2, x_ay, y_ay, z_ay, r_ay, x_bx, y_bx, z_bx, r_bx, x_by, y_by, z_by, r_by,
z_ax, r_ax) = core.my_unpack(fmt_boneframe_interpcurve, raw)
# convert the quaternion angles to euler angles
(xrot, yrot, zrot) = core.quaternion_to_euler([wrot_q, xrot_q, yrot_q, zrot_q])
# interpret the physics enable/disable bytes
if (phys1, phys2) == (z_ax, r_ax):
# if they match the values they should be, they were never overwritten in the first place???
phys_off = False
elif (phys1, phys2) == (0, 0):
# phys stays on
phys_off = False
elif (phys1, phys2) == (99, 15):
# phys turns off
phys_off = True
else:
core.MY_PRINT_FUNC("Warning: found unusual values where I expected to find physics enable/disable! Assuming this means physics off")
core.MY_PRINT_FUNC(bname_str, "f=", str(f), "(phys1,phys2)=", str((phys1, phys2)))
phys_off = True
# store them all on the list
# create a list to hold all the boneframe data, then append it onto the return-list
interp_list = [x_ax, y_ax, z_ax, r_ax, x_ay, y_ay, z_ay, r_ay, x_bx, y_bx, z_bx, r_bx, x_by, y_by, z_by, r_by]
this_boneframe = vmdstruct.VmdBoneFrame(
name=bname_str, f=f, pos=[xp,yp,zp], rot=[xrot,yrot,zrot], phys_off=phys_off, interp=interp_list
)
boneframe_list.append(this_boneframe)
# display progress printouts
core.print_progress_oneline(core.get_readfrom_byte() / len(raw))
except Exception as e:
core.MY_PRINT_FUNC(e.__class__.__name__, e)
core.MY_PRINT_FUNC("frame=", z)
core.MY_PRINT_FUNC("totalframes=", boneframe_ct)
core.MY_PRINT_FUNC("section=boneframe")
core.MY_PRINT_FUNC("Err: something went wrong while parsing, file is probably corrupt/malformed")
raise RuntimeError()
return boneframe_list
def read_vpd(vpd_filepath: str, moreinfo=False) -> vmdstruct.Vmd:
"""
Read a VPD text file and convert it to a VMD object with all boneframes and morphframes at time=0.
:param vpd_filepath: destination filepath/name, relative from CWD or absolute
:param moreinfo: if true, get extra printouts with more info about stuff
:return: VMD object
"""
cleanname = core.get_clean_basename(vpd_filepath) + ".vpd"
core.MY_PRINT_FUNC("Begin reading VPD file '%s'" % cleanname)
# read textfile to linelist, no CSV fields to untangle here
lines = core.read_txtfile_to_list(vpd_filepath, use_jis_encoding=True)
# verify magic header "Vocaloid Pose Data file"
if lines[0] != "Vocaloid Pose Data file":
core.MY_PRINT_FUNC(
"warning: did not find expected magic header! this might not be a real VPD file!"
)
# get rid of the header
lines.pop(0)
# this var is a state machine that keeps track of what I expect to find next
# if i find anything other than blankspace or what I expect, then err & die
parse_state = 0
# save this so I know when I'm done reading all the bones the header promised
num_bones = 0
# temp vars to hold stuff from previous lines
temp_title = "qwertyuiop"
temp_name = "foobar"
temp_pos = tuple()
temp_rot = tuple()
temp_value = 0.0
# this is the VMD object that will be ultimately returned
vmd_boneframes = []
vmd_morphframes = []
# iterate over the remaining lines until end-of-file
for d, line in enumerate(lines):
# vertical whitespace is always acceptable
if not line or line.isspace(): continue
# if line is not blank, it had better be something good:
if parse_state == 0: # 0 = model title
m = title_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: failed to find model title" %
(d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
temp_title = m.group(
1) # if valid match, then grab the actual title
if moreinfo:
core.MY_PRINT_FUNC("...model name = JP:'%s'" % temp_title)
parse_state = 10 # next thing to look for is #bones
elif parse_state == 10: # 10 = #bones
m = f1_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: failed to find number of bones"
% (d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
num_bones = int(float(m.group(
1))) # if a valid match, then grab the actual # of bones
if moreinfo:
core.MY_PRINT_FUNC("...# of boneframes = %d" %
num_bones)
if num_bones == 0:
parse_state = 30 # if there are 0 bones then immediately begin with the morphs
else:
parse_state = 20 # otherwise look for bones next
elif parse_state == 20: # 20 = boneA, name
m = bone_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: failed to find bone name" %
(d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
idx, name = m.group(1, 2) # get idx and name
temp_name = name
# can i use idx for anything? or is it totally useless?
parse_state = 21 # next look for quaternion rotation
elif parse_state == 21: # 21 = boneB, xyz pos
m = f3_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: failed to find bone XYZ position"
% (d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
pos = m.group(1, 2, 3) # get all 3 components
temp_pos = [float(f) for f in pos] # convert strings to floats
parse_state = 22 # next look for quaternion rotation
elif parse_state == 22: # 22 = boneC, xyzw quaternion rotation
m = f4_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: failed to find bone XYZW rotation"
% (d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
quat = m.group(1, 2, 3, 4) # get all 4 components
quat = [float(f) for f in quat] # convert strings to floats
quat.insert(
0, quat.pop(-1)) # WXYZW -> XYZW, AKA move tail (w) to head
temp_rot = core.quaternion_to_euler(
quat) # convert quaternion to euler angles
parse_state = 23 # next look for closing curly
elif parse_state == 23: # 23 = boneD, closing curly
m = close_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: bone item not properly closed"
% (d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
# finish the bone-obj and add to VMD structure
# this_boneframe = [bname_str, f, xp, yp, zp, xrot, yrot, zrot, phys_off, x_ax, y_ax, z_ax, r_ax, x_ay, y_ay,
# z_ay, r_ay, x_bx, y_bx, z_bx, r_bx, x_by, y_by, z_by, r_by]
newframe = vmdstruct.VmdBoneFrame(
name=temp_name,
f=0,
pos=temp_pos,
rot=list(temp_rot),
phys_off=False,
interp=list(core.bone_interpolation_default_linear))
vmd_boneframes.append(newframe)
if len(vmd_boneframes) == num_bones:
parse_state = 30 # if i got all the bones i expected, move to morphs
else:
parse_state = 20 # otherwise, get another bone
elif parse_state == 30: # 30 = morphA, name
m = morph_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: failed to find morph name" %
(d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
idx, name = m.group(1, 2) # get idx and name
temp_name = name
# can i use idx for anything? or is it totally useless?
parse_state = 31 # next look for value
elif parse_state == 31: # 31 = morphB, value
m = f1_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: failed to find morph value" %
(d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
v = m.group(1) # get value
temp_value = float(v) # convert strings to floats
parse_state = 32 # next look for close
elif parse_state == 32: # 32 = morphC, closing curly
m = close_re.match(line) # regex match from beginning of line
if m is None:
core.MY_PRINT_FUNC(
"Parse err line %d state %d: morph item not properly closed"
% (d + 2, parse_state))
core.MY_PRINT_FUNC("line = '%s'" % line)
raise RuntimeError()
# finish the morph-obj and add to VMD structure
# morphframe_list.append([mname_str, f, v])
newframe = vmdstruct.VmdMorphFrame(name=temp_name,
f=0,
val=temp_value)
vmd_morphframes.append(newframe)
parse_state = 30 # loop morphs until end-of-file
else:
core.MY_PRINT_FUNC("this should not happen, err & die")
raise RuntimeError()
if moreinfo:
core.MY_PRINT_FUNC("...# of morphframes = %d" %
len(vmd_morphframes))
# verify we did not hit end-of-file unexpectedly, looking-for-morphA is only valid ending state
if parse_state != 30:
core.MY_PRINT_FUNC("Parse err state %d: hit end-of-file unexpectedly" %
parse_state)
raise RuntimeError()
# after hitting end-of-file, assemble the parts of the final returnable VMD-list thing
# builds object (header, boneframe_list, morphframe_list, camframe_list, lightframe_list, shadowframe_list, ikdispframe_list)
vmd_retme = vmdstruct.Vmd(
vmdstruct.VmdHeader(version=2, modelname=temp_title), vmd_boneframes,
vmd_morphframes, list(), list(), list(), list())
core.MY_PRINT_FUNC("Done reading VPD file '%s'" % cleanname)
return vmd_retme
def main(moreinfo=True):
# the goal: extract rotation around the "arm" bone local X? axis and transfer it to rotation around the "armtwist" bone local axis
# prompt PMX name
core.MY_PRINT_FUNC("Please enter name of PMX input file:")
input_filename_pmx = core.MY_FILEPROMPT_FUNC(".pmx")
pmx = pmxlib.read_pmx(input_filename_pmx, moreinfo=moreinfo)
core.MY_PRINT_FUNC("")
# get bones
realbones = pmx.bones
twistbone_axes = []
# then, grab the "twist" bones & save their fixed-rotate axes, if they have them
# fallback plan: find the arm-to-elbow and elbow-to-wrist unit vectors and use those
for i in range(len(jp_twistbones)):
r = core.my_list_search(realbones, lambda x: x.name_jp == jp_twistbones[i], getitem=True)
if r is None:
core.MY_PRINT_FUNC("ERROR1: twist bone '{}'({}) cannot be found model, unable to continue. Ensure they use the correct semistandard names, or edit the script to change the JP names it is looking for.".format(jp_twistbones[i], eng_twistbones[i]))
raise RuntimeError()
if r.has_fixedaxis:
# this bone DOES have fixed-axis enabled! use the unit vector in r[18]
twistbone_axes.append(r.fixedaxis)
else:
# i can infer local axis by angle from arm-to-elbow or elbow-to-wrist
start = core.my_list_search(realbones, lambda x: x.name_jp == jp_sourcebones[i], getitem=True)
if start is None:
core.MY_PRINT_FUNC("ERROR2: semistandard bone '%s' is missing from the model, unable to infer axis of rotation" % jp_sourcebones[i])
raise RuntimeError()
end = core.my_list_search(realbones, lambda x: x.name_jp == jp_pointat_bones[i], getitem=True)
if end is None:
core.MY_PRINT_FUNC("ERROR3: semistandard bone '%s' is missing from the model, unable to infer axis of rotation" % jp_pointat_bones[i])
raise RuntimeError()
start_pos = start.pos
end_pos = end.pos
# now have both startpoint and endpoint! find the delta!
delta = [b - a for a,b in zip(start_pos, end_pos)]
# normalize to length of 1
length = core.my_euclidian_distance(delta)
unit = [t / length for t in delta]
twistbone_axes.append(unit)
# done extracting axes limits from bone CSV, in list "twistbone_axes"
core.MY_PRINT_FUNC("...done extracting axis limits from PMX...")
###################################################################################
# prompt VMD file name
core.MY_PRINT_FUNC("Please enter name of VMD dance input file:")
input_filename_vmd = core.MY_FILEPROMPT_FUNC(".vmd")
# next, read/use/prune the dance vmd
nicelist_in = vmdlib.read_vmd(input_filename_vmd, moreinfo=moreinfo)
# sort boneframes into individual lists: one for each [Larm + Lelbow + Rarm + Relbow] and remove them from the master boneframelist
# frames for all other bones stay in the master boneframelist
all_sourcebone_frames = []
for sourcebone in jp_sourcebones:
# partition & writeback
temp, nicelist_in.boneframes = core.my_list_partition(nicelist_in.boneframes, lambda x: x.name == sourcebone)
# all frames for "sourcebone" get their own sublist here
all_sourcebone_frames.append(temp)
# verify that there is actually arm/elbow frames to process
sourcenumframes = sum([len(x) for x in all_sourcebone_frames])
if sourcenumframes == 0:
core.MY_PRINT_FUNC("No arm/elbow bone frames are found in the VMD, nothing for me to do!")
core.MY_PRINT_FUNC("Aborting: no files were changed")
return None
else:
core.MY_PRINT_FUNC("...source contains " + str(sourcenumframes) + " arm/elbow bone frames to decompose...")
if USE_OVERKEY_BANDAID:
# to fix the path that the arms take during interpolation we need to overkey the frames
# i.e. create intermediate frames that they should have been passing through already, to FORCE it to take the right path
# i'm replacing the interpolation curves with actual frames
for sublist in all_sourcebone_frames:
newframelist = []
sublist.sort(key=lambda x: x.f) # ensure they are sorted by frame number
# for each frame
for i in range(1, len(sublist)):
this = sublist[i]
prev = sublist[i-1]
# use interpolation curve i to interpolate from i-1 to i
# first: do i need to do anything or are they already close on the timeline?
thisframenum = this.f
prevframenum = prev.f
if (thisframenum - prevframenum) <= OVERKEY_FRAME_SPACING:
continue
# if they are far enough apart that i need to do something,
thisframequat = core.euler_to_quaternion(this.rot)
prevframequat = core.euler_to_quaternion(prev.rot)
# 3, 7, 11, 15 = r_ax, r_ay, r_bx, r_by
bez = core.MyBezier((this.interp[3], this.interp[7]), (this.interp[11], this.interp[15]), resolution=50)
# create new frames at these frame numbers, spacing is OVERKEY_FRAME_SPACING
for interp_framenum in range(prevframenum + OVERKEY_FRAME_SPACING, thisframenum, OVERKEY_FRAME_SPACING):
# calculate the x time percentage from prev frame to this frame
x = (interp_framenum - prevframenum) / (thisframenum - prevframenum)
# apply the interpolation curve to translate X to Y
y = bez.approximate(x)
# interpolate from prev to this by amount Y
interp_quat = core.my_slerp(prevframequat, thisframequat, y)
# begin building the new frame
newframe = vmdstruct.VmdBoneFrame(
name=this.name, # same name
f=interp_framenum, # overwrite frame num
pos=list(this.pos), # same pos (but make a copy)
rot=list(core.quaternion_to_euler(interp_quat)), # overwrite euler angles
phys_off=this.phys_off, # same phys_off
interp=list(core.bone_interpolation_default_linear) # overwrite interpolation
)
newframelist.append(newframe)
# overwrite thisframe interp curve with default too
this.interp = list(core.bone_interpolation_default_linear) # overwrite custom interpolation
# concat the new frames onto the existing frames for this sublist
sublist += newframelist
# re-count the number of frames for printing purposes
totalnumframes = sum([len(x) for x in all_sourcebone_frames])
overkeyframes = totalnumframes - sourcenumframes
if overkeyframes != 0:
core.MY_PRINT_FUNC("...overkeying added " + str(overkeyframes) + " arm/elbow bone frames...")
core.MY_PRINT_FUNC("...beginning decomposition of " + str(totalnumframes) + " arm/elbow bone frames...")
# now i am completely done reading the VMD file and parsing its data! everything has been distilled down to:
# all_sourcebone_frames = [Larm, Lelbow, Rarm, Relbow] plus nicelist_in[1]
###################################################################################
# begin the actual calculations
# output array
new_twistbone_frames = []
# progress tracker
curr_progress = 0
# for each sourcebone & corresponding twistbone,
for (twistbone, axis_orig, sourcebone_frames) in zip(jp_twistbones, twistbone_axes, all_sourcebone_frames):
# for each frame of the sourcebone,
for frame in sourcebone_frames:
# XYZrot = 567 euler
quat_in = core.euler_to_quaternion(frame.rot)
axis = list(axis_orig) # make a copy to be safe
# "swing twist decomposition"
# swing = "local" x rotation and nothing else
# swing = sourcebone, twist = twistbone
(swing, twist) = swing_twist_decompose(quat_in, axis)
# modify "frame" in-place
# only modify the XYZrot to use new values
new_sourcebone_euler = core.quaternion_to_euler(swing)
frame.rot = list(new_sourcebone_euler)
# create & store new twistbone frame
# name=twistbone, framenum=copy, XYZpos=copy, XYZrot=new, phys=copy, interp16=copy
new_twistbone_euler = core.quaternion_to_euler(twist)
newframe = vmdstruct.VmdBoneFrame(
name=twistbone,
f=frame.f,
pos=list(frame.pos),
rot=list(new_twistbone_euler),
phys_off=frame.phys_off,
interp=list(frame.interp)
)
new_twistbone_frames.append(newframe)
# print progress updates
curr_progress += 1
core.print_progress_oneline(curr_progress / totalnumframes)
######################################################################
# done with calculations!
core.MY_PRINT_FUNC("...done with decomposition, now reassembling output...")
# attach the list of newly created boneframes, modify the original input
for sublist in all_sourcebone_frames:
nicelist_in.boneframes += sublist
nicelist_in.boneframes += new_twistbone_frames
core.MY_PRINT_FUNC("")
# write out the VMD
output_filename_vmd = "%s_twistbones_for_%s.vmd" % \
(input_filename_vmd[0:-4], core.get_clean_basename(input_filename_pmx))
output_filename_vmd = core.get_unused_file_name(output_filename_vmd)
vmdlib.write_vmd(output_filename_vmd, nicelist_in, moreinfo=moreinfo)
core.MY_PRINT_FUNC("Done!")
return None
def main(moreinfo=True):
# prompt PMX name
core.MY_PRINT_FUNC("Please enter name of PMX input file:")
input_filename_pmx = core.MY_FILEPROMPT_FUNC(".pmx")
pmx = pmxlib.read_pmx(input_filename_pmx, moreinfo=moreinfo)
# get bones
realbones = pmx.bones
# then, make 2 lists: one starting from jp_righttoe, one starting from jp_lefttoe
# start from each "toe" bone (names are known), go parent-find-parent-find until reaching no-parent
bonechain_r = build_bonechain(realbones, jp_righttoe)
bonechain_l = build_bonechain(realbones, jp_lefttoe)
# assert that the bones were found, have correct names, and are in the correct positions
# also verifies that they are direct parent-child with nothing in between
try:
assert bonechain_r[-1].name == jp_righttoe
assert bonechain_r[-2].name == jp_rightfoot
assert bonechain_l[-1].name == jp_lefttoe
assert bonechain_l[-2].name == jp_leftfoot
except AssertionError:
core.MY_PRINT_FUNC(
"ERROR: unexpected structure found for foot/toe bones, verify semistandard names and structure"
)
raise RuntimeError()
# then walk down these 2 lists, add each name to a set: build union of all relevant bones
relevant_bones = set()
for b in bonechain_r + bonechain_l:
relevant_bones.add(b.name)
# check if waist-cancellation bones are in "relevant_bones", print a warning if they are
if jp_left_waistcancel in relevant_bones or jp_right_waistcancel in relevant_bones:
# TODO LOW: i probably could figure out how to support them but this whole script is useless so idgaf
core.MY_PRINT_FUNC(
"Warning: waist-cancellation bones found in the model! These are not supported, tool may produce bad results! Attempting to continue..."
)
# also need to find initial positions of ik bones (names are known)
# build a full parentage-chain for each leg
bonechain_ikr = build_bonechain(realbones, jp_righttoe_ik)
bonechain_ikl = build_bonechain(realbones, jp_lefttoe_ik)
# verify that the ik bones were found, have correct names, and are in the correct positions
try:
assert bonechain_ikr[-1].name == jp_righttoe_ik
assert bonechain_ikr[-2].name == jp_rightfoot_ik
assert bonechain_ikl[-1].name == jp_lefttoe_ik
assert bonechain_ikl[-2].name == jp_leftfoot_ik
except AssertionError:
core.MY_PRINT_FUNC(
"ERROR: unexpected structure found for foot/toe IK bones, verify semistandard names and structure"
)
raise RuntimeError()
# verify that the bonechains are symmetric in length
try:
assert len(bonechain_l) == len(bonechain_r)
assert len(bonechain_ikl) == len(bonechain_ikr)
except AssertionError:
core.MY_PRINT_FUNC(
"ERROR: unexpected structure found, model is not left-right symmetric"
)
raise RuntimeError()
# determine how many levels of parentage, this value "t" should hold the first level where they are no longer shared
t = 0
while bonechain_l[t].name == bonechain_ikl[t].name:
t += 1
# back off one level
lowest_shared_parent = t - 1
# now i am completely done with the bones CSV, all the relevant info has been distilled down to:
# !!! bonechain_r, bonechain_l, bonechain_ikr, bonechain_ikl, relevant_bones
core.MY_PRINT_FUNC("...identified " + str(len(bonechain_l)) +
" bones per leg-chain, " + str(len(relevant_bones)) +
" relevant bones total")
core.MY_PRINT_FUNC("...identified " + str(len(bonechain_ikl)) +
" bones per IK leg-chain")
###################################################################################
# prompt VMD file name
core.MY_PRINT_FUNC("Please enter name of VMD dance input file:")
input_filename_vmd = core.MY_FILEPROMPT_FUNC(".vmd")
nicelist_in = vmdlib.read_vmd(input_filename_vmd, moreinfo=moreinfo)
# check if this VMD uses IK or not, print a warning if it does
any_ik_on = False
for ikdispframe in nicelist_in.ikdispframes:
for ik_bone in ikdispframe.ikbones:
if ik_bone.enable is True:
any_ik_on = True
break
if any_ik_on:
core.MY_PRINT_FUNC(
"Warning: the input VMD already has IK enabled, there is no point in running this script. Attempting to continue..."
)
# reduce down to only the boneframes for the relevant bones
# also build a list of each framenumber with a frame for a bone we care about
relevant_framenums = set()
boneframe_list = []
for boneframe in nicelist_in.boneframes:
if boneframe.name in relevant_bones:
boneframe_list.append(boneframe)
relevant_framenums.add(boneframe.f)
# sort the boneframes by frame number
boneframe_list.sort(key=lambda x: x.f)
# make the relevant framenumbers also an ascending list
relevant_framenums = sorted(list(relevant_framenums))
boneframe_dict = dict()
# now restructure the data from a list to a dictionary, keyed by bone name. also discard excess data when i do
for b in boneframe_list:
if b.name not in boneframe_dict:
boneframe_dict[b.name] = []
# only storing the frame#(1) + position(234) + rotation values(567)
saveme = [b.f, *b.pos, *b.rot]
boneframe_dict[b.name].append(saveme)
core.MY_PRINT_FUNC(
"...running interpolation to rectangularize the frames...")
has_warned = False
# now fill in the blanks by using interpolation, if needed
for key, bone in boneframe_dict.items(): # for each bone,
# start a list of frames generated by interpolation
interpframe_list = []
i = 0
j = 0
while j < len(relevant_framenums): # for each frame it should have,
if i == len(bone):
# if i is beyond end of bone, then copy the values from the last frame and use as a new frame
newframe = [relevant_framenums[j]] + bone[-1][1:7]
interpframe_list.append(newframe)
j += 1
elif bone[i][0] == relevant_framenums[j]: # does it have it?
i += 1
j += 1
else:
# TODO LOW: i could modify this to include my interpolation curve math now that I understand it, but i dont care
if not has_warned:
core.MY_PRINT_FUNC(
"Warning: interpolation is needed but interpolation curves are not fully tested! Assuming linear interpolation..."
)
has_warned = True
# if there is a mismatch then the target framenum is less than the boneframe framenum
# build a frame that has frame# + position(123) + rotation values(456)
newframe = [relevant_framenums[j]]
# if target is less than the current boneframe, interp between here and prev boneframe
for p in range(1, 4):
# interpolate for each position offset
newframe.append(
core.linear_map(bone[i][0], bone[i][p], bone[i - 1][0],
bone[i - 1][p], relevant_framenums[j]))
# rotation interpolation must happen in the quaternion-space
quat1 = core.euler_to_quaternion(bone[i - 1][4:7])
quat2 = core.euler_to_quaternion(bone[i][4:7])
# desired frame is relevant_framenums[j] = d
# available frames are bone[i-1][0] = s and bone[i][0] = e
# percentage = (d - s) / (e - s)
percentage = (relevant_framenums[j] -
bone[i - 1][0]) / (bone[i][0] - bone[i - 1][0])
quat_slerp = core.my_slerp(quat1, quat2, percentage)
euler_slerp = core.quaternion_to_euler(quat_slerp)
newframe += euler_slerp
interpframe_list.append(newframe)
j += 1
bone += interpframe_list
bone.sort(key=core.get1st)
# the dictionary should be fully filled out and rectangular now
for bone in boneframe_dict:
assert len(boneframe_dict[bone]) == len(relevant_framenums)
# now i am completely done reading the VMD file and parsing its data! everything has been distilled down to:
# relevant_framenums, boneframe_dict
###################################################################################
# begin the actual calculations
core.MY_PRINT_FUNC("...beginning forward kinematics computation for " +
str(len(relevant_framenums)) + " frames...")
# output array
ikframe_list = []
# have list of bones, parentage, initial pos
# have list of frames
# now i "run the dance" and build the ik frames
# for each relevant frame,
for I in range(len(relevant_framenums)):
# for each side,
for (thisik, this_chain) in zip([bonechain_ikr, bonechain_ikl],
[bonechain_r, bonechain_l]):
# for each bone in this_chain (ordered, start with root!),
for J in range(len(this_chain)):
# reset the current to be the inital position again
this_chain[J].reset()
# for each bone in this_chain (ordered, start with toe! do children before parents!)
# also, don't read/use root! because the IK are also children of root, they inherit the same root transformations
# count backwards from end to lowest_shared_parent, not including lowest_shared_parent
for J in range(len(this_chain) - 1, lowest_shared_parent, -1):
# get bone J within this_chain, translate to name
name = this_chain[J].name
# get bone [name] at index I: position & rotation
try:
xpos, ypos, zpos, xrot, yrot, zrot = boneframe_dict[name][
I][1:7]
except KeyError:
continue
# apply position offset to self & children
# also resets the currposition when changing frames
for K in range(J, len(this_chain)):
# set this_chain[K].current456 = current456 + position
this_chain[K].xcurr += xpos
this_chain[K].ycurr += ypos
this_chain[K].zcurr += zpos
# apply rotation offset to all children, but not self
_origin = [
this_chain[J].xcurr, this_chain[J].ycurr,
this_chain[J].zcurr
]
_angle = [xrot, yrot, zrot]
_angle_quat = core.euler_to_quaternion(_angle)
for K in range(J, len(this_chain)):
# set this_chain[K].current456 = current rotated around this_chain[J].current456
_point = [
this_chain[K].xcurr, this_chain[K].ycurr,
this_chain[K].zcurr
]
_newpoint = rotate3d(_origin, _angle_quat, _point)
(this_chain[K].xcurr, this_chain[K].ycurr,
this_chain[K].zcurr) = _newpoint
# also rotate the angle of this bone
curr_angle_euler = [
this_chain[K].xrot, this_chain[K].yrot,
this_chain[K].zrot
]
curr_angle_quat = core.euler_to_quaternion(
curr_angle_euler)
new_angle_quat = core.hamilton_product(
_angle_quat, curr_angle_quat)
new_angle_euler = core.quaternion_to_euler(new_angle_quat)
(this_chain[K].xrot, this_chain[K].yrot,
this_chain[K].zrot) = new_angle_euler
pass
pass
# now i have cascaded this frame's pose data down the this_chain
# grab foot/toe (-2 and -1) current position and calculate IK offset from that
# first, foot:
# footikend - footikinit = footikoffset
xfoot = this_chain[-2].xcurr - thisik[-2].xinit
yfoot = this_chain[-2].ycurr - thisik[-2].yinit
zfoot = this_chain[-2].zcurr - thisik[-2].zinit
# save as boneframe to be ultimately formatted for VMD:
# need bonename = (known)
# need frame# = relevantframe#s[I]
# position = calculated
# rotation = 0
# phys = not disabled
# interp = default (20/107)
# # then, foot-angle: just copy the angle that the foot has
if STORE_IK_AS_FOOT_ONLY:
ikframe = [
thisik[-2].name, relevant_framenums[I], xfoot, yfoot,
zfoot, this_chain[-2].xrot, this_chain[-2].yrot,
this_chain[-2].zrot, False
]
else:
ikframe = [
thisik[-2].name, relevant_framenums[I], xfoot, yfoot,
zfoot, 0.0, 0.0, 0.0, False
]
ikframe += [20] * 8
ikframe += [107] * 8
# append the freshly-built frame
ikframe_list.append(ikframe)
if not STORE_IK_AS_FOOT_ONLY:
# then, toe:
# toeikend - toeikinit - footikoffset = toeikoffset
xtoe = this_chain[-1].xcurr - thisik[-1].xinit - xfoot
ytoe = this_chain[-1].ycurr - thisik[-1].yinit - yfoot
ztoe = this_chain[-1].zcurr - thisik[-1].zinit - zfoot
ikframe = [
thisik[-1].name, relevant_framenums[I], xtoe, ytoe, ztoe,
0.0, 0.0, 0.0, False
]
ikframe += [20] * 8
ikframe += [107] * 8
# append the freshly-built frame
ikframe_list.append(ikframe)
# now done with a timeframe for all bones on both sides
# print progress updates
core.print_progress_oneline(I / len(relevant_framenums))
core.MY_PRINT_FUNC(
"...done with forward kinematics computation, now writing output...")
if INCLUDE_IK_ENABLE_FRAME:
# create a single ikdispframe that enables the ik bones at frame 0
ikbones = [
vmdstruct.VmdIkbone(name=jp_rightfoot_ik, enable=True),
vmdstruct.VmdIkbone(name=jp_righttoe_ik, enable=True),
vmdstruct.VmdIkbone(name=jp_leftfoot_ik, enable=True),
vmdstruct.VmdIkbone(name=jp_lefttoe_ik, enable=True)
]
ikdispframe_list = [
vmdstruct.VmdIkdispFrame(f=0, disp=True, ikbones=ikbones)
]
else:
ikdispframe_list = []
core.MY_PRINT_FUNC(
"Warning: IK following will NOT be enabled when this VMD is loaded, you will need enable it manually!"
)
# convert old-style bonelist ikframe_list to new object format
ikframe_list = [
vmdstruct.VmdBoneFrame(name=r[0],
f=r[1],
pos=r[2:5],
rot=r[5:8],
phys_off=r[8],
interp=r[9:]) for r in ikframe_list
]
# build actual VMD object
nicelist_out = vmdstruct.Vmd(
vmdstruct.VmdHeader(2, "SEMISTANDARD-IK-BONES--------"),
ikframe_list, # bone
[], # morph
[], # cam
[], # light
[], # shadow
ikdispframe_list # ikdisp
)
# write out
output_filename_vmd = "%s_ik_from_%s.vmd" % \
(input_filename_vmd[0:-4], core.get_clean_basename(input_filename_pmx))
output_filename_vmd = core.get_unused_file_name(output_filename_vmd)
vmdlib.write_vmd(output_filename_vmd, nicelist_out, moreinfo=moreinfo)
core.MY_PRINT_FUNC("Done!")
return None