def init_widgets(self):
self.object_widgets = dict()
for key in WidgetManager.get_list():
self.object_widgets[key] = WidgetManager.create(key, self)
self.object_widgets[key].hide()
self.objectPropertiesLayout.addWidget(self.object_widgets[key])
if self.object_widgets[key].animated:
self.app_manager.updated_animation_frame.connect(self.object_widgets[key].updateAnimationTimeInGUI)
if key in self.widget_buttons:
for (name, func, layout_name) in self.widget_buttons[key]:
new_button = QToolButton(self.object_widgets[key])
new_button.setObjectName(name)
action = QAction(name, self.object_widgets[key])
action.triggered.connect(partial(func,self.object_widgets[key]))
new_button.setDefaultAction(action)
setattr(self.object_widgets[key], name, new_button)
if layout_name is not None:
layout = getattr(self.object_widgets[key], layout_name)
layout.addWidget(new_button)
self.forceXLineEdit.text(),
self.forceYLineEdit.text(),
self.forceZLineEdit.text()
]))
self._character.apply_force(body_name, force)
def apply_torque(self):
body_name = str(self.bodyComboBox.currentText())
torque = list(
map(float, [
self.torqueXLineEdit.text(),
self.torqueYLineEdit.text(),
self.torqueZLineEdit.text()
]))
self._character.apply_torque(body_name, torque)
def set_angular_velocity(self):
joint_name = str(self.jointComboBox.currentText())
print(joint_name)
velocity = list(
map(float, [
self.angularVelocityXLineEdit.text(),
self.angularVelocityYLineEdit.text(),
self.angularVelocityZLineEdit.text()
]))
self._character.set_angular_velocity(self.joint_key_map[joint_name],
velocity)
WidgetManager.register("character", CharacterWidget)
"position"] = transform_func(p["position"])
constraint = c
constraints_dict["elementaryActions"][idx]["constraints"][
c_idx] = constraint
return constraints_dict
def update_action_sequence_list(self):
self.actionListWidget.clear()
if self._action_sequence is None:
return
for action in self._action_sequence:
item = QListWidgetItem()
item.setText(action[0])
item.setData(Qt.UserRole, action[1])
self.actionListWidget.addItem(item)
def save_graph_walk_to_file(self):
filename = QFileDialog.getSaveFileName(self, 'Save To File', '.')[0]
self._controller.export_graph_walk_to_file(filename)
def load_graph_walk_from_file(self):
filename = str(QFileDialog.getOpenFileName(self, 'Load From File',
'.'))[0]
self._controller.load_graph_walk_from_file(filename)
def clear_graph_walk(self):
self._controller.clear_graph_walk()
WidgetManager.register("mg_player", MorphableGraphControllerWidget)
self.setAnimationSliderValue(value)
self.setAnimationFrameSpinBoxValue(value)
def setAnimationSliderValue(self, value):
self.animationFrameSlider.setValue(value)
def setAnimationFrameSpinBoxValue(self, value):
self.animationFrameSpinBox.setValue(value)
def draw_mode_selection_changed(self, idx):
for anim_controller in self._controller.get_animation_controllers():
anim_controller._visualization.draw_mode = int(idx)
class GroupAnimationPlayerWidget(GroupAnimationPlayerBaseWidget, Ui_Form):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
Ui_Form.setupUi(self, self)
self.animationSpeedDoubleSpinBox.setRange(-4.0, 4.0)
self.deactivate_player_controls()
self.init_animation_player_actions()
self.initSignals()
self.initSlots()
self.isPlaying = False
self._controller = None
self.init_combo_box()
WidgetManager.register("group_player", GroupAnimationPlayerWidget, True)
def update_n_neighbors(self, value):
n_neighbors = int(value)
self._controller.set_n_neighbors(n_neighbors)
def init_combo_box(self):
self.drawModeComboBox.clear()
self.drawModeComboBox.addItem("None", 0)
self.drawModeComboBox.addItem("Lines", 1)
self.drawModeComboBox.addItem("Boxes", 2)
self.drawModeComboBox.addItem("CoordinateSystem", 3)
self.drawModeComboBox.setCurrentIndex(1)
self.drawModeComboBox.currentIndexChanged.connect(
self.draw_mode_selection_changed)
def draw_mode_selection_changed(self, idx):
self._controller._visualization.draw_mode = int(idx)
def save_to_file(self):
filename = str(QFileDialog.getSaveFileName(self, 'Save To File',
'.'))[0]
self._controller.save_to_file(filename)
def export_to_bvh_file(self):
filename = str(QFileDialog.getSaveFileName(self, 'Save To File',
'.'))[0]
self._controller.export_to_bvh_file(filename)
WidgetManager.register("blend_controller", BlendAnimationControllerWidget,
True)
self.mg_controller.direction_vector = dir_vector
def set_animation_speed(self):
speed = float(self.animSpeedLineEdit.text())
self.mg_controller.speed = speed
def set_blend_window(self):
blend_window = int(self.blendWindowLineEdit.text())
self.mg_controller.planner.settings.blend_window = blend_window
def set_ik(self, state):
self.mg_controller.planner.settings.activate_ik = bool(state)
def set_grounding(self, state):
self.mg_controller.activate_grounding = bool(state)
def set_transition_constraint(self, state):
self.mg_controller.planner.settings.add_transition_constraint = bool(
state)
def set_position_weight(self):
self.mg_controller.planner.settings.position_constraint_weight = float(
self.posWeightLineEdit.text())
def set_direction_weight(self):
self.mg_controller.planner.settings.direction_constraint_weight = float(
self.dirWeightLineEdit.text())
WidgetManager.register("morphablegraph_state_machine", MGStateMachineWidget)
self._figure_controller.scene_object._components[
"character"].visible = new_visible
def on_av_scale_changed(self):
self._figure_controller.av_scale = float(self.avScaleLineEdit.text())
def on_click_visible_com(self):
new_visible = self.visibleCOMCheckBox.isChecked()
self._figure_controller.visualize_com = new_visible
def on_click_kinematic_root(self):
self._figure_controller.activate_kinematic_root = self.kinematicRootCheckBox.isChecked(
)
if not self._figure_controller.activate_kinematic_root:
root_body = self._figure_controller.target_figure.root_body
self._figure_controller.target_figure.bodies[
root_body].set_dynamic()
def on_click_external_force(self):
self._figure_controller.activate_external_force = self.externalForceCheckBox.isChecked(
)
if not self._figure_controller.activate_external_force:
self._figure_controller.reset_motor_targets()
def on_click_balance(self):
self._figure_controller.activate_balance = self.balanceCheckBox.isChecked(
)
WidgetManager.register("figure_controller", FigureControllerWidget)
def _init_signals(self):
self.applyScaleButton.setDefaultAction(self.applyScaleAction)
def _init_slots(self):
return
def _apply_scale(self):
if self._animated_mesh is not None:
scale = float(self.scaleLineEdit.text())
self._animated_mesh.scale_mesh(scale)
def on_click_visible(self):
new_visible = self.visibleCheckBox.isChecked()
self._animated_mesh.visible = new_visible
def render_mode_selection_changed(self, idx):
if self._animated_mesh is not None:
self._animated_mesh.render_mode = idx
def init_render_mode_combo_box(self):
self.renderModeComboBox.clear()
self.renderModeComboBox.addItem("None", 0)
self.renderModeComboBox.addItem("Standard", 1)
self.renderModeComboBox.addItem("Normal Map", 2)
self.renderModeComboBox.setCurrentIndex(1)
self.renderModeComboBox.currentIndexChanged.connect(
self.render_mode_selection_changed)
WidgetManager.register("animated_mesh", AnimatedMeshWidget)
def fill_joints_combobox(self):
self.jointComboBox.clear()
joints = self._controller.skeleton.get_joint_names()
for idx, joint in enumerate(joints):
self.jointComboBox.addItem(joint, idx)
def create_blend_controller(self):
self._controller.create_blend_controller()
def create_motion_copy(self):
scene_object = self._controller.scene_object
if len(self._controller.samples) < 1:
return
sample = self._controller.samples[0]
copy_dialog = CopyMotionDialog(sample.n_frames, scene_object.name,
self)
copy_dialog.exec_()
if copy_dialog.success:
scene = scene_object.scene
skeleton_copy = self._controller.get_skeleton_copy()
start_frame = copy_dialog.start_frame
end_frame = copy_dialog.end_frame
mv_copy = self._controller.get_motion_vector_copy(
start_frame, end_frame)
scene.object_builder.create_object("animation_controller",
copy_dialog.name, skeleton_copy,
mv_copy, mv_copy.frame_time)
WidgetManager.register("mp_player", MotionPrimitiveControllerWidget, True)
def _init_actions(self):
self.updateAction = QAction("Update", self)
self.updateAction.triggered.connect(self._set_object_values)
self.posXLineEdit.returnPressed.connect(self._set_object_values)
self.posYLineEdit.returnPressed.connect(self._set_object_values)
self.posZLineEdit.returnPressed.connect(self._set_object_values)
self.scaleLineEdit.returnPressed.connect(self._set_object_values)
def _init_signals(self):
self.updateButton.setDefaultAction(self.updateAction)
def _init_slots(self):
return
#self.connect(self.animationFrameSlider, QtCore.SIGNAL("valueChanged(Qstri) "), self.valueChanged)
def _set_object_values(self):
if self._scene_object is not None:
position = list(
map(float, [
self.posXLineEdit.text(),
self.posYLineEdit.text(),
self.posZLineEdit.text()
]))
self._scene_object.setPosition(np.array(position))
self._scene_object.name = str(self.nameLineEdit.text())
scale = float(self.scaleLineEdit.text())
self._scene_object.set_scale(scale)
WidgetManager.register("object", ObjectPropertiesWidget)
data["name"] = name
data["skeleton"] = skeleton.to_unity_format()
data["model"] = skeleton_editor.skeleton_model
save_local_skeleton(self.local_skeleton_dir, name, data)
constants.LOCAL_SKELETON_MODELS[name] = data
self.fill_combo_box_with_models()
class AnimationPlayerWidget(AnimationPlayerBaseWidget, Ui_Form):
COMPONENT_NAME = "animation_controller"
def __init__(self, parent):
QWidget.__init__(self, parent)
Ui_Form.setupUi(self, self)
self.local_skeleton_dir = constants.DATA_DIR + os.sep + "skeletons"
self.animationSpeedDoubleSpinBox.setRange(-4.0, 4.0)
self.deactivate_player_controls()
self.init_animation_player_actions()
self.initSignals()
self.initSlots()
self.isPlaying = False
self._controller = None
self.fpsLineEdit.textChanged.connect(self.slot_fps_text_changed)
self.init_combo_box()
self.prev_annotation_edit_frame_idx = 0
self.labelView.setTimeLineParameters(100000, 10)
self.labelView.initScene()
self.labelView.show()
WidgetManager.register("animation_player", AnimationPlayerWidget, True)
def deactivate_player_controls(self):
self.animationFrameSlider.setEnabled(False)
self.animationFrameSpinBox.setEnabled(False)
self.animationButton.setEnabled(False)
def updateAnimationTimeInGUI(self, value):
self.setAnimationSliderValue(value)
self.setAnimationFrameSpinBoxValue(value)
def setAnimationSliderValue(self, value):
self.animationFrameSlider.setValue(value)
def setAnimationFrameSpinBoxValue(self, value):
self.animationFrameSpinBox.setValue(value)
def draw_mode_selection_changed(self, draw_mode):
self._controller.set_draw_mode(draw_mode)
def on_select_file(self, item):
name = str(item.text())
n_frames = self._controller.select_file(name)
if n_frames is not None:
self.setFrameRange(0, n_frames - 1)
def load_selected(self):
n_frames = self._controller.load_selected()
WidgetManager.register("animation_directory_explorer",
AnimationDirectoryWidget, True)
if set_constraint_dialog.success:
constraint_object = self.nav_agent.scene_object.scene.getObject(set_constraint_dialog.selected_node_id)
self.nav_agent.set_walk_target(constraint_object)
def remove_walk_target(self):
self.nav_agent.remove_walk_target()
def perform_action(self):
position = None
keyframe_label = None
action_name = str(self.actionComboBox.currentText())
if self.keyframeComboBox.count() > 0:
set_constraint_dialog = SelectSceneObjectsDialog(self.nav_agent.scene_object.scene, get_constraints)
set_constraint_dialog.exec_()
if set_constraint_dialog.success:
constraint_object = self.nav_agent.scene_object.scene.getObject(set_constraint_dialog.selected_node_id)
keyframe_label = str(self.keyframeComboBox.currentText())
position = constraint_object.getPosition()
self.nav_agent.perform_action(action_name, keyframe_label, position)
def update_keyframe_combobox(self, label):
self.fill_keyframe_combobox(str(label))
def set_tolerance(self):
self.nav_agent.tolerance = float(self.toleranceLineEdit.text())
WidgetManager.register("nav_agent", NavAgentWidget)