diff options
Diffstat (limited to 'scripts/content_tools')
| -rw-r--r-- | scripts/content_tools/anim_tool.py | 675 |
1 files changed, 382 insertions, 293 deletions
diff --git a/scripts/content_tools/anim_tool.py b/scripts/content_tools/anim_tool.py index b7585112c5..3aef8cd5ab 100644 --- a/scripts/content_tools/anim_tool.py +++ b/scripts/content_tools/anim_tool.py @@ -1,14 +1,22 @@ -#!runpy.sh - +#!/usr/bin/python """\ - -This module contains tools for manipulating the .anim files supported -for Second Life animation upload. Note that this format is unrelated -to any non-Second Life formats of the same name. - -$LicenseInfo:firstyear=2016&license=viewerlgpl$ +@file anim_tool.py +@author Brad Payne, Nat Goodspeed +@date 2015-09-15 +@brief This module contains tools for manipulating the .anim files supported + for Second Life animation upload. Note that this format is unrelated + to any non-Second Life formats of the same name. + + This code is a Python translation of the logic in + LLKeyframeMotion::serialize() and deserialize(): + https://bitbucket.org/lindenlab/viewer-release/src/827a910542a9af0a39b0ca03663c02e5c83869ea/indra/llcharacter/llkeyframemotion.cpp?at=default&fileviewer=file-view-default#llkeyframemotion.cpp-1864 + https://bitbucket.org/lindenlab/viewer-release/src/827a910542a9af0a39b0ca03663c02e5c83869ea/indra/llcharacter/llkeyframemotion.cpp?at=default&fileviewer=file-view-default#llkeyframemotion.cpp-1220 + save that there is no support for old-style .anim files, permitting + simpler code. + +$LicenseInfo:firstyear=2015&license=viewerlgpl$ Second Life Viewer Source Code -Copyright (C) 2016, Linden Research, Inc. +Copyright (C) 2015, Linden Research, Inc. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -28,63 +36,85 @@ Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA $/LicenseInfo$ """ -import sys -import os -import struct -import StringIO import math -import argparse +import os import random -from lxml import etree +from cStringIO import StringIO +import struct +import sys +from xml.etree import ElementTree + +class Error(Exception): + pass + +class BadFormat(Error): + """ + Something went wrong trying to read the specified .anim file. + """ + pass + +class ExtraneousData(BadFormat): + """ + Specifically, the .anim file in question contains more data than needed. + This could happen if the file isn't a .anim at all, and it 'just happens' + to read properly otherwise -- e.g. a block of all zero bytes could look + like empty name strings, empty arrays etc. That could be a legitimate + error -- or it could be due to a sloppy tool. Break this exception out + separately so caller can distinguish if desired. + """ + pass U16MAX = 65535 -OOU16MAX = 1.0/(float)(U16MAX) +# One Over U16MAX, for scaling +OOU16MAX = 1.0/float(U16MAX) LL_MAX_PELVIS_OFFSET = 5.0 class FilePacker(object): def __init__(self): - self.data = StringIO.StringIO() - self.offset = 0 + self.buffer = StringIO() def write(self,filename): - f = open(filename,"wb") - f.write(self.data.getvalue()) - f.close() + with open(filename,"wb") as f: + f.write(self.buffer.getvalue()) def pack(self,fmt,*args): buf = struct.pack(fmt, *args) - self.offset += struct.calcsize(fmt) - self.data.write(buf) + self.buffer.write(buf) def pack_string(self,str,size=0): - buf = str + "\000" - if size and (len(buf) < size): - buf += "\000" * (size-len(buf)) - self.data.write(buf) + # If size == 0, caller doesn't care, just wants a terminating nul byte + size = size or (len(str) + 1) + # Nonzero size means a fixed-length field. If the passed string (plus + # its terminating nul) exceeds that fixed length, we'll have to + # truncate. But make sure we still leave room for the final nul byte! + str = str[:size-1] + # Now pad what's left of str out to 'size' with nul bytes. + buf = str + ("\000" * (size-len(str))) + self.buffer.write(buf) class FileUnpacker(object): def __init__(self, filename): - f = open(filename,"rb") - self.data = f.read() + with open(filename,"rb") as f: + self.buffer = f.read() self.offset = 0 def unpack(self,fmt): - result = struct.unpack_from(fmt, self.data, self.offset) + result = struct.unpack_from(fmt, self.buffer, self.offset) self.offset += struct.calcsize(fmt) return result def unpack_string(self, size=0): - result = "" - i = 0 - while (self.data[self.offset+i] != "\000"): - result += self.data[self.offset+i] - i += 1 - i += 1 + # Nonzero size means we must consider exactly the next 'size' + # characters in self.buffer. if size: - # fixed-size field for the string - i = size - self.offset += i + self.offset += size + # but stop at the first nul byte + return self.buffer[self.offset-size:self.offset].split("\000", 1)[0] + # Zero size means consider everything until the next nul character. + result = self.buffer[self.offset:].split("\000", 1)[0] + # don't forget to skip the nul byte too + self.offset += len(result) + 1 return result # translated from the C++ version in lldefs.h @@ -108,7 +138,7 @@ def F32_to_U16(val, lower, upper): # translated from the C++ version in llquantize.h def U16_to_F32(ival, lower, upper): if ival < 0 or ival > U16MAX: - raise Exception("U16 out of range: "+ival) + raise ValueError("U16 out of range: %s" % ival) val = ival*OOU16MAX delta = (upper - lower) val *= delta @@ -121,71 +151,100 @@ def U16_to_F32(ival, lower, upper): val = 0.0 return val; -class BadFormat(Exception): - pass - class RotKey(object): - def __init__(self): - pass - - def unpack(self, anim, fup): - (self.time_short, ) = fup.unpack("<H") - self.time = U16_to_F32(self.time_short, 0.0, anim.duration) + def __init__(self, time, duration, rot): + """ + This constructor instantiates a RotKey object from scratch, as it + were, converting from float time to time_short. + """ + self.time = time + self.time_short = F32_to_U16(time, 0.0, duration) \ + if time is not None else None + self.rotation = rot + + @staticmethod + def unpack(duration, fup): + """ + This staticmethod constructs a RotKey by loadingfrom a FileUnpacker. + """ + # cheat the other constructor + this = RotKey(None, None, None) + # load time_short directly from the file + (this.time_short, ) = fup.unpack("<H") + # then convert to float time + this.time = U16_to_F32(this.time_short, 0.0, duration) + # convert each coordinate of the rotation from short to float (x,y,z) = fup.unpack("<HHH") - self.rotation = [U16_to_F32(i, -1.0, 1.0) for i in (x,y,z)] + this.rotation = [U16_to_F32(i, -1.0, 1.0) for i in (x,y,z)] + return this def dump(self, f): - print >>f, " rot_key: t",self.time,"st",self.time_short,"rot",",".join([str(f) for f in self.rotation]) + print >>f, " rot_key: t %.3f" % self.time,"st",self.time_short,"rot",",".join("%.3f" % f for f in self.rotation) - def pack(self, anim, fp): - if not hasattr(self,"time_short"): - self.time_short = F32_to_U16(self.time, 0.0, anim.duration) + def pack(self, fp): fp.pack("<H",self.time_short) (x,y,z) = [F32_to_U16(v, -1.0, 1.0) for v in self.rotation] fp.pack("<HHH",x,y,z) class PosKey(object): - def __init__(self): - pass - - def unpack(self, anim, fup): - (self.time_short, ) = fup.unpack("<H") - self.time = U16_to_F32(self.time_short, 0.0, anim.duration) + def __init__(self, time, duration, pos): + """ + This constructor instantiates a PosKey object from scratch, as it + were, converting from float time to time_short. + """ + self.time = time + self.time_short = F32_to_U16(time, 0.0, duration) \ + if time is not None else None + self.position = pos + + @staticmethod + def unpack(duration, fup): + """ + This staticmethod constructs a PosKey by loadingfrom a FileUnpacker. + """ + # cheat the other constructor + this = PosKey(None, None, None) + # load time_short directly from the file + (this.time_short, ) = fup.unpack("<H") + # then convert to float time + this.time = U16_to_F32(this.time_short, 0.0, duration) + # convert each coordinate of the rotation from short to float (x,y,z) = fup.unpack("<HHH") - self.position = [U16_to_F32(i, -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET) for i in (x,y,z)] + this.position = [U16_to_F32(i, -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET) + for i in (x,y,z)] + return this def dump(self, f): - print >>f, " pos_key: t",self.time,"pos ",",".join([str(f) for f in self.position]) + print >>f, " pos_key: t %.3f" % self.time,"pos ",",".join("%.3f" % f for f in self.position) - def pack(self, anim, fp): - if not hasattr(self,"time_short"): - self.time_short = F32_to_U16(self.time, 0.0, anim.duration) + def pack(self, fp): fp.pack("<H",self.time_short) (x,y,z) = [F32_to_U16(v, -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET) for v in self.position] fp.pack("<HHH",x,y,z) class Constraint(object): - def __init__(self): - pass - - def unpack(self, anim, fup): - (self.chain_length, self.constraint_type) = fup.unpack("<BB") - self.source_volume = fup.unpack_string(16) - self.source_offset = fup.unpack("<fff") - self.target_volume = fup.unpack_string(16) - self.target_offset = fup.unpack("<fff") - self.target_dir = fup.unpack("<fff") - fmt = "<ffff" - (self.ease_in_start, self.ease_in_stop, self.ease_out_start, self.ease_out_stop) = fup.unpack("<ffff") - - def pack(self, anim, fp): + @staticmethod + def unpack(duration, fup): + this = Constraint() + (this.chain_length, this.constraint_type) = fup.unpack("<BB") + this.source_volume = fup.unpack_string(16) + this.source_offset = fup.unpack("<fff") + this.target_volume = fup.unpack_string(16) + this.target_offset = fup.unpack("<fff") + this.target_dir = fup.unpack("<fff") + (this.ease_in_start, this.ease_in_stop, this.ease_out_start, this.ease_out_stop) = \ + fup.unpack("<ffff") + return this + + def pack(self, fp): fp.pack("<BB", self.chain_length, self.constraint_type) fp.pack_string(self.source_volume, 16) fp.pack("<fff", *self.source_offset) fp.pack_string(self.target_volume, 16) fp.pack("<fff", *self.target_offset) fp.pack("<fff", *self.target_dir) - fp.pack("<ffff", self.ease_in_start, self.ease_in_stop, self.ease_out_start, self.ease_out_stop) + fp.pack("<ffff", self.ease_in_start, self.ease_in_stop, + self.ease_out_start, self.ease_out_stop) def dump(self, f): print >>f, " constraint:" @@ -202,30 +261,26 @@ class Constraint(object): print >>f, " ease_out_stop",self.ease_out_stop class Constraints(object): - def __init__(self): - pass - - def unpack(self, anim, fup): - (self.num_constraints, ) = fup.unpack("<i") - self.constraints = [] - for i in xrange(self.num_constraints): - constraint = Constraint() - constraint.unpack(anim, fup) - self.constraints.append(constraint) - - def pack(self, anim, fp): - fp.pack("<i",self.num_constraints) + @staticmethod + def unpack(duration, fup): + this = Constraints() + (num_constraints, ) = fup.unpack("<i") + this.constraints = [Constraint.unpack(duration, fup) + for i in xrange(num_constraints)] + return this + + def pack(self, fp): + fp.pack("<i",len(self.constraints)) for c in self.constraints: - c.pack(anim,fp) + c.pack(fp) def dump(self, f): - print >>f, "constraints:",self.num_constraints + print >>f, "constraints:",len(self.constraints) for c in self.constraints: c.dump(f) class PositionCurve(object): def __init__(self): - self.num_pos_keys = 0 self.keys = [] def is_static(self): @@ -236,28 +291,27 @@ class PositionCurve(object): return False return True - def unpack(self, anim, fup): - (self.num_pos_keys, ) = fup.unpack("<i") - self.keys = [] - for k in xrange(0,self.num_pos_keys): - pos_key = PosKey() - pos_key.unpack(anim, fup) - self.keys.append(pos_key) + @staticmethod + def unpack(duration, fup): + this = PositionCurve() + (num_pos_keys, ) = fup.unpack("<i") + this.keys = [PosKey.unpack(duration, fup) + for k in xrange(num_pos_keys)] + return this - def pack(self, anim, fp): - fp.pack("<i",self.num_pos_keys) + def pack(self, fp): + fp.pack("<i",len(self.keys)) for k in self.keys: - k.pack(anim, fp) + k.pack(fp) def dump(self, f): print >>f, " position_curve:" - print >>f, " num_pos_keys", self.num_pos_keys - for k in xrange(0,self.num_pos_keys): - self.keys[k].dump(f) + print >>f, " num_pos_keys", len(self.keys) + for k in self.keys: + k.dump(f) class RotationCurve(object): def __init__(self): - self.num_rot_keys = 0 self.keys = [] def is_static(self): @@ -268,42 +322,46 @@ class RotationCurve(object): return False return True - def unpack(self, anim, fup): - (self.num_rot_keys, ) = fup.unpack("<i") - self.keys = [] - for k in xrange(0,self.num_rot_keys): - rot_key = RotKey() - rot_key.unpack(anim, fup) - self.keys.append(rot_key) + @staticmethod + def unpack(duration, fup): + this = RotationCurve() + (num_rot_keys, ) = fup.unpack("<i") + this.keys = [RotKey.unpack(duration, fup) + for k in xrange(num_rot_keys)] + return this - def pack(self, anim, fp): - fp.pack("<i",self.num_rot_keys) + def pack(self, fp): + fp.pack("<i",len(self.keys)) for k in self.keys: - k.pack(anim, fp) + k.pack(fp) def dump(self, f): print >>f, " rotation_curve:" - print >>f, " num_rot_keys", self.num_rot_keys - for k in xrange(0,self.num_rot_keys): - self.keys[k].dump(f) + print >>f, " num_rot_keys", len(self.keys) + for k in self.keys: + k.dump(f) class JointInfo(object): - def __init__(self): - pass - - def unpack(self, anim, fup): - self.joint_name = fup.unpack_string() - (self.joint_priority, ) = fup.unpack("<i") + def __init__(self, name, priority): + self.joint_name = name + self.joint_priority = priority self.rotation_curve = RotationCurve() - self.rotation_curve.unpack(anim, fup) self.position_curve = PositionCurve() - self.position_curve.unpack(anim, fup) - def pack(self, anim, fp): + @staticmethod + def unpack(duration, fup): + this = JointInfo(None, None) + this.joint_name = fup.unpack_string() + (this.joint_priority, ) = fup.unpack("<i") + this.rotation_curve = RotationCurve.unpack(duration, fup) + this.position_curve = PositionCurve.unpack(duration, fup) + return this + + def pack(self, fp): fp.pack_string(self.joint_name) fp.pack("<i", self.joint_priority) - self.rotation_curve.pack(anim, fp) - self.position_curve.pack(anim, fp) + self.rotation_curve.pack(fp) + self.position_curve.pack(fp) def dump(self, f): print >>f, "joint:" @@ -313,13 +371,26 @@ class JointInfo(object): self.position_curve.dump(f) class Anim(object): - def __init__(self, filename=None): + def __init__(self, filename=None, verbose=False): + # set this FIRST as it's consulted by read() and unpack() + self.verbose = verbose if filename: self.read(filename) def read(self, filename): fup = FileUnpacker(filename) - self.unpack(fup) + try: + self.unpack(fup) + except struct.error as err: + raise BadFormat("error reading %s: %s" % (filename, err)) + # By the end of streaming data in from our FileUnpacker, we should + # have consumed the entire thing. If there's excess data, it's + # entirely possible that this is a garbage file that happens to + # resemble a valid degenerate .anim file, e.g. with zero counts of + # things. + if fup.offset != len(fup.buffer): + raise ExtraneousData("extraneous data in %s; is it really a Linden .anim file?" % + filename) # various validity checks could be added - see LLKeyframeMotion::deserialize() def unpack(self,fup): @@ -333,27 +404,57 @@ class Anim(object): else: raise BadFormat("Bad combination of version, sub_version: %d %d" % (self.version, self.sub_version)) + # Also consult BVH conversion code for stricter checks + + # C++ deserialize() checks self.base_priority against + # LLJoint::ADDITIVE_PRIORITY and LLJoint::USE_MOTION_PRIORITY, + # possibly sets self.max_priority + # checks self.duration against MAX_ANIM_DURATION !! + # checks self.emote_name != str(self.ID) + # checks self.hand_pose against LLHandMotion::NUM_HAND_POSES !! + # checks 0 < num_joints <= LL_CHARACTER_MAX_JOINTS (no need -- + # validate names) + # checks each joint_name neither "mScreen" nor "mRoot" ("attempted to + # animate special joint") !! + # checks each joint_name can be found in mCharacter + # checks each joint_priority >= LLJoint::USE_MOTION_PRIORITY + # tracks max observed joint_priority, excluding USE_MOTION_PRIORITY + # checks each 0 <= RotKey.time <= self.duration !! + # checks each RotKey.rotation.isFinite() !! + # checks each PosKey.position.isFinite() !! + # checks 0 <= num_constraints <= MAX_CONSTRAINTS !! + # checks each Constraint.chain_length <= num_joints + # checks each Constraint.constraint_type < NUM_CONSTRAINT_TYPES !! + # checks each Constraint.source_offset.isFinite() !! + # checks each Constraint.target_offset.isFinite() !! + # checks each Constraint.target_dir.isFinite() !! + # from https://bitbucket.org/lindenlab/viewer-release/src/827a910542a9af0a39b0ca03663c02e5c83869ea/indra/llcharacter/llkeyframemotion.cpp?at=default&fileviewer=file-view-default#llkeyframemotion.cpp-1812 : + # find joint to which each Constraint's collision volume is attached; + # for each link in Constraint.chain_length, walk to joint's parent, + # find that parent in list of joints, set its index in index list + self.emote_name = fup.unpack_string() - (self.loop_in_point, self.loop_out_point, self.loop, self.ease_in_duration, self.ease_out_duration, self.hand_pose, self.num_joints) = fup.unpack("@ffiffII") + (self.loop_in_point, self.loop_out_point, self.loop, + self.ease_in_duration, self.ease_out_duration, self.hand_pose, num_joints) = \ + fup.unpack("@ffiffII") - self.joints = [] - for j in xrange(0,self.num_joints): - joint_info = JointInfo() - joint_info.unpack(self, fup) - self.joints.append(joint_info) - print "unpacked joint",joint_info.joint_name - self.constraints = Constraints() - self.constraints.unpack(self, fup) - self.data = fup.data + self.joints = [JointInfo.unpack(self.duration, fup) + for j in xrange(num_joints)] + if self.verbose: + for joint_info in self.joints: + print "unpacked joint",joint_info.joint_name + self.constraints = Constraints.unpack(self.duration, fup) + self.buffer = fup.buffer def pack(self, fp): fp.pack("@HHhf", self.version, self.sub_version, self.base_priority, self.duration) fp.pack_string(self.emote_name, 0) - fp.pack("@ffiffII", self.loop_in_point, self.loop_out_point, self.loop, self.ease_in_duration, self.ease_out_duration, self.hand_pose, self.num_joints) + fp.pack("@ffiffII", self.loop_in_point, self.loop_out_point, self.loop, + self.ease_in_duration, self.ease_out_duration, self.hand_pose, len(self.joints)) for j in self.joints: - j.pack(anim, fp) - self.constraints.pack(anim, fp) + j.pack(fp) + self.constraints.pack(fp) def dump(self, filename="-"): if filename=="-": @@ -370,7 +471,7 @@ class Anim(object): print >>f, "ease_in_duration: ", self.ease_in_duration print >>f, "ease_out_duration: ", self.ease_out_duration print >>f, "hand_pose", self.hand_pose - print >>f, "num_joints", self.num_joints + print >>f, "num_joints", len(self.joints) for j in self.joints: j.dump(f) self.constraints.dump(f) @@ -382,10 +483,9 @@ class Anim(object): def write_src_data(self, filename): print "write file",filename - f = open(filename,"wb") - f.write(self.data) - f.close() - + with open(filename,"wb") as f: + f.write(self.buffer) + def find_joint(self, name): joints = [j for j in self.joints if j.joint_name == name] if joints: @@ -395,91 +495,71 @@ class Anim(object): def add_joint(self, name, priority): if not self.find_joint(name): - j = JointInfo() - j.joint_name = name - j.joint_priority = priority - j.rotation_curve = RotationCurve() - j.position_curve = PositionCurve() - self.joints.append(j) - self.num_joints = len(self.joints) + self.joints.append(JointInfo(name, priority)) def delete_joint(self, name): j = self.find_joint(name) if j: - if args.verbose: + if self.verbose: print "removing joint", name - anim.joints.remove(j) - anim.num_joints = len(self.joints) + self.joints.remove(j) else: - if args.verbose: + if self.verbose: print "joint not found to remove", name def summary(self): nj = len(self.joints) nz = len([j for j in self.joints if j.joint_priority > 0]) - nstatic = len([j for j in self.joints if j.rotation_curve.is_static() and j.position_curve.is_static()]) + nstatic = len([j for j in self.joints + if j.rotation_curve.is_static() + and j.position_curve.is_static()]) print "summary: %d joints, non-zero priority %d, static %d" % (nj, nz, nstatic) def add_pos(self, joint_names, positions): js = [joint for joint in self.joints if joint.joint_name in joint_names] for j in js: - if args.verbose: + if self.verbose: print "adding positions",j.joint_name,positions j.joint_priority = 4 - j.position_curve.num_pos_keys = len(positions) - j.position_curve.keys = [] - for i,pos in enumerate(positions): - key = PosKey() - key.time = self.duration * i / (len(positions) - 1) - key.time_short = F32_to_U16(key.time, 0.0, self.duration) - key.position = pos - j.position_curve.keys.append(key) + j.position_curve.keys = [PosKey(self.duration * i / (len(positions) - 1), + self.duration, + pos) + for i,pos in enumerate(positions)] def add_rot(self, joint_names, rotations): js = [joint for joint in self.joints if joint.joint_name in joint_names] for j in js: print "adding rotations",j.joint_name j.joint_priority = 4 - j.rotation_curve.num_rot_keys = len(rotations) - j.rotation_curve.keys = [] - for i,pos in enumerate(rotations): - key = RotKey() - key.time = self.duration * i / (len(rotations) - 1) - key.time_short = F32_to_U16(key.time, 0.0, self.duration) - key.rotation = pos - j.rotation_curve.keys.append(key) + j.rotation_curve.keys = [RotKey(self.duration * i / (len(rotations) - 1), + self.duration, + rot) + for i,rot in enumerate(rotations)] def twistify(anim, joint_names, rot1, rot2): js = [joint for joint in anim.joints if joint.joint_name in joint_names] for j in js: print "twisting",j.joint_name - print j.rotation_curve.num_rot_keys + print len(j.rotation_curve.keys) j.joint_priority = 4 - j.rotation_curve.num_rot_keys = 2 - j.rotation_curve.keys = [] - key1 = RotKey() - key1.time_short = 0 - key1.time = U16_to_F32(key1.time_short, 0.0, anim.duration) - key1.rotation = rot1 - key2 = RotKey() - key2.time_short = U16MAX - key2.time = U16_to_F32(key2.time_short, 0.0, anim.duration) - key2.rotation = rot2 - j.rotation_curve.keys.append(key1) - j.rotation_curve.keys.append(key2) + # Set the joint(s) to rot1 at time 0, rot2 at the full duration. + j.rotation_curve.keys = [ + RotKey(0.0, anim.duration, rot1), + RotKey(anim.duration, anim.duration, rot2)] def float_triple(arg): vals = arg.split() if len(vals)==3: return [float(x) for x in vals] else: - raise Exception("arg %s does not resolve to a float triple" % arg) + raise ValueError("arg %s does not resolve to a float triple" % arg) def get_joint_by_name(tree,name): if tree is None: return None - matches = [elt for elt in tree.getroot().iter() if \ - elt.get("name")==name and elt.tag in ["bone", "collision_volume", "attachment_point"]] + matches = [elt for elt in tree.getroot().iter() + if elt.get("name")==name + and elt.tag in ["bone", "collision_volume", "attachment_point"]] if len(matches)==1: return matches[0] elif len(matches)>1: @@ -496,139 +576,148 @@ def get_elt_pos(elt): else: return (0.0, 0.0, 0.0) -def resolve_joints(names, skel_tree, lad_tree): - print "resolve joints, no_hud is",args.no_hud +def resolve_joints(names, skel_tree, lad_tree, no_hud=False): + print "resolve joints, no_hud is",no_hud if skel_tree and lad_tree: all_elts = [elt for elt in skel_tree.getroot().iter()] all_elts.extend([elt for elt in lad_tree.getroot().iter()]) - matches = [] + matches = set() for elt in all_elts: if elt.get("name") is None: continue #print elt.get("name"),"hud",elt.get("hud") - if args.no_hud and elt.get("hud"): + if no_hud and elt.get("hud"): #print "skipping hud joint", elt.get("name") continue if elt.get("name") in names or elt.tag in names: - matches.append(elt.get("name")) - return list(set(matches)) + matches.add(elt.get("name")) + return list(matches) else: return names -if __name__ == "__main__": +def main(*argv): + import argparse # default search location for config files is defined relative to # the script location; assuming they live in the same viewer repo + # Use sys.argv[0] because (a) this script lives where it lives regardless + # of what our caller passes and (b) we don't expect our caller to pass the + # script name anyway. pathname = os.path.dirname(sys.argv[0]) - path_to_skel = os.path.join(os.path.abspath(pathname),"..","..","indra","newview","character") + # we're in scripts/content_tools; hop back to base of repository clone + path_to_skel = os.path.join(os.path.abspath(pathname),os.pardir,os.pardir, + "indra","newview","character") parser = argparse.ArgumentParser(description="process SL animations") parser.add_argument("--verbose", help="verbose flag", action="store_true") parser.add_argument("--dump", help="dump to stdout", action="store_true") parser.add_argument("--rot", help="specify sequence of rotations", type=float_triple, nargs="+") - parser.add_argument("--rand_pos", help="request random positions within specified scale", type=float) + parser.add_argument("--rand_pos", help="request NUM random positions (default %(default)s)", + metavar="NUM", type=int, default=2) parser.add_argument("--reset_pos", help="request original positions", action="store_true") parser.add_argument("--pos", help="specify sequence of positions", type=float_triple, nargs="+") parser.add_argument("--duration", help="specify duration", type=float) parser.add_argument("--loop_in", help="specify loop in time", type=float) parser.add_argument("--loop_out", help="specify loop out time", type=float) parser.add_argument("--num_pos", help="number of positions to create", type=int, default=2) - parser.add_argument("--delete_joints", help="specify joints to be deleted", nargs="+") - parser.add_argument("--joints", help="specify joints to be added or modified", nargs="+") + parser.add_argument("--delete_joints", help="specify joints to be deleted", nargs="+", + metavar="JOINT") + parser.add_argument("--joints", help="specify joints to be added or modified", nargs="+", + metavar="JOINT") parser.add_argument("--summary", help="print summary of the output animation", action="store_true") - parser.add_argument("--skel", help="name of the avatar_skeleton file", default= os.path.join(path_to_skel,"avatar_skeleton.xml")) - parser.add_argument("--lad", help="name of the avatar_lad file", default= os.path.join(path_to_skel,"avatar_lad.xml")) - parser.add_argument("--set_version", nargs=2, type=int, help="set version and sub-version to specified values") + parser.add_argument("--skel", help="name of the avatar_skeleton file (default %(default)s)", + default=os.path.join(path_to_skel,"avatar_skeleton.xml"), + metavar="FILEPATH") + parser.add_argument("--lad", help="name of the avatar_lad file (default %(default)s)", + default=os.path.join(path_to_skel,"avatar_lad.xml"), + metavar="FILEPATH") + parser.add_argument("--set_version", nargs=2, type=int, + help="set version and sub-version to specified values", + metavar=("VERSION", "SUB-VERSION")) parser.add_argument("--no_hud", help="omit hud joints from list of attachments", action="store_true") parser.add_argument("--base_priority", help="set base priority", type=int) parser.add_argument("--joint_priority", help="set joint priority for all joints", type=int) parser.add_argument("infilename", help="name of a .anim file to input") parser.add_argument("outfilename", nargs="?", help="name of a .anim file to output") - args = parser.parse_args() + args = parser.parse_args(argv) - print "anim_tool.py: " + " ".join(sys.argv) + print "anim_tool.py: " + " ".join(argv) print "dump is", args.dump print "infilename",args.infilename,"outfilename",args.outfilename print "rot",args.rot print "pos",args.pos print "joints",args.joints - try: - anim = Anim(args.infilename) - skel_tree = None - lad_tree = None - joints = [] - if args.skel: - skel_tree = etree.parse(args.skel) - if skel_tree is None: - print "failed to parse",args.skel - exit(1) - if args.lad: - lad_tree = etree.parse(args.lad) - if lad_tree is None: - print "failed to parse",args.lad - exit(1) - if args.joints: - joints = resolve_joints(args.joints, skel_tree, lad_tree) - if args.verbose: - print "joints resolved to",joints - for name in joints: - anim.add_joint(name,0) - if args.delete_joints: - del_joints = resolve_joints(args.delete_joints, skel_tree, lad_tree) - if args.verbose: - print "delete_joints resolved to",del_joints - for name in del_joints: - anim.delete_joint(name) - joints.remove(name) - if joints and args.rot: - anim.add_rot(joints, args.rot) - if joints and args.pos: - anim.add_pos(joints, args.pos) - print "joints ",joints,"rand_pos",args.rand_pos,"num_pos",args.num_pos - if joints and args.rand_pos is not None: - print "rand_pos",args.rand_pos - for joint in joints: - pos_array = list(tuple(random.uniform(-args.rand_pos,args.rand_pos) for i in xrange(3)) for j in xrange(args.num_pos)) - pos_array.append(pos_array[0]) - anim.add_pos([joint], pos_array) - if joints and args.reset_pos: - for joint in joints: - elt = get_joint_by_name(skel_tree,joint) - if elt is None: - elt = get_joint_by_name(lad_tree,joint) - if elt is not None: - pos_array = [] - pos_array.append(get_elt_pos(elt)) - pos_array.append(pos_array[0]) - anim.add_pos([joint], pos_array) - else: - print "no elt or no pos data for",joint - if args.set_version: - anim.version = args.set_version[0] - anim.sub_version = args.set_version[1] - if args.base_priority is not None: - print "set base priority",args.base_priority - anim.base_priority = args.base_priority - if args.joint_priority is not None: - print "set joint priority",args.joint_priority - for joint in anim.joints: - joint.joint_priority = args.joint_priority - if args.duration is not None: - print "set duration",args.duration - anim.duration = args.duration - if args.loop_in is not None: - print "set loop_in",args.loop_in - anim.loop_in_point = args.loop_in - if args.loop_out is not None: - print "set loop_out",args.loop_out - anim.loop_out_point = args.loop_out - if args.dump: - anim.dump("-") - if args.summary: - anim.summary() - if args.outfilename: - anim.write(args.outfilename) - except: - raise + anim = Anim(args.infilename, args.verbose) + skel_tree = None + lad_tree = None + joints = [] + if args.skel: + skel_tree = ElementTree.parse(args.skel) + if skel_tree is None: + raise Error("failed to parse " + args.skel) + if args.lad: + lad_tree = ElementTree.parse(args.lad) + if lad_tree is None: + raise Error("failed to parse " + args.lad) + if args.joints: + joints = resolve_joints(args.joints, skel_tree, lad_tree, args.no_hud) + if args.verbose: + print "joints resolved to",joints + for name in joints: + anim.add_joint(name,0) + if args.delete_joints: + for name in args.delete_joints: + anim.delete_joint(name) + if joints and args.rot: + anim.add_rot(joints, args.rot) + if joints and args.pos: + anim.add_pos(joints, args.pos) + if joints and args.rand_pos: + # pick a random sequence of positions for each joint specified + for joint in joints: + # generate a list of rand_pos triples + pos_array = [tuple(random.uniform(-1,1) for i in xrange(3)) + for j in xrange(args.rand_pos)] + # close the loop by cycling back to the first entry + pos_array.append(pos_array[0]) + anim.add_pos([joint], pos_array) + if joints and args.reset_pos: + for joint in joints: + elt = get_joint_by_name(skel_tree,joint) or get_joint_by_name(lad_tree,joint) + if elt is not None: + anim.add_pos([joint], 2*[get_elt_pos(elt)]) + else: + print "no elt or no pos data for",joint + if args.set_version: + anim.version, anim.sub_version = args.set_version + if args.base_priority is not None: + print "set base priority",args.base_priority + anim.base_priority = args.base_priority + # --joint_priority sets priority for ALL joints, not just the explicitly- + # specified ones + if args.joint_priority is not None: + print "set joint priority",args.joint_priority + for joint in anim.joints: + joint.joint_priority = args.joint_priority + if args.duration is not None: + print "set duration",args.duration + anim.duration = args.duration + if args.loop_in is not None: + print "set loop_in",args.loop_in + anim.loop_in_point = args.loop_in + if args.loop_out is not None: + print "set loop_out",args.loop_out + anim.loop_out_point = args.loop_out + if args.dump: + anim.dump("-") + if args.summary: + anim.summary() + if args.outfilename: + anim.write(args.outfilename) +if __name__ == "__main__": + try: + sys.exit(main(*sys.argv[1:])) + except Error as err: + sys.exit("%s: %s" % (err.__class__.__name__, err)) |