def inter_ui(self): ui = lwsdk.LWPanels() panel = ui.create('Random Number') panel.setw(300) interval_control = panel.float_ctl('Change interval (seconds)') interval_control.set_float(self._change_interval) # 'width' for dir_ctl() is in characters, not pixels! path_control = panel.dir_ctl('Object path', 50) if len(self._object_path): path_control.set_str(self._object_path) path_control.set_event(self, self.path_callback) self._controls = [interval_control, path_control] panel.align_controls_vertical(self._controls) panel.size_to_layout(5, 5) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL): self._change_interval = interval_control.get_float() path = path_control.get_str() if not os.path.exists(path): lwsdk.LWMessageFuncs().error('The provided path', 'is invalid!') else: self._object_path = path ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, generic_access): self.tree_root = TreeNode("root") self.tree_root.children.append(TreeNode("Item 1")) self.tree_root.children[-1].children.append(TreeNode("Child 1-1")) self.tree_root.children[-1].children[-1].children.append( TreeNode("Child 1-1-1")) self.tree_root.children[-1].children[-1].children.append( TreeNode("Child 1-1-2")) self.tree_root.children[-1].children[-1].children[-1].children.append( TreeNode("Child 1-1-2-1")) self.tree_root.children.append(TreeNode("Item 2")) self.tree_root.children.append(TreeNode("Item 3")) self.tree_root.children[-1].children.append(TreeNode("Child 3-1")) ui = lwsdk.LWPanels() panel = ui.create('Test Tree') c1 = panel.tree_ctl('Tree', 200, 200, self.tree_info_func, self.tree_count_func, self.tree_node_func) c1.set_event(self.tree_event_func) # note: no event data panel.align_controls_vertical([c1]) panel.size_to_layout(5, 5) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, mod_command): ui = lwsdk.LWPanels() panel = ui.create('Subtract Weight') c = panel.listbox_ctl('Base Map', 300, 16, self.name_items, self.count_items) panel.align_controls_vertical([c]) panel.size_to_layout(1, 1) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK self._base = lwsdk.LWObjectFuncs().vmapName(lwsdk.LWVMAP_WGHT, c.get_int()) print('listed base weight: %s' % self._base) ui.destroy(panel) selname, selid = lwsdk.LWStateQueryFuncs().vmap(lwsdk.LWM_VMAP_WEIGHT) self._target = selname print('selected weight map id: %d' % selid) print('selected weight map name: %s' % selname) op = mod_command.editBegin(0, 0, lwsdk.OPSEL_USER) if not op: print >> sys.stderr, 'failed to editBegin' return lwsdk.AFUNC_OK result = lwsdk.EDERR_NONE try: selpoints = [] result = op.fastPointScan(op.state, self.fast_point_scan, (selpoints, ), lwsdk.OPLYR_FG, 1) if result != lwsdk.EDERR_NONE: op.done(op.state, result, 0) return lwsdk.AFUNC_OK print('selected points: %d' % len(selpoints)) #selpoints = op.genPoints(op.state, lwsdk.OPLYR_FG, 1) for p in selpoints: # get base value op.vMapSelect(op.state, self._base, lwsdk.LWVMAP_WGHT, 1) b = op.pointVGet(op.state, p)[1] print('pt:%d' % p) if (b != None): print('w(B):%f' % b) # get target value op.vMapSelect(op.state, self._target, lwsdk.LWVMAP_WGHT, 1) v = op.pointVGet(op.state, p)[1] if (v != None): print('w(A):%f' % v) if (b != None): v = 1.0 - b else: v = 1.0 op.pntVMap(op.state, p, lwsdk.LWVMAP_WGHT, self._target, [v]) except: result = lwsdk.EDERR_USERABORT raise finally: op.done(op.state, result, 0) return lwsdk.AFUNC_OK
def inter_ui(self): global object_path ui = lwsdk.LWPanels() panel = ui.create('Frame Timer') panel.setw(300) # 'width' for dir_ctl() is in characters, not pixels! self._path_control = panel.dir_ctl('Object path', 50) if len(object_path): self._path_control.set_str(object_path) self._path_control.set_event(self, self.path_callback) panel.size_to_layout(5, 5) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL): path = self._path_control.get_str() if not os.path.exists(path): lwsdk.LWMessageFuncs().error('The provided path', 'is invalid!') else: object_path = path ui.destroy(panel) return lwsdk.AFUNC_OK
def inter_ui(self): ui = lwsdk.LWPanels() panel = ui.create('Lazy Points') panel.setw(200) lag_control = panel.float_ctl('Lag rate') lag_control.set_float(self._lag_rate) spin_control = panel.hdragbut_ctl('') # The second 'data' argument is optional, and will be set to None if omitted. spin_control.set_event(self.drag_callback) # instead of calling a class method, you can use a stand-alone function # spin_control.set_event(drag_standalone, self) self._controls = [lag_control, spin_control] panel.align_controls_horizontal(self._controls) self._drag_accumulate = 0 if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL): self._lag_rate = lag_control.get_float() ui.destroy(panel) return lwsdk.AFUNC_OK
def inter_ui(self): ui = lwsdk.LWPanels() panel = ui.create('Noisy Channel') panel.setw(150) offset_control = panel.float_ctl('Offset') offset_control.set_float(self._offset) speed_control = panel.float_ctl('Speed') speed_control.set_float(self._speed) scale_control = panel.float_ctl('Scale') scale_control.set_float(self._scale) phase_control = panel.float_ctl('Phase') phase_control.set_float(self._phase) self._controls = [ offset_control, speed_control, scale_control, phase_control ] panel.align_controls_vertical(self._controls) #panel.size_to_layout(5, 5) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL): self._offset = offset_control.get_float() self._speed = speed_control.get_float() self._scale = scale_control.get_float() self._phase = phase_control.get_float() ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, mod_command): self.read_history() ui = lwsdk.LWPanels() panel = ui.create('Select layers by string ' + __version__ + ' - ' + __copyright__) self.text_string = panel.str_ctl("String", 50) self.hchoice_contains = panel.hchoice_ctl( "Select FG Layer", ('Contains string', 'Not contains string')) self.bool_others = panel.bool_ctl("Select others as BG Layer") self.bool_sort_history = panel.bool_ctl( "Move the last condition up if they match") self.list_history = panel.multilist_ctl('History', 450, 10, self.nameCallback, self.countCallback, self.columnCallback) self.button_remove = panel.button_ctl("Remove") self.button_remove.ghost() self.list_history.set_select(self.selectCallback) self.button_remove.set_event(self.remove_history) self.set_default_values() if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK history = HistoryData() history.string = self.text_string.get_str() history.select_contains = not self.hchoice_contains.get_int() history.select_others = self.bool_others.get_int() self.last_string = history.string self.last_select_contains = history.select_contains self.last_others = history.select_others self.sort_history = self.bool_sort_history.get_int() self.add_history(history) self.write_history() try: self.select_layers(mod_command, history) except NoForegroundLayer: message_funcs = lwsdk.LWMessageFuncs() message_funcs.error('No foreground layer', '') finally: return lwsdk.AFUNC_OK ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, generic_access): ui = lwsdk.LWPanels() panel = ui.create('Test Multilist') c1 = panel.multilist_ctl('Multilist', 200, 10, self.name_2d, self.count_2d, self.column_width) c1.set_select(self.multi_select_event_func) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_RESIZE) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, generic_access): ui = lwsdk.LWPanels() panel = ui.create('Test Custom Popup') self._c1 = panel.custpopup_ctl('Custom Popup', 200, self.name_1d, self.count_1d) self._c1.set_event(self.popup_event) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, generic_access): ui = lwsdk.LWPanels() panel = ui.create('Test Listbox') c1 = panel.listbox_ctl('Listbox', 200, 10, self.name_1d, self.count_1d) c1.set_select(self.single_select_event_func) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_RESIZE) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, mod_command): ui = lwsdk.LWPanels() panel = ui.create(RESOURCE % 'Test Multilist Control') c1 = panel.multilist_ctl(RESOURCE % 'Multilist', 200, 10, self.nameCallback, self.countCallback, self.columnCallback) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, generic_access): ui = lwsdk.LWPanels() panel = ui.create('Test Text') c1 = panel.text_ctl( 'Text', ['Static text 1', 'Static text 1', 'Static text 1']) panel.align_controls_vertical([c1]) panel.size_to_layout(5, 5) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_RESIZE) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK ui.destroy(panel) return lwsdk.AFUNC_OK
def inter_ui(self): global scale_choice ui = lwsdk.LWPanels() panel = ui.create('Sol') panel.setw(200) scale_control = panel.wpopup_ctl('Per-slice scaling', scaling_factors_str, 75) scale_control.set_int(scale_choice) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL): scale_choice = scale_control.get_int() self.adjust_scaling() ui.destroy(panel) return lwsdk.AFUNC_OK
def inter_ui(self): if self._panel: self.release_panel() else: if not self._ui: self._ui = lwsdk.LWPanels() self._panel = self._ui.create('Ring Test') target_obj_ctl = self._panel.item_ctl('Target', lwsdk.LWI_ANY) target_obj_ctl.set_event(self.effector_change) camera_obj_ctl = self._panel.item_ctl('Camera', lwsdk.LWI_CAMERA) camera_obj_ctl.set_event(self.camera_change) camera_active_ctl = self._panel.bool_ctl('Active') camera_active_ctl.set_event(self.active_change) camera_active_ctl.set_int(0) camera_active_ctl.ghost() target_active_ctl = self._panel.bool_ctl('Target object') target_active_ctl.set_event(self.target_change) target_active_ctl.set_int(0) target_active_ctl.ghost() radius_ctl = self._panel.percent_ctl('Radius') radius_ctl.set_event(self.radius_change) radius_ctl.set_float(100.0) radius_ctl.ghost() self._controls = [ target_obj_ctl, camera_obj_ctl, camera_active_ctl, target_active_ctl, radius_ctl ] self._panel.align_controls_vertical(self._controls) self._panel.size_to_layout(5, 5) self._panel.set_close_callback(self.panel_close) self._panel.open(lwsdk.PANF_NOBUTT) return lwsdk.AFUNC_OK
def __init__(self, context): # context has no relevant value in a Master plug-in super(ring_test, self).__init__() self._item_info = lwsdk.LWItemInfo() self._ui = lwsdk.LWPanels() self._panel = None self._comring = lwsdk.LWComRing() self._selected_camera = None self._selected_camera_name = None self._camera_active = {} self._camera_radii = {} self._camera_target = {} self._target_object = None # connect to the channel self._comring.ringAttach("ringtest_channel", self, self.ring_event)
def process(self, mod_command): self.history = recall("history", []) print self.history ui = lwsdk.LWPanels() panel = ui.create(RESOURCE % 'historyList') self.c2 = panel.str_ctl(RESOURCE % "String", 50) self.c3 = panel.bool_ctl(RESOURCE % "contains string (FG)") self.c4 = panel.bool_ctl(RESOURCE % "others (BG)") self.listHistory = panel.multilist_ctl(RESOURCE % 'History', 450, 10, self.nameCallback, self.countCallback, self.columnCallback) self.listHistory.set_select(self.selectCallback) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK tmp_history = historyData() tmp_history.string = self.c2.get_str() tmp_history.isContain = False if self.c3.get_int() < 1 else True tmp_history.selectOthers = False if self.c4.get_int() < 1 else True index = self.searchHistory(tmp_history) if index < 0: if len(tmp_history.string) > 0: self.history.insert(0, tmp_history) store("history", self.history) else: self.moveHistoryRecordForward(index) store("history", self.history) ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, mod_command): ui = lwsdk.LWPanels() panel = ui.create( RESOURCE % 'Select layers with string - Copyright(C)2012 naru design') self.c2 = panel.str_ctl(RESOURCE % "String", 50) self.c3 = panel.bool_ctl(RESOURCE % "contains string (FG)") self.c4 = panel.bool_ctl(RESOURCE % "others (BG)") self.c1 = panel.multilist_ctl(RESOURCE % 'History', 450, 10, self.nameCallback, self.countCallback, self.columnCallback) self.c1.set_select(self.selectCallback) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK ui.destroy(panel) return lwsdk.AFUNC_OK
def process(self, mod_command): ui = lwsdk.LWPanels() panel = ui.create('Random Point Distribution') c1 = panel.int_ctl('Number of points') c2 = panel.fvec_ctl('Radius') c3 = panel.hchoice_ctl('Shape', ['Round', 'Square']) c4 = panel.hchoice_ctl('Falloff towards', ['Center', 'Edges']) c5 = panel.int_ctl('Steepness') c6 = panel.hchoice_ctl('Density distribution', ['Linear', 'Exponential', 'Constant']) c7 = panel.str_ctl('Surface', 50) panel.align_controls_vertical([c1, c2, c3, c4, c5, c6, c7]) panel.size_to_layout(5, 5) c1.set_int(self._num_points) c2.setv_fvec(self._radius) c3.set_int(self._shape) c4.set_int(self._falloff) c5.set_int(self._steepness) c6.set_int(self._density) c7.set_str(self._surface) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK self._num_points = c1.get_int() self._radius = c2.getv_fvec() self._shape = c3.get_int() self._falloff = c4.get_int() self._steepness = c5.get_int() self._density = c6.get_int() self._surface = c7.get_str() ui.destroy(panel) rmax = (self._radius[0] + self._radius[1] + self._radius[2]) / 3.0 mesh_edit_op = mod_command.editBegin(0, 0, lwsdk.OPSEL_USER) if not mesh_edit_op: print >>sys.stderr, 'Failed to engage mesh edit operations!' return lwsdk.AFUNC_OK monitor_funcs = lwsdk.DynaMonitorFuncs() dyna_monitor = monitor_funcs.create("Random Point Distribution", "Generating points...") if dyna_monitor: dyna_monitor.init(dyna_monitor.data, self._num_points) edit_op_result = lwsdk.EDERR_NONE random.seed() # catch exceptions to make sure Modeler ends up on a sane state try: i = 0 while i < self._num_points: if self._shape == ptspread.ROUND: point = lwsdk.Vector( (2.0 * random.random() - 1.0) * self._radius[0], (2.0 * random.random() - 1.0) * self._radius[1], (2.0 * random.random() - 1.0) * self._radius[2] ) r = abs(lwsdk.Vector.magnitude(point)) p = self.point_prob(self._density + self._falloff, r, rmax, self._steepness) if random.random() < p: pid = mesh_edit_op.addPoint(mesh_edit_op.state, point) mesh_edit_op.addPoly(mesh_edit_op.state, lwsdk.LWPOLTYPE_FACE, None, self._surface, [pid]) i += 1 if dyna_monitor: if dyna_monitor.step(dyna_monitor.data, 1): edit_op_result = lwsdk.EDERR_USERABORT break else: # SQUARE point = lwsdk.Vector() point.x = (2.0 * random.random() - 1.0) * self._radius[0] p = self.point_prob(self._density + self._falloff, point.x, rmax, self._steepness) point.y = (2.0 * random.random() - 1.0) * self._radius[1] p += self.point_prob(self._density + self._falloff, point.y, rmax, self._steepness) point.z = (2.0 * random.random() - 1.0) * self._radius[2] p += self.point_prob(self._density + self._falloff, point.z, rmax, self._steepness) p /= 3.0 if random.random() < p: pid = mesh_edit_op.addPoint(mesh_edit_op.state, point) mesh_edit_op.addPoly(mesh_edit_op.state, lwsdk.LWPOLTYPE_FACE, None, self._surface, [pid]) i += 1 if dyna_monitor: if dyna_monitor.step(dyna_monitor.data, 1): edit_op_result = lwsdk.EDERR_USERABORT break except: edit_op_result = lwsdk.EDERR_USERABORT raise finally: mesh_edit_op.done(mesh_edit_op.state, edit_op_result, 0) if dyna_monitor: dyna_monitor.done(dyna_monitor.data) monitor_funcs.destroy(dyna_monitor) return lwsdk.AFUNC_OK
def process(self, mod_command): ui = lwsdk.LWPanels() panel = ui.create('Bubbles') c1 = panel.hchoice_ctl('Sphere Type', ['Globe', 'Tesselated']) c2 = panel.int_ctl('Tesselation Level') c3 = panel.dist_ctl('Maximum Radius') c4 = panel.dist_ctl('Minimum Radius') c5 = panel.int_ctl('Globe Sides') c6 = panel.int_ctl('Globe Segments') c7 = panel.str_ctl('Surface', 50) panel.align_controls_vertical([c1, c2, c3, c4, c5, c6, c7]) panel.size_to_layout(5, 5) c1.set_int(self._sphereType) c2.set_int(self._tessLevel) c3.set_float(self._maxRadius) c4.set_float(self._minRadius) c5.set_int(self._globeSides) c6.set_int(self._globeSegments) c7.set_str(self._surface) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK self._sphereType = c1.get_int() self._tessLevel = c2.get_int() self._maxRadius = c3.get_float() self._minRadius = c4.get_float() self._globeSides = c5.get_int() self._globeSegments = c6.get_int() self._surface = c7.get_str() ui.destroy(panel) cs_dict = self.get_commands(mod_command) random.seed() cs_options = lwsdk.marshall_dynavalues((self._surface, )) result, dyna_value = mod_command.execute(mod_command.data, cs_dict["SURFACE"], cs_options, lwsdk.OPSEL_USER) mesh_edit_op = mod_command.editBegin(0, 0, lwsdk.OPSEL_USER) if not mesh_edit_op: print >> sys.stderr, 'Failed to engage mesh edit operations!' return lwsdk.AFUNC_OK # gather up the point ids points = [] # NOTE: we will be passing in a sequence (list or tuple) as the argument to the callback. # internally, Python expects a sequence as an argument to the function, so it MUST be encased # in another sequence, or it will be mistaken for a sequence containing the arguments # (instead of an argument itself). edit_op_result = mesh_edit_op.fastPointScan(mesh_edit_op.state, self.fast_point_scan, (points, ), lwsdk.OPLYR_FG, 1) if edit_op_result != lwsdk.EDERR_NONE: mesh_edit_op.done(mesh_edit_op.state, edit_op_result, 0) return lwsdk.AFUNC_OK point_count = len(points) # print some info to the PCore console print '%d points found for lwsdk.OPLYR_FG' % point_count edit_op_result = lwsdk.EDERR_NONE monitor_funcs = lwsdk.DynaMonitorFuncs() dyna_monitor = monitor_funcs.create("Bubbles", "Removing points...") if dyna_monitor: dyna_monitor.init(dyna_monitor.data, point_count) positions = [] # catch exceptions to make sure Modeler ends up on a sane state try: for point in points: print type(point) positions.append( lwsdk.Vector( mesh_edit_op.pointPos(mesh_edit_op.state, point))) mesh_edit_op.remPoint(mesh_edit_op.state, point) if dyna_monitor: if dyna_monitor.step(dyna_monitor.data, 1): edit_op_result = lwsdk.EDERR_USERABORT break except: edit_op_result = lwsdk.EDERR_USERABORT raise finally: mesh_edit_op.done(mesh_edit_op.state, edit_op_result, 0) if dyna_monitor: dyna_monitor.done(dyna_monitor.data) monitor_funcs.destroy(dyna_monitor) dyna_monitor = monitor_funcs.create("Bubbles", "Creating bubbles...") if dyna_monitor: dyna_monitor.init(dyna_monitor.data, point_count) for position in positions: percent = random.random() radius = lwsdk.Vector(self._minRadius + ( (self._maxRadius - self._minRadius) * percent)) if self._sphereType == bubbles.GLOBE: cs_options = lwsdk.marshall_dynavalues( (radius, self._globeSides, self._globeSegments, position)) result, dyna_value = mod_command.execute( mod_command.data, cs_dict["MAKEBALL"], cs_options, lwsdk.OPSEL_USER) else: cs_options = lwsdk.marshall_dynavalues( (radius, self._tessLevel, position)) result, dyna_value = mod_command.execute( mod_command.data, cs_dict["MAKETESBALL"], cs_options, lwsdk.OPSEL_USER) if dyna_monitor: if dyna_monitor.step(dyna_monitor.data, 1): edit_op_result = lwsdk.EDERR_USERABORT break if dyna_monitor: dyna_monitor.done(dyna_monitor.data) monitor_funcs.destroy(dyna_monitor) return lwsdk.AFUNC_OK
def process(self, ga): ui = lwsdk.LWPanels() panel = ui.create('Scatter Objects') c1 = panel.dist_ctl('Radius') c2 = panel.bool_ctl('X') c3 = panel.bool_ctl('Y') c4 = panel.bool_ctl('Z') c1.set_float(self._radius) c2.set_int(1 if self._include_x else 0) c3.set_int(1 if self._include_y else 0) c4.set_int(1 if self._include_z else 0) panel.align_controls_vertical([c1, c2, c3, c4]) panel.size_to_layout(5, 5) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK self._radius = c1.get_float() self._include_x = (c2.get_int() == 1) self._include_y = (c3.get_int() == 1) self._include_z = (c4.get_int() == 1) ui.destroy(panel) item_info = lwsdk.LWItemInfo() interface_info = lwsdk.LWInterfaceInfo() current_time = interface_info.curTime autokey_is_on = ((interface_info.generalFlags & lwsdk.LWGENF_AUTOKEY) != 0) selected_items = interface_info.selected_items() for obj in selected_items: r = random() x_invert = -1 if r < 0.5 else 1 x_value = 0.0 if self._include_x: x_value = random() * self._radius * x_invert r = random() y_invert = -1 if r < 0.5 else 1 y_value = 0.0 if self._include_y: y_value = random() * self._radius * y_invert r = random() z_invert = -1 if r < 0.5 else 1 z_value = 0.0 if self._include_z: z_value = random() * self._radius * z_invert ga.evaluate(ga.data, "SelectItem %s" % lwsdk.itemid_to_str(obj)) ga.evaluate(ga.data, "Position %f %f %f" % (x_value, y_value, z_value)) if not autokey_is_on: ga.evaluate(ga.data, "CreateKey %f" % current_time) return lwsdk.AFUNC_OK
def process(self, generic_access): #launch interface ui = lwsdk.LWPanels() panel = ui.create('Package Scene') panel.setw(750) # The consolidate option doesn't move anything, but grabs all assets and puts them in the content structure # you're currently using self.consolidate_check = panel.bool_ctl("Consolidate files only") self.consolidate_check.move(150, self.consolidate_check.y() ) self.consolidate_check.set_event(self.consolidate_active ) # The panel.dir_ctl() call creates a requester in which you'll choose the destination folder self.target_folder = panel.dir_ctl("Destination folder:", 98) self.target_folder.set_event(self.refresh_items) self.preserve_check = panel.bool_ctl("Preserve Existing Structure") # Subfolders are folders that go below the Objects, Scenes, and Images folders, should they be needed. self.asset_string = panel.str_ctl("Subfolder:", 72) self.asset_string.set_event(self.refresh_items) # This gives the user the option of whether to copy complete image sequences or not. # If the user opts not to copy the sequences, only the first image of the sequence will be copied self.imseq_check = panel.bool_ctl("Copy Image Sequences") self.imseq_check.set_event(self.imseq_active) # This selection box gives the user the option to either consolidate all images (including sequences) # into the target Images directory, or to have subfolders created for image sequences to keep # them neat and tidy self.imsub_list = [] self.imsub_list.append("Root Images folder") self.imsub_list.append("Sequence-named subfolder") self.imsub_choice = panel.hchoice_ctl("Image sequence destination:", self.imsub_list) self.imseq_active(self, self.imseq_active) # This displays the eventual path destinations for the individual asset types self.sc_string = panel.dir_ctl("Scenes path:", 98) self.ob_string = panel.dir_ctl("Objects path:", 98) self.im_string = panel.dir_ctl("Images path:", 98) self.dyn_string = panel.dir_ctl("Dynamics path:", 98) self.ies_string = panel.dir_ctl("Photometric lights path:",98) self.rad_string = panel.dir_ctl("Radiosity Cache path:",98) self.vert_string = panel.dir_ctl("Vertex Cache path:",98) self.radsave_check = panel.bool_ctl("Copy Radiosity cache file") self.radsave_check.set_event(self.radcache_active) self.radcache_active(self, self.radcache_active) self.radsave_check.set_int(1) self.rad_string.unghost() self.reload_check = panel.bool_ctl("Reload Original Scene") panel.align_controls_vertical([self.consolidate_check, self.target_folder, self.preserve_check, self.asset_string, self.imseq_check, self.imsub_choice, self.sc_string, self.ob_string, self.im_string, self.dyn_string, self.ies_string, self.rad_string, self.vert_string, self.radsave_check, self.reload_check]) self.target_folder.set_str(self.content_dir) self.refresh_items(None,None) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK #end interface ------------------------------------------------------------------------ #getting values ------------------------------------------------------------------------ self.consolidate = self.consolidate_check.get_int() self.target_dir = self.target_folder.get_str() self.preserve = self.preserve_check.get_int() self.asset_str = self.asset_string.get_str() self.imseq = self.imseq_check.get_int() self.imsub = self.imsub_choice.get_int() self.ob_dir = self.ob_string.get_str() self.sc_dir = self.sc_string.get_str() self.im_dir = self.im_string.get_str() self.dyn_dir = self.dyn_string.get_str() self.ies_dir = self.ies_string.get_str() self.rad_dir = self.rad_string.get_str() self.vert_dir = self.vert_string.get_str() self.radsave = self.radsave_check.get_int() self.reload = self.reload_check.get_int() #end getting values ------------------------------------------------------------------------ self.comring.ringAttach(self.RINGNAME,self,self.comring_event) data = self.comring.encodeData("s:512#2",(self.content_dir, self.target_dir)); self.comring.ringMessage(self.RINGNAME,1,data); # event #1 would be "copy to new content" #self.comring.ringDetatch(self.RINGNAME) #begin image processing ------------------------------------------------------------------------ if self.images.first() != None: # there are images to be worked on if self.consolidate == True: asset_str = "" self.target_dir = self.content_dir self.ob_dir = self.consol_string("Objects") self.sc_dir = self.consol_string("Scenes") self.im_dir = self.consol_string("Images") self.dyn_dir = self.consol_string("Dynamics") self.ies_dir = self.consol_string("Lights") self.rad_dir = self.consol_string("Radiosity") self.vert_dir = self.consol_string("VertCache") for currentImage in self.imageMasterList: #construct new path currentfile = self.images.filename(currentImage,0) #current filename from the big list currentname = self.images.name(currentImage) if self.content_dir in currentfile: validContent = True else: validContent = False # sequence section ---- if '(sequence)' in currentname and self.imseq == True: #is a sequence and wants to copy it if validContent == True and self.preserve == 1: #wants to preserve, and has a chance #target is the destination content + original directory image_target = os.path.join(self.target_dir,os.path.dirname(currentfile).replace(self.content_dir,'').strip('\\/') ) else: #don't want to preserve or can't image_target = self.im_dir #not valid content directory, can't preserve first_image = self.copy_sequence(currentfile, currentname, image_target, self.imsub) # process and copy sequence self.images.replace(currentImage, first_image) # image section ---------- else: #not a sequence if validContent == True and self.preserve == 1: #wants to preserve, and has a chance #target is the destination content + original directory image_target = os.path.join(self.target_dir,os.path.dirname(currentfile).replace(self.content_dir,'').strip('\\/') ) else: image_target = self.make_content_target(currentfile,self.im_dir) #get the destination target path self.psCopy(currentfile, image_target) #copy, making directories if necessary self.images.replace(currentImage, image_target) #replace old image with new else: # no images loaded pass # "No Images to copy" # end image processing ----------------------------- lwsdk.command("ContentDirectory " + self.target_dir) # begin object processing --------------------------------------------- #get object list item_info = lwsdk.LWItemInfo() obj_info = lwsdk.LWObjectInfo() objlist = [] myobj = item_info.first( lwsdk.LWI_OBJECT, lwsdk.LWITEM_NULL ) if myobj != lwsdk.LWITEM_NULL: objlist.append( myobj ) while myobj != lwsdk.LWITEM_NULL: myobj = item_info.next( myobj ) if myobj != lwsdk.LWITEM_NULL: objlist.append( myobj ) #get destination path for obj in objlist: #if item_info.name( obj ) != obj_info.filename( obj ): # probably isn't a null object if obj_info.numPoints( obj ) != 1 and obj_info.numPolygons( obj ) != 0: if self.preserve == True and os.path.dirname(obj_info.filename( obj )) != self.content_dir and self.content_dir in obj_info.filename( obj ): # valid and can preserve ob_path = obj_info.filename( obj ).replace(self.content_dir,'') new_path = os.path.join(self.ob_dir, ob_path) else: new_path = os.path.join(self.ob_dir, os.path.basename(obj_info.filename( obj ))) try: os.makedirs( os.path.dirname(new_path) ) except: try: os.makedirs( os.path.dirname(new_path) + os.sep ) except: myerr = sys.exc_value #save object to new path if os.path.lexists( os.path.dirname(new_path) ) == True: lwsdk.command("SelectByName " + item_info.name( obj )) lwsdk.command("SaveObject " + new_path) else: pass # "Must be null" # end object processing ------------------ # begin scene processing ----------------- if self.preserve == 1 and self.content_dir in self.scene.filename and os.path.dirname(self.scene.filename) != self.content_dir: sc_sub = self.scene.filename.replace(self.content_dir,'') new_scene = os.path.join(self.sc_dir, sc_sub, self.scene.name) else: new_scene = os.path.join(self.sc_dir, self.scene.name) try: os.makedirs( os.path.dirname(new_scene) ) except: try: os.makedirs( os.path.dirname(new_scene) + os.sep ) except: myerr = sys.exc_value if os.path.lexists( os.path.dirname(new_scene) ) == True: tempdir = tempfile.mkdtemp() tempscene = os.path.join(tempdir, self.scene.name) lwsdk.command("SaveSceneCopy " + tempscene) infile = open(tempscene, "r") lines = infile.readlines() infile.close() outfile = open(new_scene, 'w') photo_on = False bdd_on = False mdd_on = False vert_on = False mddnode_on = False flock_on = False # scan scene for ancillary files for l in lines: l = l.replace('\n','') # strip newline # 1. Get path # 2. Find old item # 3. Prepare new path # 4. Copy old item to new path # 5. Write new path to Scene file #process bdd files #if ".bdd" in l: # l is the line out of the Scene file if "FX_Break" in l: # l is the line out of the Scene file bdd_on = True # Switch this on, since we've found a BDD line outfile.write(l + "\n") elif ".bdd" in l and bdd_on == True: bddunc = False # Start out assuming it is NOT a UNC path if l.startswith("\\\\"): bddunc = True # If the line starts with at double-backslash, fair bet it's a UNC path ls = l.replace('\\','/') oldbddpath = os.path.join(self.content_dir, ls ) if self.preserve == True: if content_dir in oldbddpath: preserve = True else: preserve = False if preserve == True and self.preserve == True: newbddpath = os.path.join(self.target_dir, os.path.dirname(ls), os.path.basename(ls) ) else: newbddpath = os.path.join(self.dyn_dir, os.path.basename(ls) ) self.psCopy(oldbddpath.replace('\\','/'), newbddpath.replace('\\','/') ) if bddunc == True: outfile.write( newbddpath + "\n") else: outfile.write( l + "\n") elif "EndPlugin" in l and bdd_on == True: outfile.write(l + "\n") outfile.write("\n") bdd_on = False elif "FX_MotionDrive" in l: mdd_on = True outfile.write(l + "\n") elif ".mdd" in l and mdd_on == True: mdd_on = False l = l.replace('\\','/') oldmddpath = os.path.join(self.content_dir, l) if self.preserve == True: newmddpath = os.path.join(self.target_dir, l) else: newmddpath = os.path.join( self.dyn_dir, os.path.basename(l) ) self.psCopy(oldmddpath, newmddpath) outfile.write( l + "\n" ) elif "MD_Plug" in l: vert_on = True outfile.write( l + "\n" ) elif ".mdd" in l and vert_on == True and mddnode_on == False: vertunc = False oldvertpath = os.path.join( self.content_dir, l.strip().replace('\"','') ) if oldvertpath.startswith("\\\\"): vertunc = True ls = l.strip().replace('\"','').split('\\/') newvertpath = os.path.join( self.vert_dir, os.path.basename(l.strip().replace('\"','') ) ) if vertunc == True: oldvertnorm = os.path.normpath(oldvertpath) oldvertnorm = oldvertnorm.replace(r'\\\\',r'\\') self.psCopy(oldvertnorm, newvertpath) else: self.psCopy(oldvertpath, newvertpath) outline = ' \"' + self.strip_first_slash(newvertpath[len(self.target_dir):]) + '\"\n' outfile.write(outline) vert_on = False elif ".xml" in l and vert_on == True and mddnode_on == False: xmlunc = False oldvertpath = os.path.join( self.content_dir, l.strip().replace('\"','') ) oldmc = os.path.splitext(oldvertpath)[0] + ".mc" if oldvertpath.startswith("\\\\"): xmlunc = True ls = l.strip().replace('\"','').split('\\/') newvertpath = os.path.join( self.vert_dir, os.path.basename(l.strip().replace('\"','') ) ) newmc = os.path.splitext(newvertpath)[0] + ".mc" if xmlunc == True: oldvertnorm = os.path.normpath(oldvertpath) oldvertnorm = oldvertnorm.replace(r'\\\\',r'\\') oldmcnorm = os.path.normpath(oldmc) oldmcnorm = oldmcnorm.replace(r'\\\\',r'\\') self.psCopy(oldvertnorm, newvertpath) self.psCopy(oldmcnorm, newmc) self.copy_mc_sequence(oldmcnorm, newmc) else: self.psCopy(oldvertpath, newvertpath) self.psCopy(oldmc, newmc) self.copy_mc_sequence(oldmc, newmc) outline = ' \"' + self.strip_first_slash(newvertpath[len(self.target_dir):]) + '\"\n' outfile.write(outline) vert_on = False elif "{ MDReader" in l: outfile.write( l + "\n" ) elif "MDD_Node" in l: mddnode_on = True outfile.write( l + "\n") elif ".mdd" in l and mddnode_on == True and vert_on == False: mddnode_on = False l = l.replace('\\','/') oldvertpath = os.path.join( self.content_dir, l.strip().replace('\"','') ) ls = l.strip().replace('\"','').split('\\/') newvertpath = os.path.join( self.vert_dir, os.path.basename(l.strip().replace('\"','') ) ) self.psCopy(oldvertpath, newvertpath) outline = '\"' + self.strip_first_slash(newvertpath[len(self.target_dir):]) + '\"\n' outfile.write(' Filename ' + outline ) # Process Particle FX files elif ".pfx" in l: pfxunc = False lsplit = l.split(None,5) ls = os.path.normpath(lsplit[5]) if ls.startswith("\\\\"): #UNC path pfxunc = True if '\\' in ls or '/' in ls: # this section is for the Mac, if it's having trouble lsp = ls.split('\\') # dealing with backslashes ls = lsp[-1] oldpfxpath = os.path.join( self.content_dir,lsplit[5] ) if self.content_dir in oldpfxpath: preserve = True else: preserve = False if preserve == 1 and self.preserve == 1: newpfxpath = os.path.join(self.target_dir,lsplit[5]) else: newpfxpath = os.path.join(self.dyn_dir, os.path.basename(ls) ) psCopySource = oldpfxpath.replace('\\','/') psCopyDest = newpfxpath.replace('\\','/') self.psCopy(psCopySource, psCopyDest) lsplit[5] = newpfxpath outline = ' '.join(lsplit) outfile.write(" " + outline + "\n") # Process IES Lights elif "Plugin LightHandler" in l and "PhotometricLight" in l: outfile.write("Plugin LightHandler 1 PhotometricLight\n") photo_on = True elif photo_on == True and "File \"" in l: oldiespath = l[8:-1] if oldiespath[:1] == ":": oldiespath = os.sep + oldiespath[1:] newiespath = os.path.join(self.ies_dir, os.path.basename(oldiespath)) if newiespath[:1] == ":": newiespath = os.sep + newiespath[1:] outfile.write(' File \"' + self.strip_first_slash(newiespath) + '\"\n') self.psCopy(oldiespath, newiespath) photo_on = False # Process Radiosity Cache files elif "RadiosityCacheFilePath" in l and self.radsave == True: l = l.split(None,1)[1] oldradpath_drive = os.path.splitdrive(l)[0] oldradpath_path = os.path.dirname(os.path.splitdrive(l)[1]) oldradpath_file = os.path.basename(l) if oldradpath_drive != None: oldradpath = os.path.join(oldradpath_drive, oldradpath_path, oldradpath_file).replace('\\','/') if oldradpath[:1] == ":": oldradpath = os.sep + oldradpath[1:] else: oldradpath = os.path.join(self.content_dir, l) newradpath = os.path.join(self.rad_dir, oldradpath_file).replace('\\','/') if newradpath[:1] == ":": newradpath = os.sep + newradpath[1:] self.psCopy(oldradpath, newradpath ) outfile.write('RadiosityCacheFilePath ' + self.strip_first_slash(newradpath) + "\n") #Copy flocking cache data elif "FlockMaster" in l: outfile.write(l + "\n") flock_on = True flock_count = 1 elif flock_on == True and flock_count == 1: outfile.write(l + "\n") flock_count = flock_count + 1 elif flock_on == True and flock_count == 2: flock_count = flock_count + 1 flockunc = False lsplit = l.replace("\"",'') ls = os.path.normpath(lsplit) if ls.startswith("\\\\"): flockunc = True if '\\' in ls or '/' in ls: lsp = ls.split('\\') ls = lsp[-1] oldflockpath = os.path.join( self.content_dir, lsplit) if self.preserve == True: if self.content_dir in oldflockpath: preserve = True else: preserve = False if self.preserve == True and preserve == True: newflockpath = os.path.join(self.dyn_dir, ls) else: newflockpath = os.path.join(self.dyn_dir, os.path.basename(ls)) psCopySource = os.path.normpath(oldflockpath) psCopyDest = os.path.normpath(newflockpath) self.psCopy(psCopySource, psCopyDest) newflockwrite = '\"' + newflockpath.replace('\\','\\\\') + '\"' elif flock_on == True and "EndPlugin" in l: flock_on = False outfile.write(l + "\n") else: #if nothing matched, just pass the line right through to the new scene outfile.write( l + "\n") # copy over Bullet dynamics cache file if os.path.lexists(os.path.join( self.content_dir, "Dynamics") ): dynasource = os.path.join( self.content_dir, "Dynamics", self.scene.name[:-4]) + ".dynacache" dynadest = os.path.join( self.dyn_dir, os.path.basename( dynasource ) ) self.psCopy(dynasource, dynadest) outfile.close() self.psCopy(tempscene, new_scene) if self.reload == True: lwsdk.command("LoadScene " + self.scene.filename) else: lwsdk.command("LoadScene " + new_scene) os.remove(tempscene) os.rmdir(tempdir) return lwsdk.AFUNC_OK
def process(self, mod_command): ui = lwsdk.LWPanels() panel = ui.create('Final Fantasy 7:Remake Import') controlWidth = 64 c1 = panel.load_ctl('Select File', controlWidth) c1.set_str(self._filepath) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK self.filepath = c1.get_str() edit_op_result = lwsdk.EDERR_NONE cs_dict = self.get_commands(mod_command) progress_count = 8 cs_test0 = mod_command.lookup(mod_command.data, "cmdseq") t1 = time.time() files = path_wrangler(self.filepath) files.get_files() #Dump(files) md = open(files.data['uexp'], 'rb') ua = open(files.data['uasset'], 'rb') meshName = files.data['meshName'] submesh_name = files.data['submesh_name'] arm = False weightData = {} Weight_array = [] vertexArray = [] NA = [] normal_array = [] UVs0 = [] UVs1 = [] UVs2 = [] UVs3 = [] UVs4 = [] faces = [] names = readUasset(ua) ua.close() mod_command.undoGroupBegin() pattern0 = re.compile( b'\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00........') for x in xrange(20000): s1 = struct.unpack("18s", md.read(18))[0] if pattern0.match(s1): c0 = struct.unpack("<L", md.read(4))[0] c1 = struct.unpack("<L", md.read(4))[0] c2 = struct.unpack("<L", md.read(4))[0] c3 = struct.unpack("<L", md.read(4))[0] c4 = struct.unpack("<L", md.read(4))[0] if (c0 and c1 and c2 and c3 and c4 > 1000000000): break else: md.seek(-20, 1) md.seek(-17, 1) materialCount = struct.unpack("<L", md.read(4))[0] progress_count += materialCount materials = {} for m in xrange(materialCount): materials[m] = {} materials[m]['val0'] = struct.unpack("<l", md.read(4))[0] stringIndex = struct.unpack("<L", md.read(4))[0] unk0 = struct.unpack("<L", md.read(4))[0] unk1 = struct.unpack("<L", md.read(4))[0] unk2 = struct.unpack("<L", md.read(4))[0] unk3 = struct.unpack("<f", md.read(4))[0] unk4 = struct.unpack("<f", md.read(4))[0] unk5 = struct.unpack("<L", md.read(4))[0] unk6 = struct.unpack("<L", md.read(4))[0] materials[m]['name'] = names[stringIndex] boneCount = struct.unpack("<L", md.read(4))[0] joint_data = {} joint_names = [] for i in xrange(boneCount): string_index = struct.unpack("<L", md.read(4))[0] jName = names[string_index] unk = struct.unpack("<L", md.read(4))[0] parent = struct.unpack("<l", md.read(4))[0] joint_data[i] = {"name": jName, "parent": parent} joint_names.append(jName) boneCount2 = struct.unpack("<L", md.read(4))[0] if not moninit(progress_count, "Importing", title='Progress'): raise Exception('Hell!') layerindex = 1 for i in range(boneCount): m1 = struct.unpack("<10f", md.read(40)) monstep() cs_options = lwsdk.marshall_dynavalues(str(layerindex)) result = mod_command.execute(mod_command.data, cs_dict["SETLAYER"], cs_options, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues(meshName) result = mod_command.execute(mod_command.data, cs_dict["SETLAYERNAME"], cs_options, lwsdk.OPSEL_USER) layerindex += 1 boneCount3 = struct.unpack("<L", md.read(4))[0] md.seek(boneCount3 * 12, 1) vertexGroups = {} unk0 = struct.unpack("<L", md.read(4))[0] unk1 = struct.unpack("B", md.read(1))[0] unk2 = struct.unpack("B", md.read(1))[0] groupCount = struct.unpack("<L", md.read(4))[0] for m in xrange(groupCount): z1 = struct.unpack("<H", md.read(2))[0] ID = struct.unpack("<H", md.read(2))[0] md.seek(24, 1) vertexGroups[ID] = {'range': 0, 'bones': []} # pragma region bone palette start = struct.unpack("<L", md.read(4))[0] count = struct.unpack("<L", md.read(4))[0] vertexGroups[ID]['bones_np'] = np.zeros((boneCount2, ), dtype=int) bone_names = [] for bn in xrange(count): bid = struct.unpack("<H", md.read(2))[0] vertexGroups[ID]['bones_np'][bn] = bid vertexGroups[ID]['bones'].append(bid) bone_names.append(joint_data[bid]["name"]) # pragma endregion bone palette size = struct.unpack("<L", md.read(4))[0] stop = start + size vertexGroups[ID]['range'] = np.arange(start, stop) vertexGroups[ID]["start"] = start vertexGroups[ID]["stop"] = stop vertexGroups[ID]["size"] = size vertexGroups[ID]["names"] = bone_names md.seek(34, 1) FFx4 = readHexString(md, 4) flag = struct.unpack("<L", md.read(4))[0] if flag: # extra data for this group count = struct.unpack("<L", md.read(4))[0] md.seek(count * 16, 1) else: null = struct.unpack("<L", md.read(4))[0] unk = struct.unpack("B", md.read(1))[0] checkHere = md.tell() stride = struct.unpack("<L", md.read(4))[0] fCount = struct.unpack("<L", md.read(4))[0] faceByteCount = fCount * stride fi = np.fromfile(md, dtype='B', count=faceByteCount) if stride == 4: fi_0 = fi.view(dtype='<L').reshape(fCount // 3, 3) elif stride == 2: fi_0 = fi.view(dtype='<H').reshape(fCount // 3, 3) fi_0[:, [0, 1]] = fi_0[:, [1, 0]] faces = fi_0.tolist() unkCount = struct.unpack("<L", md.read(4))[0] md.seek(unkCount * 2, 1) unk = struct.unpack("<L", md.read(4))[0] vertexCount = struct.unpack("<L", md.read(4))[0] boneCount = struct.unpack("<L", md.read(4))[0] md.seek(boneCount * 2, 1) null0 = struct.unpack("<L", md.read(4))[0] null1 = struct.unpack("<L", md.read(4))[0] uv_count = struct.unpack("<L", md.read(4))[0] unk0 = struct.unpack("<H", md.read(2))[0] uv_count2 = struct.unpack("<L", md.read(4))[0] null2 = struct.unpack("<L", md.read(4))[0] unk1 = struct.unpack("<f", md.read(4))[0] unk2 = struct.unpack("<f", md.read(4))[0] unk3 = struct.unpack("<f", md.read(4))[0] null3 = struct.unpack("<L", md.read(4))[0] null4 = struct.unpack("<L", md.read(4))[0] null5 = struct.unpack("<L", md.read(4))[0] vStride = struct.unpack("<L", md.read(4))[0] vCount = struct.unpack("<L", md.read(4))[0] byteCount = vCount * vStride vi = np.fromfile(md, dtype='B', count=byteCount).reshape( (vCount, vStride)) pos = vi[:, 8:20].ravel().view(dtype='<f').reshape((vCount, 3)) pos[:, [0, 2]] = pos[:, [2, 0]] pos[:, [0, 1]] = pos[:, [1, 0]] VA = pos.tolist() if uv_count > 0: uvData_0 = vi[:, 20:24].ravel().view(dtype='<f2').reshape( (vCount, 2)) uvData_0[:, 1:2] *= -1 uvData_0[:, 1:2] += 1 UVs0 = uvData_0.tolist() if uv_count > 1: uvData_1 = vi[:, 24:28].ravel().view(dtype='<f2').reshape( (vCount, 2)) uvData_1[:, 1:2] *= -1 uvData_1[:, 1:2] += 1 UVs1 = uvData_1.tolist() if uv_count > 2: uvData_2 = vi[:, 28:32].ravel().view(dtype='<f2').reshape( (vCount, 2)) uvData_2[:, 1:2] *= -1 uvData_2[:, 1:2] += 1 UVs2 = uvData_2.tolist() if uv_count > 3: uvData_3 = vi[:, 32:36].ravel().view(dtype='<f2').reshape( (vCount, 2)) uvData_3[:, 1:2] *= -1 uvData_3[:, 1:2] += 1 UVs3 = uvData_3.tolist() if uv_count > 4: uvData_4 = vi[:, 36:40].ravel().view(dtype='<f2').reshape( (vCount, 2)) uvData_4[:, 1:2] *= -1 uvData_4[:, 1:2] += 1 UVs4 = uvData_4.tolist() monstep() mesh_edit_op = mod_command.editBegin(0, 0, lwsdk.OPSEL_USER) #points map(lambda x: v_f(x, vertexArray, mesh_edit_op), VA) monstep() #faces material_IDs = np.empty([1, fCount], dtype='U32').reshape(fCount // 3, 3) for g in vertexGroups: h = np.in1d(fi_0, vertexGroups[g]['range']).reshape(fi_0.shape) m = np.all(h, axis=1) material_IDs[m] = materials[g]['name'] monstep() map(lambda x, y: f_f(x, vertexArray, mesh_edit_op, y), faces, material_IDs) monstep() #UVs val = 0 if uv_count > 0: map(lambda x, y: uv_f(x, y, val, mesh_edit_op, meshName), vertexArray, UVs0) val += 1 if uv_count > 1: map(lambda x, y: uv_f(x, y, val, mesh_edit_op, meshName), vertexArray, UVs1) val += 1 if uv_count > 2: map(lambda x, y: uv_f(x, y, val, mesh_edit_op, meshName), vertexArray, UVs2) val += 1 if uv_count > 3: map(lambda x, y: uv_f(x, y, val, mesh_edit_op, meshName), vertexArray, UVs3) val += 1 if uv_count > 4: map(lambda x, y: uv_f(x, y, val, mesh_edit_op, meshName), vertexArray, UVs4) val += 1 monstep() unkS = struct.unpack("<H", md.read(2))[0] extraBoneWeights = struct.unpack("<L", md.read(4))[0] wCount = struct.unpack("<L", md.read(4))[0] stride = struct.unpack("<L", md.read(4))[0] wCount2 = struct.unpack("<L", md.read(4))[0] subStride = stride // 2 for q in xrange(len(vertexGroups)): boneNames = vertexGroups[q]["names"] start = vertexGroups[q]["start"] stop = vertexGroups[q]["stop"] for j in xrange(start, stop): b0 = struct.unpack("B", md.read(1))[0] b1 = struct.unpack("B", md.read(1))[0] b2 = struct.unpack("B", md.read(1))[0] b3 = struct.unpack("B", md.read(1))[0] b4 = struct.unpack("B", md.read(1))[0] b5 = struct.unpack("B", md.read(1))[0] b6 = struct.unpack("B", md.read(1))[0] b7 = struct.unpack("B", md.read(1))[0] bn0 = boneNames[b0] bn1 = boneNames[b1] bn2 = boneNames[b2] bn3 = boneNames[b3] bn4 = boneNames[b4] bn5 = boneNames[b5] bn6 = boneNames[b6] bn7 = boneNames[b7] w0 = struct.unpack("B", md.read(1))[0] / 255.0 w1 = struct.unpack("B", md.read(1))[0] / 255.0 w2 = struct.unpack("B", md.read(1))[0] / 255.0 w3 = struct.unpack("B", md.read(1))[0] / 255.0 w4 = struct.unpack("B", md.read(1))[0] / 255.0 w5 = struct.unpack("B", md.read(1))[0] / 255.0 w6 = struct.unpack("B", md.read(1))[0] / 255.0 w7 = struct.unpack("B", md.read(1))[0] / 255.0 mesh_edit_op.pntVMap(mesh_edit_op.state, vertexArray[j], lwsdk.LWVMAP_WGHT, bn0, [w0]) mesh_edit_op.pntVMap(mesh_edit_op.state, vertexArray[j], lwsdk.LWVMAP_WGHT, bn1, [w1]) mesh_edit_op.pntVMap(mesh_edit_op.state, vertexArray[j], lwsdk.LWVMAP_WGHT, bn2, [w2]) mesh_edit_op.pntVMap(mesh_edit_op.state, vertexArray[j], lwsdk.LWVMAP_WGHT, bn3, [w3]) mesh_edit_op.pntVMap(mesh_edit_op.state, vertexArray[j], lwsdk.LWVMAP_WGHT, bn4, [w4]) mesh_edit_op.pntVMap(mesh_edit_op.state, vertexArray[j], lwsdk.LWVMAP_WGHT, bn5, [w5]) mesh_edit_op.pntVMap(mesh_edit_op.state, vertexArray[j], lwsdk.LWVMAP_WGHT, bn6, [w6]) mesh_edit_op.pntVMap(mesh_edit_op.state, vertexArray[j], lwsdk.LWVMAP_WGHT, bn7, [w7]) monstep() mesh_edit_op.done(mesh_edit_op.state, edit_op_result, 0) monend() mod_command.undoGroupEnd() elapsed = time.time() - t1 print "Time: " + str(elapsed) md.close() return lwsdk.AFUNC_OK
def process(self, ga): ui = lwsdk.LWPanels() panel = ui.create('Final Fantasy 7:Remake Import') controlWidth = 64 c1 = panel.load_ctl('Select File', controlWidth) c1.set_str(self._filepath) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK self.filepath = c1.get_str() progress_count = 8 t1 = time.time() interface_info = lwsdk.LWInterfaceInfo() if not (interface_info.generalFlags & lwsdk.LWGENF_PARENTINPLACE): ga.evaluate(ga.data, "ParentInPlace") #set bind pose at frame -10 ga.evaluate(ga.data, "GoToFrame -10") interface_info = lwsdk.LWInterfaceInfo() selected_items = interface_info.selected_items() #if a mesh not selected create a parent null for the bones if not selected_items: result = ga.evaluate(ga.data, "AddNull Root") interface_info = lwsdk.LWInterfaceInfo() selected_items = interface_info.selected_items() buildItemID = selected_items[0] else: item_info = lwsdk.LWItemInfo() mytype = item_info.type(selected_items[0]) if mytype == lwsdk.LWI_OBJECT: buildItemID = selected_items[0] else: result = ga.evaluate(ga.data, "AddNull Root") interface_info = lwsdk.LWInterfaceInfo() selected_items = interface_info.selected_items() buildItemID = selected_items[0] #get weightmap count object_functions = lwsdk.LWObjectFuncs() numWeights = object_functions.numVMaps(lwsdk.LWVMAP_WGHT) files = path_wrangler(self.filepath) files.get_files() md = open(files.data['uexp'], 'rb') ua = open(files.data['uasset'], 'rb') meshName = files.data['meshName'] submesh_name = files.data['submesh_name'] arm = False weightData = {} Weight_array = [] vertexArray = [] NA = [] normal_array = [] UVs0 = [] UVs1 = [] UVs2 = [] UVs3 = [] UVs4 = [] faces = [] names = readUasset(ua) ua.close() pattern0 = re.compile( b'\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00........') for x in xrange(20000): s1 = struct.unpack("18s", md.read(18))[0] if pattern0.match(s1): c0 = struct.unpack("<L", md.read(4))[0] c1 = struct.unpack("<L", md.read(4))[0] c2 = struct.unpack("<L", md.read(4))[0] c3 = struct.unpack("<L", md.read(4))[0] c4 = struct.unpack("<L", md.read(4))[0] if (c0 and c1 and c2 and c3 and c4 > 1000000000): break else: md.seek(-20, 1) md.seek(-17, 1) materialCount = struct.unpack("<L", md.read(4))[0] materials = {} for m in xrange(materialCount): materials[m] = {} materials[m]['val0'] = struct.unpack("<l", md.read(4))[0] stringIndex = struct.unpack("<L", md.read(4))[0] unk0 = struct.unpack("<L", md.read(4))[0] unk1 = struct.unpack("<L", md.read(4))[0] unk2 = struct.unpack("<L", md.read(4))[0] unk3 = struct.unpack("<f", md.read(4))[0] unk4 = struct.unpack("<f", md.read(4))[0] unk5 = struct.unpack("<L", md.read(4))[0] unk6 = struct.unpack("<L", md.read(4))[0] materials[m]['name'] = names[stringIndex] boneCount = struct.unpack("<L", md.read(4))[0] joint_data = {} joint_names = [] for i in xrange(boneCount): string_index = struct.unpack("<L", md.read(4))[0] jName = names[string_index] unk = struct.unpack("<L", md.read(4))[0] parent = struct.unpack("<l", md.read(4))[0] joint_data[i] = {"name": jName, "parent": parent} boneCount2 = struct.unpack("<L", md.read(4))[0] progress_count += boneCount2 if not moninit(progress_count, "Importing", title='Progress'): raise Exception('Hell!') boneArray = [] psn = {} IDs = [] for bn in range(boneCount2): boneName = joint_data[bn]["name"] BNparent = joint_data[bn]["parent"] m1 = struct.unpack("<10f", md.read(40)) ps0 = (m1[4], m1[5], m1[6]) #BNps = np.asarray(ps0) rt0_ = (m1[3], m1[0], m1[1], m1[2]) rt0 = quat2mat(rt0_) if BNparent == -1: BNparent = 0 #BNps = [mi[3,1], mi[3,2], mi[3,0]] BNps = ps0 psn[bn] = BNps #BNrt = mat2euler(mi, axes='ryxz') ga.evaluate(ga.data, "SelectItem %s" % lwsdk.itemid_to_str(buildItemID)) layoutCommand = "AddBone " + boneName result = ga.evaluate(ga.data, layoutCommand) # no influence except for weight maps result = ga.evaluate(ga.data, 'BoneStrength 0') interface_info = lwsdk.LWInterfaceInfo() selected_items = interface_info.selected_items() itemID = selected_items[0] IDs.append(itemID) #UpdateMotion needed for parent in place if bn != 0: ga.evaluate(ga.data, 'UpdateMotion') ga.evaluate( ga.data, "ParentItem %s" % lwsdk.itemid_to_str(IDs[BNparent])) layoutCommand = "Position " + str(BNps[0]) + " " + str( BNps[1]) + " " + str(BNps[2]) result = ga.evaluate(ga.data, layoutCommand) if bn == 0: result = ga.evaluate(ga.data, "BoneRestLength 0.5") else: lenX = psn[BNparent][0] - BNps[0] lenY = psn[BNparent][1] - BNps[1] lenZ = psn[BNparent][2] - BNps[2] #dont use full bone length....dummy boneLength = math.sqrt(lenX * lenX + lenY * lenY + lenZ * lenZ) * 0.6 result = ga.evaluate(ga.data, "BoneRestLength " + str(boneLength)) #BNrt = quat2euler(rt0_, axes='szyx') BNrt = quat2euler(rt0_, axes='ryxz') rotx = (180.0 / math.pi) * BNrt[0] roty = (180.0 / math.pi) * BNrt[1] rotz = (180.0 / math.pi) * BNrt[2] layoutCommand = "Rotation " + str(rotx) + " " + str( roty) + " " + str(rotz) result = ga.evaluate(ga.data, layoutCommand) if bn == 0: layoutCommand = "Rotation " + str(180.0) + " " + str( 180.0) + " " + str(0.0) result = ga.evaluate(ga.data, layoutCommand) # if 'autokey' is not turned on, we need to explicitly # create keys for the object at the current time offset if not (interface_info.generalFlags & lwsdk.LWGENF_AUTOKEY): ga.evaluate(ga.data, "CreateKey %f" % interface_info.curTime) #keys created at frame -10 so delete any at frame 0 ga.evaluate(ga.data, 'DeleteKey 0') if (numWeights > 0): if bn != 0: for b in range(numWeights): weightName = object_functions.vmapName( lwsdk.LWVMAP_WGHT, b) if weightName == boneName: layoutCommand = 'BoneWeightMapName ' + boneName result = ga.evaluate(ga.data, layoutCommand) result = ga.evaluate(ga.data, 'BoneWeightMapOnly') ga.evaluate(ga.data, 'RecordRestPosition') monstep() #-----------------------------------------------------------# boneCount3 = struct.unpack("<L", md.read(4))[0] md.seek(boneCount3 * 12, 1) vertexGroups = {} unk0 = struct.unpack("<L", md.read(4))[0] unk1 = struct.unpack("B", md.read(1))[0] unk2 = struct.unpack("B", md.read(1))[0] groupCount = struct.unpack("<L", md.read(4))[0] for m in xrange(groupCount): z1 = struct.unpack("<H", md.read(2))[0] ID = struct.unpack("<H", md.read(2))[0] md.seek(24, 1) vertexGroups[ID] = {'range': 0, 'bones': []} # pragma region bone palette start = struct.unpack("<L", md.read(4))[0] count = struct.unpack("<L", md.read(4))[0] vertexGroups[ID]['bones_np'] = np.zeros((boneCount2, ), dtype=int) bone_names = [] for bn in xrange(count): bid = struct.unpack("<H", md.read(2))[0] vertexGroups[ID]['bones_np'][bn] = bid vertexGroups[ID]['bones'].append(bid) bone_names.append(joint_data[bid]["name"]) # pragma endregion bone palette size = struct.unpack("<L", md.read(4))[0] stop = start + size vertexGroups[ID]['range'] = np.arange(start, stop) vertexGroups[ID]["start"] = start vertexGroups[ID]["stop"] = stop vertexGroups[ID]["size"] = size vertexGroups[ID]["names"] = bone_names md.seek(34, 1) FFx4 = readHexString(md, 4) flag = struct.unpack("<L", md.read(4))[0] if flag: # extra data for this group count = struct.unpack("<L", md.read(4))[0] md.seek(count * 16, 1) else: null = struct.unpack("<L", md.read(4))[0] process_surfaces(files, vertexGroups, materials) #-----------------------------------------------------------# ga.evaluate(ga.data, 'SelectAllBones') #ga.evaluate(ga.data, 'RecordRestPosition') bonemayastyledraw() itemiconscale(0.2) monend() elapsed = time.time() - t1 print "Time: " + str(elapsed) md.close() return lwsdk.AFUNC_OK
def process(self, mod_command): ui = lwsdk.LWPanels() panel = ui.create('Gears') c1 = panel.hchoice_ctl('Axis', ['X', 'Y', 'Z']) c2 = panel.int_ctl('Number of Teeth') c3 = panel.dist_ctl('Inner Radius') c4 = panel.dist_ctl('Outer Radius') c5 = panel.dist_ctl('Thickness') c6 = panel.hchoice_ctl('Gear Type', ['Angular', 'Smooth']) c7 = panel.fvec_ctl('Center') panel.align_controls_vertical([c1, c2, c3, c4, c5, c6, c7]) panel.size_to_layout(5, 5) c1.set_int(self._axis) c2.set_int(self._teeth) c3.set_float(self._rad_inner) c4.set_float(self._rad_outer) c5.set_float(self._thickness) c6.set_int(self._geartype) c7.setv_fvec(self._center) if panel.open(lwsdk.PANF_BLOCKING | lwsdk.PANF_CANCEL) == 0: ui.destroy(panel) return lwsdk.AFUNC_OK self._axis = c1.get_int() self._teeth = c2.get_int() self._rad_inner = c3.get_float() self._rad_outer = c4.get_float() self._thickness = c5.get_float() self._geartype = c6.get_int() self._center = c7.getv_fvec() ui.destroy(panel) cs_dict = self.get_commands(mod_command) cx = self._center[0] cy = self._center[1] cz = self._center[2] - (self._thickness / 2) t_ang = 360 / self._teeth / 57.2957794 # figure out the layers we need to use and those that are # available for our temporary work fg_layers = lwsdk.LWStateQueryFuncs().layerList(lwsdk.OPLYR_FG, None) fg_layers_list = fg_layers.split() empty_layers = lwsdk.LWStateQueryFuncs().layerList( lwsdk.OPLYR_EMPTY, None) empty_layers_list = empty_layers.split() cs_options = lwsdk.marshall_dynavalues(fg_layers_list[0]) result = mod_command.execute(mod_command.data, cs_dict["SETLAYER"], cs_options, lwsdk.OPSEL_USER) x = 0 empty_layer = empty_layers_list[x] while x < len(empty_layers_list) and (empty_layer in fg_layers_list): x += 1 empty_layer = empty_layers_list[x] # only punch a hole if we can get an empty layer to work in if x == len(empty_layers_list): print >> sys.stderr, "Cannot locate an empty background layer!" return lwsdk.AFUNC_OK mesh_edit_op = mod_command.editBegin(0, 0, lwsdk.OPSEL_USER) if not mesh_edit_op: print >> sys.stderr, 'Failed to engage mesh edit operations!' return lwsdk.AFUNC_OK monitor_funcs = lwsdk.DynaMonitorFuncs() dyna_monitor = monitor_funcs.create("Gears", "Generating gear...") if dyna_monitor: dyna_monitor.init(dyna_monitor.data, self._teeth) edit_op_result = lwsdk.EDERR_NONE ptID = [] cancelled = False # catch exceptions to make sure Modeler ends up on a sane state try: tooth = 0 for tooth in range(self._teeth): a1 = t_ang * tooth a2 = a1 + (t_ang * 3 / 6) a3 = a1 + (t_ang * 4 / 6) a4 = a1 + (t_ang * 5 / 6) pt = [(self._rad_inner * math.sin(a1) + cx), (self._rad_inner * math.cos(a1) + cy), cz] ptID.append(mesh_edit_op.addPoint(mesh_edit_op.state, pt)) pt = [(self._rad_inner * math.sin(a2) + cx), (self._rad_inner * math.cos(a2) + cy), cz] ptID.append(mesh_edit_op.addPoint(mesh_edit_op.state, pt)) pt = [(self._rad_outer * math.sin(a3) + cx), (self._rad_outer * math.cos(a3) + cy), cz] ptID.append(mesh_edit_op.addPoint(mesh_edit_op.state, pt)) pt = [(self._rad_outer * math.sin(a4) + cx), (self._rad_outer * math.cos(a4) + cy), cz] ptID.append(mesh_edit_op.addPoint(mesh_edit_op.state, pt)) if dyna_monitor: result = dyna_monitor.step(dyna_monitor.data, 1) if result: cancelled = True break if cancelled: edit_op_result = lwsdk.EDERR_USERABORT else: if self._geartype == gears.ANGULAR: mesh_edit_op.addPoly(mesh_edit_op.state, lwsdk.LWPOLTYPE_FACE, None, "Gear", ptID) else: # Smooth ptID.append(ptID[0]) # close the loop mesh_edit_op.addCurve(mesh_edit_op.state, None, ptID, 0) except: edit_op_result = lwsdk.EDERR_USERABORT raise finally: mesh_edit_op.done(mesh_edit_op.state, edit_op_result, 0) if dyna_monitor: dyna_monitor.done(dyna_monitor.data) monitor_funcs.destroy(dyna_monitor) if cancelled: return lwsdk.AFUNC_OK if self._geartype == gears.SMOOTH: result = mod_command.execute(mod_command.data, cs_dict["FREEZECURVES"], None, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues(('Z', self._thickness)) result = mod_command.execute(mod_command.data, cs_dict["EXTRUDE"], cs_options, lwsdk.OPSEL_USER) # make hole with a diameter 25% of the gear's radius cs_options = lwsdk.marshall_dynavalues(empty_layer) result = mod_command.execute(mod_command.data, cs_dict["SETLAYER"], cs_options, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues(( [ self._rad_outer * 0.25, # radius self._rad_outer * 0.25, self._rad_outer * 0.25 ], -0.5, # top self._thickness + 1, # bottom 'Z', # axis 32, # number of sides 1, # number of segments [cx, cy, cz] # center )) result = mod_command.execute(mod_command.data, cs_dict["MAKEDISC"], cs_options, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues(fg_layers_list[0]) result = mod_command.execute(mod_command.data, cs_dict["SETLAYER"], cs_options, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues(empty_layer) result = mod_command.execute(mod_command.data, cs_dict["SETBLAYER"], cs_options, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues('SUBTRACT') result = mod_command.execute(mod_command.data, cs_dict["BOOLEAN"], cs_options, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues(empty_layer) result = mod_command.execute(mod_command.data, cs_dict["SETLAYER"], cs_options, lwsdk.OPSEL_USER) result = mod_command.execute(mod_command.data, cs_dict["DELETE"], None, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues(fg_layers_list[0]) result = mod_command.execute(mod_command.data, cs_dict["SETLAYER"], cs_options, lwsdk.OPSEL_USER) result = mod_command.execute(mod_command.data, cs_dict["MERGEPOINTS"], None, lwsdk.OPSEL_USER) result = mod_command.execute(mod_command.data, cs_dict["ALIGNPOLS"], None, lwsdk.OPSEL_USER) if self._geartype == gears.SMOOTH: result = mod_command.execute(mod_command.data, cs_dict["FLIP"], None, lwsdk.OPSEL_USER) if self._axis != gears.Z: angle = 90.0 if self._axis == gears.X: cs_options = lwsdk.marshall_dynavalues((angle, 'Y')) elif self._axis == gears.Y: cs_options = lwsdk.marshall_dynavalues((angle, 'X')) result = mod_command.execute(mod_command.data, cs_dict["ROTATE"], cs_options, lwsdk.OPSEL_USER) cs_options = lwsdk.marshall_dynavalues(fg_layers) result = mod_command.execute(mod_command.data, cs_dict["SETLAYER"], cs_options, lwsdk.OPSEL_USER) return lwsdk.AFUNC_OK