def __init__(self, win, win_scale, user_id, icons=None):
"""
Class for settings menu. At the moment it only lets you change the win_scale and reloads the pygame window when
this is done.
:param win: Window Scale (How large the window is - must be multiplied by all size related variables).
:param win_scale: Window Scale (How large the window is - must be multiplied by all size related variables).
:param user_id: UserID if the user has signed in (they don't have to be signed in to play Classic).
:param icons: List of icon objects from the StartScreen.
"""
# Essential
super().__init__(win, win_scale, user_id, icons)
self.sub_program_name = 'settings'
# Settings Title
self.settings_title = gui.Word('Settings!', (178, 90), (255, 255, 30),
60,
win_scale,
centre=True)
# Sliders
self.music_slider = (gui.Slider(
'Music ',
168,
200,
200,
25,
20, (255, 255, 30),
3,
win_scale,
level=int(local_settings.get_setting('music_volume')),
centre=True))
self.game_slider = (gui.Slider(
'Game Sound ',
168,
240,
200,
25,
20, (255, 255, 30),
3,
win_scale,
level=int(local_settings.get_setting('game_volume')),
centre=True))
self.win_scale_slider = (gui.Slider(
'Win Scale ',
168,
280,
200,
25,
20, (255, 255, 30),
3,
win_scale,
level=int(local_settings.get_setting('win_scale')),
centre=True,
levels=5))
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Mouse')
row = [0]
def add(widget, name, method):
widget.addWidget(gui.TextView(name), row[0], 0)
widget.addWidget(AppMouseActionEdit(method), row[0], 1)
row[0] += 1
speedBox = self.addLeftWidget(gui.SliderBox('3D Viewport Speed'))
self.normal = speedBox.addWidget(gui.Slider(gui3d.app.settings.get('lowspeed', 1), 1, 10,
["Normal speed",": %d"]))
self.mouseBox = self.addLeftWidget(gui.GroupBox('Camera'))
add(self.mouseBox, "Move", gui3d.app.mouseTranslate)
add(self.mouseBox, "Rotate", gui3d.app.mouseRotate)
add(self.mouseBox, "Zoom", gui3d.app.mouseZoom)
self.invertMouseWheel = self.mouseBox.addWidget(gui.CheckBox("Invert wheel", gui3d.app.settings.get('invertMouseWheel', False)))
@self.invertMouseWheel.mhEvent
def onClicked(event):
gui3d.app.settings['invertMouseWheel'] = self.invertMouseWheel.selected
@self.normal.mhEvent
def onChange(value):
gui3d.app.settings['lowspeed'] = value
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Random')
self.human = G.app.selectedHuman
toolbox = self.addLeftWidget(gui.SliderBox('Randomize settings'))
self.macro = toolbox.addWidget(gui.CheckBox("Macro", True))
self.face = toolbox.addWidget(gui.CheckBox("Face", True))
self.body = toolbox.addWidget(gui.CheckBox("Body", True))
self.height = toolbox.addWidget(gui.CheckBox("Height", False))
self.symmetry = toolbox.addWidget(
gui.Slider(value=0.7, min=0.0, max=1.0, label="Symmetry"))
#self.amount = toolbox.addWidget(gui.Slider(value=0.5, label="Amount"))
#self.create = toolbox.addWidget(gui.Button("Replace current"))
#self.modify = toolbox.addWidget(gui.Button("Adjust current"))
self.randomBtn = toolbox.addWidget(gui.Button("Randomize"))
@self.randomBtn.mhEvent
def onClicked(event):
randomize(self.human,
self.symmetry.getValue(),
macro=self.macro.selected,
height=self.height.selected,
face=self.face.selected,
body=self.body.selected)
def __init__(self, state_data):
super().__init__(state_data)
self.buttons = dict()
self.buttons["BACK"] = gui.Button(y=430,
text="Back",
callback=(lambda: self.end_state()))
self.slider = gui.Slider(initial_value=pygame.mixer.music.get_volume())
def __init__(self, category):
guirender.RenderTaskView.__init__(self, category, 'Aqsis')
self.sceneToRender = None
optionsBox = self.addLeftWidget(gui.SliderBox('Options'))
#Sliders
self.shadingRateSlider = optionsBox.addWidget(
gui.Slider(value=2, min=0.1, max=10, label="ShadingRate: %.2f"))
self.samplesSlider = optionsBox.addWidget(
gui.Slider(value=2, min=1.0, max=10, label="Samples: %.2f"))
self.skinOilSlider = optionsBox.addWidget(
gui.Slider(value=0.3, min=0.0, max=10, label="Skin Oil: %.2f"))
#Buttons
self.renderButton = optionsBox.addWidget(gui.Button('Render'))
@self.shadingRateSlider.mhEvent
def onChanging(value):
gui3d.app.settings[
'rendering_aqsis_shadingrate'] = value #Using global dictionary in app for global settings
@self.samplesSlider.mhEvent
def onChanging(value):
gui3d.app.settings['rendering_aqsis_samples'] = value
@self.skinOilSlider.mhEvent
def onChanging(value):
gui3d.app.settings['rendering_aqsis_oil'] = value
@self.renderButton.mhEvent
def onClicked(event):
if not which("aqsis"):
gui3d.app.prompt('Aqsis not found',
'You don\'t seem to have aqsis installed.',
'Download', 'Cancel', self.downloadAqsis)
return
if not self.sceneToRender:
self.sceneToRender = mh2renderman.RMRScene(gui3d.app)
self.buildShaders()
self.sceneToRender.render()
def createSlider(self,
value=0.0,
min=0.0,
max=1.0,
label=None,
vertical=False,
valueConverter=None,
image=None,
scale=1000):
return gui.Slider(value, min, max, label, vertical, valueConverter,
image, scale)
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Proportional editing', label='Edit')
self.radius = 1.0
self.start = None
self.center = None
self.axis = None
self.depth = None
self.original = None
self.normals = None
self.weights = None
self.verts = None
self.faces = None
self.smoothed = None
self.converter = ValueConverter()
value = self.converter.displayToData(self.radius)
self.radiusSlider = self.addLeftWidget(gui.Slider(value, min=-5.0, max=3.0, label="Radius",
valueConverter=self.converter))
self.clear = self.addLeftWidget(gui.Button("Clear"))
self.modeBox = self.addLeftWidget(gui.GroupBox("Mode"))
modes = []
self.grab = self.modeBox.addWidget(gui.RadioButton(modes, "Grab", selected=True))
self.norm = self.modeBox.addWidget(gui.RadioButton(modes, "Normal"))
self.scalex = self.modeBox.addWidget(gui.RadioButton(modes, "Scale X"))
self.scaley = self.modeBox.addWidget(gui.RadioButton(modes, "Scale Y"))
self.scalez = self.modeBox.addWidget(gui.RadioButton(modes, "Scale Z"))
self.rotate = self.modeBox.addWidget(gui.RadioButton(modes, "Rotate"))
self.smooth = self.modeBox.addWidget(gui.RadioButton(modes, "Smooth"))
self.buildCircle()
self.updateRadius()
self.circle = self.addObject(gui3d.Object(self.circleMesh))
@self.clear.mhEvent
def onClicked(dummy):
human = gui3d.app.selectedHuman
targets = []
for name in human.targetsDetailStack.keys():
if isinstance(algos3d.getTarget(human, name), EditTarget):
targets.append(name)
gui3d.app.do(EditAction(human, targets, 0.0))
@self.radiusSlider.mhEvent
def onChanging(value):
self.radius = self.converter.dataToDisplay(value)
self.updateRadius()
@self.radiusSlider.mhEvent
def onChange(value):
self.radius = self.converter.dataToDisplay(value)
self.updateRadius()
def createPlaybackControl(self):
self.playbackBox = self.addRightWidget(gui.GroupBox('Playback'))
self.frameSlider = self.playbackBox.addWidget(
gui.Slider(value=0, min=0, max=1, label='Frame: %d'))
# TODO make slider use time instead of frames?
@self.frameSlider.mhEvent
def onChanging(value):
self.updateAnimation(value)
@self.frameSlider.mhEvent
def onChange(value):
self.updateAnimation(value)
self.playPauseBtn = self.playbackBox.addWidget(gui.Button("Play"))
@self.playPauseBtn.mhEvent
def onClicked(value):
if self.playPauseBtn.text() == 'Play':
self.startPlayback()
else:
self.stopPlayback()
self.animateInPlaceTggl = self.playbackBox.addWidget(
gui.CheckBox("In-place animation"))
@self.animateInPlaceTggl.mhEvent
def onClicked(event):
self.human.animated.setAnimateInPlace(
self.animateInPlaceTggl.selected)
self.updateAnimation(self.currFrame)
self.animateInPlaceTggl.setSelected(True)
self.restPoseBtn = self.playbackBox.addWidget(
gui.Button("Set to Rest Pose"))
@self.restPoseBtn.mhEvent
def onClicked(value):
self.setToRestPose()
self.interpolateTggl = self.playbackBox.addWidget(
gui.CheckBox("Interpolate animation"))
@self.interpolateTggl.mhEvent
def onClicked(event):
self.interpolate = self.interpolateTggl.selected
self.interpolateTggl.setSelected(True)
def createPlaybackControl(self):
if self.anim:
maxFrames = self.anim.nFrames
if maxFrames < 1:
maxFrames = 1
else:
maxFrames = 1
if self.playbackBox:
self.frameSlider.setMin(0)
self.frameSlider.setMax(maxFrames)
self.currFrame = 0
self.frameSlider.setValue(0)
return
self.playbackBox = self.addRightWidget(gui.GroupBox('BVH playback'))
self.frameSlider = self.playbackBox.addWidget(gui.Slider(value = 0, min = 0, max = maxFrames, label = 'Frame: %d', vertical=False, valueConverter=None, image=None, scale=100000))
@self.frameSlider.mhEvent
def onChanging(value):
self.updateAnimation(value)
@self.frameSlider.mhEvent
def onChange(value):
self.updateAnimation(value)
self.playPause = self.playbackBox.addWidget(gui.Button("Play"))
@self.playPause.mhEvent
def onClicked(value):
if self.playPause.text() == 'Play':
self.startPlayback()
else:
self.stopPlayback()
self.animateInPlaceTggl = self.playbackBox.addWidget(gui.ToggleButton("In-place animation"))
@self.animateInPlaceTggl.mhEvent
def onClicked(event):
if not self.animated:
return
if self.animated:
self.animated.setAnimateInPlace(self.animateInPlaceTggl.selected)
if self.bvhAnimated:
self.bvhAnimated.setAnimateInPlace(self.animateInPlaceTggl.selected)
self.updateAnimation(self.currFrame)
self.animateInPlaceTggl.setSelected(True)
self.restPoseBtn = self.playbackBox.addWidget(gui.Button("Set to Rest Pose"))
@self.restPoseBtn.mhEvent
def onClicked(value):
self.setToRestPose()
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Animations')
self.human = gui3d.app.selectedHuman
self.playbackSlider = self.addLeftWidget(gui.Slider(label='Frame'))
self.playbackSlider.setMin(0)
self.frameLbl = self.addLeftWidget(gui.TextView(''))
self.frameLbl.setTextFormat(u"Frame: %s", 0)
@self.playbackSlider.mhEvent
def onChange(value):
self.updateFrame(int(value))
@self.playbackSlider.mhEvent
def onChanging(value):
self.updateFrame(int(value))
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'vsScript')
box = self.addLeftWidget(gui.GroupBox('vsScript'))
self.category = category
# We add a button to the current task
# A button just fires an event when it is clicked, if a selected texture is specified,
# it is used while the mouse is down on the button
self.vsWeight_gui = 1.0
self.modelName_gui = "T1_large_s_mkh"
self.userDocPath_gui = r"C:\Users\Bekki\Documents"
self.mkhPath_gui = r"c:\Program Files\makehuman-community"
self.aTextEdit = box.addWidget(gui.TextEdit(text='add model name'))
self.aButton = box.addWidget(gui.Button('Load MKH Model'))
self.bButton = box.addWidget(gui.Button('Export STL Model'))
self.pushed = 0
self.aButtonLabel = box.addWidget(gui.TextView('Pushed 0 times'))
#self.loadRunScript()
@self.aButton.mhEvent
def onClicked(event):
#loadProxy(gui3d.app, 0.88,"T3_s_mkh",r"C:\Users\Bekki\Documents", r"c:\Program Files\makehuman-community")
loadProxy(gui3d.app, self.vsWeight_gui, self.modelName_gui,
self.userDocPath_gui, self.mkhPath_gui)
@self.bButton.mhEvent
def onClicked(event):
exportProxy(gui3d.app, self.modelName_gui)
# We want the slider to start from the middle
self.aSlider = box.addWidget(
gui.Slider(value=0.5, label=['Change Weight', ' %.2f']))
self.aSliderLabel = box.addWidget(gui.TextView('Value is 0.5'))
@self.aSlider.mhEvent
def onChange(value):
self.aSliderLabel.setTextFormat('Weight value is %f', value)
self.aProgressBar.setProgress(value)
# we also create a progressbar, which is updated as the slider moves
self.aProgressBar = box.addWidget(gui.ProgressBar())
self.aProgressBar.setProgress(0.5)
def makeProps(self):
SceneItem.makeProps(self)
self.colbox = self.widget.addWidget(
VectorInput("Ambience", self.sceneview.scene.environment.ambience,
True))
self.colboxSlider = self.widget.addWidget(
gui.Slider(value=1,
min=0,
max=1,
label=['Light X position', ' %.2f']))
@self.colbox.mhEvent
def onChange(value):
self.sceneview.scene.environment.ambience = value
@self.colboxSlider.mhEvent
def onChanging(value):
self.sceneview.scene.environment.ambience = (value, value, value)
self.colbox.setValue(self.sceneview.scene.environment.ambience)
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Random Custom')
self.human = G.app.selectedHuman
toolbox = self.addLeftWidget(gui.SliderBox('Randomize settings'))
self.macro = toolbox.addWidget(gui.CheckBox("Macro", False))
self.face = toolbox.addWidget(gui.CheckBox("Face", True))
self.body = toolbox.addWidget(gui.CheckBox("Body", True))
self.height = toolbox.addWidget(gui.CheckBox("Height", False))
self.symmetry = toolbox.addWidget(gui.Slider(value=0.2, min=0.0, max=1.0, label="Symmetry"))
#self.amount = toolbox.addWidget(gui.Slider(value=0.5, label="Amount"))
#self.create = toolbox.addWidget(gui.Button("Replace current"))
#self.modify = toolbox.addWidget(gui.Button("Adjust current"))
self.eyes_cheek_mouth_sigma = toolbox.addWidget(gui.Slider(value=0.2, min=0.0, max=1.0, label="Eyes cheek mouth Sigma"))
self.head_sigma = toolbox.addWidget(gui.Slider(value=0.15, min=0.0, max=1.0, label="Head Sigma"))
self.ears_eyebrows_sigma = toolbox.addWidget(gui.Slider(value=0.2, min=0.0, max=1.0, label="Ears eyebrows Sigma"))
self.nose_sigma = toolbox.addWidget(gui.Slider(value=0.1, min=0.0, max=1.0, label="Nose Sigma"))
self.forehead_neck_chin_sigma = toolbox.addWidget(gui.Slider(value=0.05, min=0.0, max=1.0, label="Forehead neck chin Sigma"))
self.randomBtn = toolbox.addWidget(gui.Button("Randomize"))
restorebox = self.addLeftWidget(gui.GroupBox('Restore settings'))
self.restoreBtn = restorebox.addWidget(gui.Button('Restore to defaults'))
@self.restoreBtn.mhEvent
def onClicked(event):
self.macro.setChecked(False)
self.face.setChecked(True)
self.body.setChecked(True)
self.height.setChecked(False)
self.symmetry.setValue(value=0.2)
@self.randomBtn.mhEvent
def onClicked(event):
randomize(self.human,
self.symmetry.getValue(),
macro=self.macro.selected,
height=self.height.selected,
face=self.face.selected,
body=self.body.selected,
sigmas=[self.eyes_cheek_mouth_sigma.getValue(),
self.head_sigma.getValue(),
self.ears_eyebrows_sigma.getValue(),
self.nose_sigma.getValue(),
self.forehead_neck_chin_sigma.getValue()])
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Background')
self.human = gui3d.app.selectedHuman
self.backgroundsFolder = mh.getPath('backgrounds')
if not os.path.exists(self.backgroundsFolder):
os.makedirs(self.backgroundsFolder)
self.backgroundsFolders = [ mh.getSysDataPath('backgrounds'),
self.backgroundsFolder ]
self.extensions = ['bmp', 'png', 'tif', 'tiff', 'jpg', 'jpeg']
self.texture = mh.Texture()
self.sides = { 'front': [0,0,0],
'back': [0,180,0],
'left': [0,-90,0],
'right': [0,90,0],
'top': [90,0,0],
'bottom': [-90,0,0],
'other': None }
self.filenames = {} # Stores (filename, aspect)
self.transformations = {} # Stores ((posX,posY), scaleY)
for side in self.sides.keys():
self.filenames[side] = None
self.transformations[side] = [(0.0, 0.0), 1.0]
self.planeMeshes = dict()
self.opacity = 40
for viewName, rot in self.sides.items():
if rot is not None:
rv = [0, 0, 0]
angle = 0.0
for r_idx, r in enumerate(rot):
if r != 0:
rv[r_idx] = 1
angle = math.radians(r)
if angle == 0:
m = None
else:
m = tm.rotation_matrix(-angle, rv)
else:
m = None
mesh = geometry3d.RectangleMesh(20, 20, centered=True, rotation=m)
mesh.name = "Background_%s" % viewName
obj = gui3d.app.addObject(gui3d.Object(mesh, [0, 0, 0], visible=False))
obj.setShadeless(True)
obj.setDepthless(True)
#obj.placeAtFeet = True
mesh.setCameraProjection(0)
mesh.setColor([255, 255, 255, self.opacity*2.55])
mesh.setPickable(False)
mesh.priority = -90
self.planeMeshes[viewName] = obj
if viewName == 'other':
obj.lockRotation = True
@obj.mhEvent
def onMouseDragged(event):
if event.button in [mh.Buttons.LEFT_MASK, mh.Buttons.MIDDLE_MASK]:
if mh.getKeyModifiers() & (mh.Modifiers.SHIFT):
delta = 150.0
else:
delta = 30.0
dx = float(event.dx)/delta
dy = float(-event.dy)/delta
self.moveBackground(dx, dy)
elif event.button == mh.Buttons.RIGHT_MASK:
if mh.getKeyModifiers() & (mh.Modifiers.SHIFT):
delta = 500.0
else:
delta = 100.0
scale = self.getBackgroundScale()
scale += float(event.dy)/delta
self.setBackgroundScale(scale)
# Add icon to action toolbar
self.backgroundImageToggle = gui.Action('background', 'Background', self.toggleBackground, toggle=True)
gui3d.app.view_toolbar.addAction(self.backgroundImageToggle)
gui3d.app.actions.background = self.backgroundImageToggle
#self.filechooser = self.addTopWidget(fc.FileChooser(self.backgroundsFolders, self.extensions, None))
#self.addLeftWidget(self.filechooser.sortBox)
self.filechooser = self.addRightWidget(fc.IconListFileChooser(self.backgroundsFolders, self.extensions, None, None, 'Background', noneItem=True))
self.filechooser.setIconSize(50,50)
self.filechooser.enableAutoRefresh(False)
#self.addLeftWidget(self.filechooser.createSortBox())
self.backgroundBox = self.addLeftWidget(gui.GroupBox('Side'))
self.bgSettingsBox = self.addLeftWidget(gui.GroupBox('Background settings'))
self.radioButtonGroup = []
for side in ['front', 'back', 'left', 'right', 'top', 'bottom', 'other']:
radioBtn = self.backgroundBox.addWidget(gui.RadioButton(self.radioButtonGroup, label=side.capitalize(), selected=len(self.radioButtonGroup)==0))
radioBtn.side = side
@radioBtn.mhEvent
def onClicked(value):
side = self.sides[self.getSelectedSideCheckbox()]
if side:
gui3d.app.axisView(side)
self.refreshFileChooser()
self.opacitySlider = self.bgSettingsBox.addWidget(gui.Slider(value=self.opacity, min=0,max=100, label = ["Opacity",": %d%%"]))
self.dragButton = self.bgSettingsBox.addWidget(gui.CheckBox('Move && Resize'))
self.foregroundTggl = self.bgSettingsBox.addWidget(gui.CheckBox("Show in foreground"))
@self.opacitySlider.mhEvent
def onChanging(value):
for obj in self.planeMeshes.values():
obj.mesh.setColor([255, 255, 255, 2.55*value])
@self.opacitySlider.mhEvent
def onChange(value):
self.opacity = value
for obj in self.planeMeshes.values():
obj.mesh.setColor([255, 255, 255, 2.55*value])
@self.foregroundTggl.mhEvent
def onClicked(value):
self.setShowBgInFront(self.foregroundTggl.selected)
@self.filechooser.mhEvent
def onFileSelected(filename):
side = self.getSelectedSideCheckbox()
if self.filenames[side]:
oldBg = self.filenames[side][0]
else:
oldBg = None
gui3d.app.do(BackgroundAction("Change background",
self,
side,
oldBg,
filename))
mh.redraw()
@self.dragButton.mhEvent
def onClicked(event):
for obj in self.planeMeshes.values():
obj.mesh.setPickable(self.dragButton.selected)
gui3d.app.selectedHuman.mesh.setPickable(not self.dragButton.selected)
mh.redraw()
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Settings')
self.shaderGroup = []
shaderBox = self.addLeftWidget(gui.GroupBox('Shader'))
self.shaderNo = shaderBox.addWidget(
gui.RadioButton(self.shaderGroup, "No shader", True))
self.shaderPhong = shaderBox.addWidget(
gui.RadioButton(self.shaderGroup, "Phong shader"))
self.shaderToon = shaderBox.addWidget(
gui.RadioButton(self.shaderGroup, "Toon shader"))
#self.shaderSkin = shaderBox.addWidget(gui.RadioButton(self.shaderGroup, "Skin shader"))
sliderBox = self.addLeftWidget(gui.GroupBox('Slider behavior'))
self.realtimeUpdates = sliderBox.addWidget(
gui.CheckBox("Update real-time",
gui3d.app.settings.get('realtimeUpdates', True)))
self.realtimeNormalUpdates = sliderBox.addWidget(
gui.CheckBox("Update normals real-time",
gui3d.app.settings.get('realtimeNormalUpdates',
True)))
self.cameraAutoZoom = sliderBox.addWidget(
gui.CheckBox("Auto-zoom camera",
gui3d.app.settings.get('cameraAutoZoom', True)))
self.sliderImages = sliderBox.addWidget(
gui.CheckBox("Slider images",
gui3d.app.settings.get('sliderImages', True)))
mouseBox = self.addLeftWidget(gui.SliderBox('Mouse behavior'))
self.normal = mouseBox.addWidget(
gui.Slider(gui3d.app.settings.get('lowspeed', 1), 1, 10,
"Normal: %d"))
self.shift = mouseBox.addWidget(
gui.Slider(gui3d.app.settings.get('highspeed', 5), 1, 10,
"Shift: %d"))
modes = []
unitBox = self.unitsBox = self.addLeftWidget(gui.GroupBox('Units'))
metric = unitBox.addWidget(
gui.RadioButton(
modes, 'Metric',
gui3d.app.settings.get('units', 'metric') == 'metric'))
imperial = unitBox.addWidget(
gui.RadioButton(
modes, 'Imperial',
gui3d.app.settings.get('units', 'metric') == 'imperial'))
libraryBox = self.addLeftWidget(gui.GroupBox('Library behavior'))
self.jumpToModelling = libraryBox.addWidget(
gui.CheckBox("To Modelling after choice",
gui3d.app.settings.get('jumpToModelling', True)))
themes = []
themesBox = self.themesBox = self.addRightWidget(gui.GroupBox('Theme'))
self.themeNative = themesBox.addWidget(
ThemeRadioButton(themes, "Native look", "default"))
self.themeMH = themesBox.addWidget(
ThemeRadioButton(themes, "MakeHuman", "makehuman"))
# For debugging themes on multiple platforms
'''
platforms = []
platformsBox = self.platformsBox = self.addRightWidget(gui.GroupBox('Look and feel'))
for platform in gui3d.app.getLookAndFeelStyles():
platformsBox.addWidget(PlatformRadioButton(platforms, platform))
'''
# We might allow overriding the font from the style, but for now loaded fonts can be used from a style
'''
fonts = []
fontsBox = self.fontsBox = self.addRightWidget(gui.GroupBox('Font'))
fontsBox.addWidget(FontRadioButton(fonts, "Default"))
for font in gui3d.app.getCustomFonts():
fontsBox.addWidget(FontRadioButton(fonts, font))
'''
languages = []
languageBox = self.languageBox = self.addRightWidget(
gui.GroupBox('Language'))
languageBox.addWidget(LanguageRadioButton(languages, 'english'))
languageFiles = [
os.path.basename(filename).replace('.ini', '')
for filename in os.listdir('data/languages')
if filename.split(os.extsep)[-1] == "ini"
]
for language in languageFiles:
languageBox.addWidget(LanguageRadioButton(languages, language))
@self.shaderNo.mhEvent
def onClicked(event):
human = gui3d.app.selectedHuman
human.mesh.setShader(None)
@self.shaderPhong.mhEvent
def onClicked(event):
self.setShader("data/shaders/glsl/phong")
@self.shaderToon.mhEvent
def onClicked(event):
self.setShader("data/shaders/glsl/toon")
#@self.shaderSkin.mhEvent
#def onClicked(event):
#self.setShader("data/shaders/glsl/skin")
#gui3d.app.selectedHuman.mesh.setShaderParameter("gradientMap", "data/textures/color_temperature.png")
#gui3d.app.selectedHuman.mesh.setShaderParameter("ambientOcclusionMap", "data/textures/female_young.tif")
@self.realtimeUpdates.mhEvent
def onClicked(event):
gui3d.app.settings[
'realtimeUpdates'] = self.realtimeUpdates.selected
@self.realtimeNormalUpdates.mhEvent
def onClicked(event):
gui3d.app.settings[
'realtimeNormalUpdates'] = self.realtimeNormalUpdates.selected
@self.cameraAutoZoom.mhEvent
def onClicked(event):
gui3d.app.settings['cameraAutoZoom'] = self.cameraAutoZoom.selected
@self.sliderImages.mhEvent
def onClicked(event):
gui3d.app.settings['sliderImages'] = self.sliderImages.selected
gui.Slider.showImages(self.sliderImages.selected)
mh.refreshLayout()
@self.normal.mhEvent
def onChange(value):
gui3d.app.settings['lowspeed'] = value
@self.shift.mhEvent
def onChange(value):
gui3d.app.settings['highspeed'] = value
@metric.mhEvent
def onClicked(event):
gui3d.app.settings['units'] = 'metric'
@imperial.mhEvent
def onClicked(event):
gui3d.app.settings['units'] = 'imperial'
@self.jumpToModelling.mhEvent
def onClicked(event):
gui3d.app.settings[
'jumpToModelling'] = self.jumpToModelling.selected
def main(self):
verticalContainer = gui.Widget(640, 680, False, 10)
horizontalContainer = gui.Widget(620, 620, True, 10)
subContainerLeft = gui.Widget(340, 530, False, 10)
self.img = gui.Image(100, 100, './res/logo.png')
self.table = gui.Table(300, 200)
row = gui.TableRow()
item = gui.TableTitle()
item.append(str(id(item)), 'ID')
row.append(str(id(item)), item)
item = gui.TableTitle()
item.append(str(id(item)), 'First Name')
row.append(str(id(item)), item)
item = gui.TableTitle()
item.append(str(id(item)), 'Last Name')
row.append(str(id(item)), item)
self.table.append(str(id(row)), row)
self.add_table_row(self.table, '101', 'Danny', 'Young')
self.add_table_row(self.table, '102', 'Christine', 'Holand')
self.add_table_row(self.table, '103', 'Lars', 'Gordon')
self.add_table_row(self.table, '104', 'Roberto', 'Robitaille')
self.add_table_row(self.table, '105', 'Maria', 'Papadopoulos')
# the arguments are width - height - layoutOrientationOrizontal
subContainerRight = gui.Widget(240, 560, False, 10)
self.lbl = gui.Label(200, 30, 'This is a LABEL!')
self.bt = gui.Button(200, 30, 'Press me!')
# setting the listener for the onclick event of the button
self.bt.set_on_click_listener(self, 'on_button_pressed')
self.txt = gui.TextInput(200, 30)
self.txt.set_text('This is a TEXTAREA')
self.txt.set_on_change_listener(self, 'on_text_area_change')
self.spin = gui.SpinBox(200, 30)
self.spin.set_on_change_listener(self, 'on_spin_change')
self.btInputDiag = gui.Button(200, 30, 'Open InputDialog')
self.btInputDiag.set_on_click_listener(self, 'open_input_dialog')
self.btFileDiag = gui.Button(200, 30, 'File Selection Dialog')
self.btFileDiag.set_on_click_listener(self,
'open_fileselection_dialog')
self.btUploadFile = gui.FileUploader(200, 30, './')
self.btUploadFile.set_on_success_listener(self,
'fileupload_on_success')
self.btUploadFile.set_on_failed_listener(self, 'fileupload_on_failed')
self.listView = gui.ListView(300, 120)
self.listView.set_on_selection_listener(self, "list_view_on_selected")
li0 = gui.ListItem(279, 20, 'Danny Young')
li1 = gui.ListItem(279, 20, 'Christine Holand')
li2 = gui.ListItem(279, 20, 'Lars Gordon')
li3 = gui.ListItem(279, 20, 'Roberto Robitaille')
self.listView.append('0', li0)
self.listView.append('1', li1)
self.listView.append('2', li2)
self.listView.append('3', li3)
self.dropDown = gui.DropDown(200, 20)
c0 = gui.DropDownItem(200, 20, 'DropDownItem 0')
c1 = gui.DropDownItem(200, 20, 'DropDownItem 1')
self.dropDown.append('0', c0)
self.dropDown.append('1', c1)
self.dropDown.set_on_change_listener(self, 'drop_down_changed')
self.slider = gui.Slider(200, 20, 10, 0, 100, 5)
self.slider.set_on_change_listener(self, 'slider_changed')
self.colorPicker = gui.ColorPicker(200, 20, '#ffbb00')
self.colorPicker.set_on_change_listener(self, 'color_picker_changed')
self.date = gui.Date(200, 20, '2015-04-13')
self.date.set_on_change_listener(self, 'date_changed')
# appending a widget to another, the first argument is a string key
subContainerRight.append('1', self.lbl)
subContainerRight.append('2', self.bt)
subContainerRight.append('3', self.txt)
subContainerRight.append('4', self.spin)
subContainerRight.append('5', self.btInputDiag)
subContainerRight.append('5_', self.btFileDiag)
subContainerRight.append(
'5__',
gui.FileDownloader(200, 30, 'download test', './res/logo.png'))
subContainerRight.append('5___', self.btUploadFile)
subContainerRight.append('6', self.dropDown)
subContainerRight.append('7', self.slider)
subContainerRight.append('8', self.colorPicker)
subContainerRight.append('9', self.date)
self.subContainerRight = subContainerRight
subContainerLeft.append('0', self.img)
subContainerLeft.append('1', self.table)
subContainerLeft.append('2', self.listView)
horizontalContainer.append('0', subContainerLeft)
horizontalContainer.append('1', subContainerRight)
menu = gui.Menu(620, 40)
m1 = gui.MenuItem(100, 40, 'File')
m2 = gui.MenuItem(100, 40, 'View')
m2.set_on_click_listener(self, 'menu_view_clicked')
m11 = gui.MenuItem(100, 40, 'Save')
m12 = gui.MenuItem(100, 40, 'Open')
m12.set_on_click_listener(self, 'menu_open_clicked')
m111 = gui.MenuItem(100, 40, 'Save')
m111.set_on_click_listener(self, 'menu_save_clicked')
m112 = gui.MenuItem(100, 40, 'Save as')
m112.set_on_click_listener(self, 'menu_saveas_clicked')
menu.append('1', m1)
menu.append('2', m2)
m1.append('11', m11)
m1.append('12', m12)
m11.append('111', m111)
m11.append('112', m112)
verticalContainer.append('0', menu)
verticalContainer.append('1', horizontalContainer)
# returning the root widget
return verticalContainer
def __init__(self, category):
# Setup GUI elements
gui3d.TaskView.__init__(self, category, 'Actions')
box = self.addLeftWidget(gui.GroupBox('Export'))
self.rigButton = box.addWidget(FileSelectView('Load BVH'))
self.rigButton.setDirectory(DATA_PATH)
self.rigButton.setFilter('Biovision Motion Hierarchy (*.bvh)')
self.exportButton = box.addWidget(gui.Button('Export animation'))
self.exportAllButton = box.addWidget(gui.Button('Export all'))
self.window = None
@self.rigButton.mhEvent
def onFilesSelected(filenames):
if not self.skel:
self.loadRig()
loadFirst = (self.animationList.rowCount() == 0)
for filename in filenames:
if filename not in self.selectedBVHs:
item = self.animationList.addItem(os.path.splitext(os.path.basename(filename))[0])
item.filename = filename
self.selectedBVHs.add(filename)
if loadFirst:
self.loadAnimation(filenames[0])
@self.exportButton.mhEvent
def onClicked(event):
self.export()
@self.exportAllButton.mhEvent
def onClicked(event):
self.exportAll()
self.human = gui3d.app.selectedHuman
self.humanChanged = False
self.humanTransparent = False
self.selectedBVHs = set()
self.skel = None
self.animated = None
self.bvhAnimated = None
self.skelMesh = None
self.skelObj = None
self.bvhMesh = None
self.bvhObj = None
self.timer = None
self.currFrame = 0
self.anim = None
self.bvhAnim = None
self.oldHumanTransp = self.human.meshData.transparentPrimitives
optionsBox = self.addLeftWidget(gui.GroupBox('Options'))
self.kinectCamTggle = optionsBox.addWidget(gui.ToggleButton("Kinect camera"))
self.kinectCamTggle.setSelected(True)
self.useMHCamTggl = optionsBox.addWidget(gui.ToggleButton("Use camera pos"))
self.useMHCamTggl.setSelected(False)
mesh = BackPlane(20, 20, centered=True)
self.bgPlane = self.addObject(gui3d.Object([0, 0, 0], mesh))
mesh.setColor([255, 255, 255, 255])
mesh.setShadeless(True)
mesh.priority = -90
mesh = GroundPlane(20, 20, centered=True)
self.groundPlane = self.addObject(gui3d.Object([0, 0, 0], mesh))
mesh.setColor([0, 0, 0, 255])
mesh.setShadeless(True)
mesh.priority = -90
yOffset = self.getFeetOnGroundOffset()
self.groundposSlider = optionsBox.addWidget(gui.Slider(value=int(yOffset), min=-125,max=125, label = "Ground Pos: %d"))
self.groundposVal = int(yOffset)
self.groundPlane.mesh.move(0,yOffset,0)
@self.groundposSlider.mhEvent
def onChanging(value):
val = value - self.groundposVal
self.groundPlane.mesh.move(0,val,0)
self.groundposVal = self.groundposVal + val
@self.groundposSlider.mhEvent
def onChange(value):
val = value - self.groundposVal
self.groundPlane.mesh.move(0,val,0)
self.groundposVal = self.groundposVal + val
self.backposSlider = optionsBox.addWidget(gui.Slider(value=-9, min=-125,max=125, label = "Back Pos: %d"))
self.backposVal = -9
@self.backposSlider.mhEvent
def onChanging(value):
val = value - self.backposVal
self.bgPlane.mesh.move(0,0,val)
self.backposVal = self.backposVal + val
@self.backposSlider.mhEvent
def onChange(value):
val = value - self.backposVal
self.bgPlane.mesh.move(0,0,val)
self.backposVal = self.backposVal + val
self.bgPlane.mesh.move(0,0,self.backposVal)
displayBox = self.addRightWidget(gui.GroupBox('Display'))
self.showHumanTggl = displayBox.addWidget(gui.ToggleButton("Show human"))
@self.showHumanTggl.mhEvent
def onClicked(event):
if self.showHumanTggl.selected:
self.human.show()
else:
self.human.hide()
self.showHumanTggl.setSelected(True)
self.showMHXRigTggl = displayBox.addWidget(gui.ToggleButton("Show human Rig"))
@self.showMHXRigTggl.mhEvent
def onClicked(event):
self.setShowRig(self.showMHXRigTggl.selected)
self.showMHXRigTggl.setSelected(True)
self.showBVHRigTggl = displayBox.addWidget(gui.ToggleButton("Show BVH Rig"))
@self.showBVHRigTggl.mhEvent
def onClicked(event):
self.setShowBVHRig(self.showBVHRigTggl.selected)
self.showBVHRigTggl.setSelected(False)
self.imageExported = False
self.playbackBox = None
self.playPause = None
self.createPlaybackControl()
animationListBox = self.addRightWidget(gui.GroupBox('BVHs'))
self.animationList = animationListBox.addWidget(gui.ListView())
self.animationList.setSizePolicy(QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.MinimumExpanding)
self.animationList.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
@self.animationList.mhEvent
def onClicked(item):
self.loadAnimation(item.filename)
self.removeAnimBtn = animationListBox.addWidget(gui.Button('Remove selected'))
@self.removeAnimBtn.mhEvent
def onClicked(item):
print "remove clicked"
if len(self.animationList.selectedItems()) > 0:
print "taking action"
item = self.animationList.selectedItems()[0]
self.removeAnimation(item.filename)
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Example')
box = self.addLeftWidget(gui.GroupBox('Example'))
# We add a button to the current task
# A button just fires an event when it is clicked, if a selected texture is specified,
# it is used while the mouse is down on the button
self.aButton = box.addWidget(gui.Button('Button'))
self.pushed = 0
self.aButtonLabel = box.addWidget(gui.TextView('Pushed 0 times'))
@self.aButton.mhEvent
def onClicked(event):
self.pushed += 1
self.aButtonLabel.setTextFormat('Pushed %d times', self.pushed)
# We add a toggle button to the current task
# A toggle button fires an event when it is clicked but retains its selected state after the mouse is up,
# if a selected texture is specified, it is used to show whether the button is toggled
self.aToggleButton = box.addWidget(gui.CheckBox('ToggleButton'))
self.aToggleButtonLabel = box.addWidget(gui.TextView('Not selected'))
@self.aToggleButton.mhEvent
def onClicked(event):
if self.aToggleButton.selected:
self.aToggleButtonLabel.setText('Selected')
else:
self.aToggleButtonLabel.setText('Not selected')
# Next we will add some radio buttons. For this we need a group, since only one in the group can be selected
# A radio button fires an event when it is clicked but retains its selected state after the mouse is up, and deselects all other buttons in the group
# If a selected texture is specified, it is used to show whether the button is selected
self.aRadioButtonGroup = []
# We make the first one selected
self.aRadioButton1 = box.addWidget(gui.RadioButton(self.aRadioButtonGroup, 'RadioButton1', selected=True))
self.aRadioButton2 = box.addWidget(gui.RadioButton(self.aRadioButtonGroup, 'RadioButton2'))
self.aRadioButtonLabel = box.addWidget(gui.TextView('Button 1 is selected'))
@self.aRadioButton1.mhEvent
def onClicked(event):
self.aRadioButtonLabel.setText('Button 1 is selected')
@self.aRadioButton2.mhEvent
def onClicked(event):
self.aRadioButtonLabel.setText('Button 2 is selected')
# When the slider is dragged and released, an onChange event is fired
# By default a slider goes from 0.0 to 1.0, and the initial position will be 0.0 unless specified
# We want the slider to start from the middle
self.aSlider = box.addWidget(gui.Slider(value=0.5, label=['Slider',' %.2f']))
self.aSliderLabel = box.addWidget(gui.TextView('Value is 0.5'))
@self.aSlider.mhEvent
def onChange(value):
self.aSliderLabel.setTextFormat('Value is %f', value)
self.aProgressBar.setProgress(value)
# we also create a progressbar, which is updated as the slider moves
self.aProgressBar = box.addWidget(gui.ProgressBar())
self.aProgressBar.setProgress(0.5)
# A text edit
self.aTextEdit = box.addWidget(gui.TextEdit(text='Some text'))
self.meshSlider = box.addWidget(gui.Slider(value=0.5, label=['Mesh distort',' %0.2f']))
self.isMeshStored = False
@self.meshSlider.mhEvent
def onChanging(value):
human = gui3d.app.selectedHuman
if self.isMeshStored:
self.restoreMesh(human)
else:
self.storeMesh(human)
self.isMeshStored = True
human.mesh.coord += human.mesh.vnorm * value
human.mesh.markCoords(coor=True)
human.mesh.update()
@self.meshSlider.mhEvent
def onChange(value):
human = gui3d.app.selectedHuman
human.applyAllTargets()
self.isMeshStored = False
human.mesh.coord += human.mesh.vnorm * value
human.mesh.markCoords(coor=True)
human.mesh.update()
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Povray')
# for path to PovRay binaries file
binary = ''
bintype = []
pathBox = self.addLeftWidget(gui.GroupBox('Povray bin path'))
# this part load old settings values for next session; str(povray_bin)
povray_bin = gui3d.app.settings.get('povray_bin', '')
self.path = pathBox.addWidget(gui.TextEdit(str(povray_bin)), 0, 0, 1,
2)
self.browse = pathBox.addWidget(gui.BrowseButton('dir'), 1, 0, 1, 1)
self.browse.setPath(povray_bin)
if sys.platform == 'win32':
self.browse.setFilter(
'Executable programs (*.exe);;All files (*.*)')
#
if os.name == 'nt':
#
if os.environ['PROCESSOR_ARCHITECTURE'] == 'x86':
self.win32sse2Button = pathBox.addWidget(
gui.CheckBox('Use SSE2 bin', True))
#
@self.path.mhEvent
def onChange(value):
gui3d.app.settings[
'povray_bin'] = 'Enter your path' if not value else str(value)
@self.browse.mhEvent
def onClicked(path):
if os.path.isdir(path):
gui3d.app.settings['povray_bin'] = path
self.path.setText(path)
#------------------------------------------------------------------------------------
filter = []
# Options box
optionsBox = self.addLeftWidget(gui.GroupBox('Options'))
self.doSubdivide = optionsBox.addWidget(
gui.CheckBox('Subdivide mesh', True))
self.usebump = optionsBox.addWidget(gui.CheckBox(
'Use bump maps', True))
self.useSSS = optionsBox.addWidget(
gui.CheckBox('Use S.S. Scattering', True))
self.SSSA = optionsBox.addWidget(
gui.Slider(value=0.5, label="SSS Amount"))
settingsBox = self.addLeftWidget(gui.GroupBox('Settings'))
settingsBox.addWidget(gui.TextView("Resolution"))
self.resBox = settingsBox.addWidget(
gui.TextEdit("x".join([str(self.resWidth),
str(self.resHeight)])))
self.AA = settingsBox.addWidget(
gui.Slider(value=0.5, label="AntiAliasing"))
materialsBox = self.addRightWidget(gui.GroupBox('Materials'))
self.skinoil = materialsBox.addWidget(
gui.Slider(value=0.5, label="Skin oil"))
self.moist = materialsBox.addWidget(
gui.Slider(value=0.7, label="Moisturization"))
self.tension = materialsBox.addWidget(
gui.Slider(value=0.7, label="Skin tension"))
self.grain = materialsBox.addWidget(
gui.Slider(value=0.5, label="Skin graininess"))
self.hairShine = materialsBox.addWidget(
gui.CheckBox('Hair shine', False))
self.hairSpec = materialsBox.addWidget(
gui.Slider(value=0.45, label="Shine strength"))
self.hairRough = materialsBox.addWidget(
gui.Slider(value=0.4, label="Shine coverage"))
self.hairHard = materialsBox.addWidget(
gui.Slider(value=0.5, label="Hair hardness"))
# box
#optionsBox = self.addLeftWidget(gui.GroupBox('Options'))
#Buttons
# Simplified the gui a bit for the average user. Uncomment to clutter it up with developer - useful stuff.
#source=[]
#self.iniButton = optionsBox.addWidget(gui.RadioButton(source, 'Use ini settings'))
#self.guiButton = optionsBox.addWidget(gui.RadioButton(source, 'Use gui settings', selected = True))
#format=[]
#self.arrayButton = optionsBox.addWidget(gui.RadioButton(format, 'Array format'))
#self.mesh2Button = optionsBox.addWidget(gui.RadioButton(format, 'Mesh2 format', selected = True))
#action=[]
#self.exportButton = optionsBox.addWidget(gui.RadioButton(action , 'Export only', selected = True))
#self.exportandrenderButton = optionsBox.addWidget(gui.RadioButton(action , 'Export and render'))
self.renderButton = optionsBox.addWidget(gui.Button('Render'))
@self.resBox.mhEvent
def onChange(value):
try:
value = value.replace(" ", "")
res = [int(x) for x in value.split("x")]
self.resWidth = res[0]
self.resHeight = res[1]
except: # The user hasn't typed the value correctly yet.
pass
#
@self.renderButton.mhEvent
def onClicked(event):
reload(
mh2povray
) # Avoid having to close and reopen MH for every coding change (can be removed once testing is complete)
# it is necessary to put this code here, so that it is executed with the 'renderButton.event'
if os.name == 'nt':
#
if os.environ['PROCESSOR_ARCHITECTURE'] == "x86":
binary = 'win32'
if self.win32sse2Button.selected:
binary = 'win32sse2'
else:
binary = 'win64'
# for Ubuntu.. atm
if sys.platform == 'linux2':
binary = 'linux'
#
mh2povray.povrayExport({
'source':
'gui', # 'ini' if self.iniButton.selected else 'gui',
'format':
'mesh2', # 'array' if self.arrayButton.selected else 'mesh2',
'action':
'render', # 'export' if self.exportButton.selected else 'render',
'scene':
gui3d.app.getCategory('Rendering').getTaskByName(
'Scene').scene,
'subdivide':
True if self.doSubdivide.selected else False,
'AA':
0.5 - 0.49 * self.AA.getValue(),
'bintype':
binary,
'SSS':
True if self.useSSS.selected else False,
'SSSA':
self.SSSA.getValue() + 0.01, # blur strength. Prevent zero
'skinoil':
0.001 *
(10**(4 * self.skinoil.getValue())), # exponential slider
'moist':
self.moist.getValue(), # percentage
'rough':
0.001 *
(10**(2 *
(1 - self.tension.getValue()))), # exponential slider
'wrinkles':
0.5 * self.grain.getValue(),
'usebump':
True if self.usebump.selected else False,
'hairShine':
True if self.hairShine.selected else False,
'hairSpec':
self.hairSpec.getValue(),
'hairRough': (0.7 * self.hairRough.getValue())**2,
'hairHard':
0.01 * 10**(4 * self.hairHard.getValue())
}) # exponential slider
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Pose tuning')
self.zone = ""
self.rigtype = None
self.armature = None
self.armatureObject = None
self.objects = []
self.activeBone = None
self.poseModifier = None
cubeLayer = CLayerObject("Cube", 'CUBE')
cubeLayer.buildCube((-8, 8, 0), 1.0)
cubeLayer.finishBuild((0, 0, 0))
self.cube = cubeLayer.object
self.cube.hide()
# Main box
self.mainBox = self.addLeftWidget(gui.GroupBox('Rotation'))
self.eulerBox = self.addLeftWidget(gui.GroupBox('Euler'))
self.quatBox = self.addLeftWidget(gui.GroupBox('Quaternion'))
self.QWslider = self.quatBox.addWidget(
gui.Slider(value=1000.0, min=-1000.0, max=1000.0, label="W: %d"))
self.QXslider = self.quatBox.addWidget(
gui.Slider(value=0.0, min=-1000.0, max=1000.0, label="X: %d"))
self.QYslider = self.quatBox.addWidget(
gui.Slider(value=0.0, min=-1000.0, max=1000.0, label="Y: %d"))
self.QZslider = self.quatBox.addWidget(
gui.Slider(value=0.0, min=-1000.0, max=1000.0, label="Z: %d"))
self.EXslider = self.eulerBox.addWidget(
gui.Slider(value=0.0, min=-180, max=180, label="X: %d"))
self.EYslider = self.eulerBox.addWidget(
gui.Slider(value=0.0, min=-180, max=180, label="Y: %d"))
self.EZslider = self.eulerBox.addWidget(
gui.Slider(value=0.0, min=-180, max=180, label="Z: %d"))
self.rotSlider = self.mainBox.addWidget(
gui.Slider(value=0.0, min=-180, max=180, label="Rotation: %d"))
self.rotWorld = self.mainBox.addWidget(
gui.CheckBox("World Rotation", False))
rots = []
self.rotX = self.mainBox.addWidget(gui.RadioButton(rots, "X", True))
self.rotY = self.mainBox.addWidget(gui.RadioButton(rots, "Y", False))
self.rotZ = self.mainBox.addWidget(gui.RadioButton(rots, "Z", False))
self.showMesh = self.mainBox.addWidget(gui.CheckBox("Show Mesh", True))
self.showRig = self.mainBox.addWidget(gui.CheckBox("Show Rig", False))
self.restPosition = self.mainBox.addWidget(
gui.CheckBox("Rest Position", False))
#self.updateButton = self.mainBox.addWidget(gui.Button("Update"))
self.reloadCharacterButton = self.mainBox.addWidget(
gui.Button("Reload Character"))
self.zeroBoneButton = self.mainBox.addWidget(gui.Button("Zero Bone"))
self.zeroAllButton = self.mainBox.addWidget(gui.Button("Zero All"))
self.poseButton = self.mainBox.addWidget(gui.Button("Pose"))
self.testButton = self.mainBox.addWidget(gui.Button("Test bones"))
# self.mainBox.hide()
# self.quatBox.hide()
# self.eulerBox.hide()
# Rig select box
self.rigBox = self.addLeftWidget(gui.GroupBox('Rig'))
prisms = []
self.prismButtons = {}
first = True
for type in ['Prism', 'Box', 'Line']:
self.prismButtons[type] = self.rigBox.addWidget(
gui.RadioButton(prisms, type, first))
first = False
self.selectRigButton = self.rigBox.addWidget(gui.Button("SelectRig"))
rigs = []
self.rigButtons = {}
self.rigButtons["mhx"] = self.rigBox.addWidget(
gui.RadioButton(rigs, "Mhx", False))
path = "data/rigs"
if not os.path.exists(path):
log.notice("Did not find directory %s", path)
else:
buttons = []
for name in ["game", "simple", "rigid"]:
#for fname in os.listdir(path):
# (name, ext) = os.path.splitext(fname)
# if ext == ".rig":
self.rigButtons[name] = self.rigBox.addWidget(
gui.RadioButton(rigs, name.capitalize(), False))
self.rigBox.show()
# Bone select box
self.boneBox = self.addRightWidget(gui.GroupBox('Bone'))
self.boneButtons = {}
self.boneBox.hide()
# Pose select box
self.poseBox = self.addRightWidget(gui.GroupBox('Pose'))
self.poseButtons = {}
self.poseBox.hide()
# Layer select box
self.layerBox = self.addRightWidget(gui.GroupBox('Layers'))
self.layerButtons = {}
self.layerBox.hide()
@self.selectRigButton.mhEvent
def onClicked(event):
for name, button in self.prismButtons.items():
if button.selected:
prismType = name
for name, button in self.rigButtons.items():
if button.selected:
rigtype = name
if rigtype:
self.selectRig(prismType, rigtype)
@self.testButton.mhEvent
def onClicked(event):
listBones = doTest1(self.armature.bones)
self.updateAll()
doTest2(listBones)
@self.poseButton.mhEvent
def onClicked(event):
if not self.poseButtons:
radio = []
self.poseButtons = {}
path = os.path.join(mh.getPath(''), "data", "poses")
if not os.path.exists(path):
os.makedirs(path)
for file in os.listdir(path):
(pose, ext) = os.path.splitext(file)
if ext.lower() == ".bvh":
button = PoseRadioButton(radio, pose, False, self)
self.poseButtons[pose] = self.poseBox.addWidget(button)
self.poseBox.show()
@self.showMesh.mhEvent
def onClicked(event):
self.updateAll()
@self.showMesh.mhEvent
def onClicked(event):
self.updateAll()
@self.showRig.mhEvent
def onClicked(event):
self.updateAll()
@self.restPosition.mhEvent
def onClicked(event):
self.updateAll()
@self.zeroBoneButton.mhEvent
def onClicked(event):
bone = self.getSelectedBone()
bone.zeroTransformation()
self.zeroSliders()
self.updateAll()
@self.zeroAllButton.mhEvent
def onClicked(event):
self.zeroSliders()
for bone in self.armature.controls:
bone.zeroTransformation()
self.updateAll()
@self.reloadCharacterButton.mhEvent
def onClicked(event):
self.zeroSliders()
human = gui3d.app.selectedHuman
amt = self.getArmature()
self.armatureObject = None
if amt:
#amt.hide()
gui3d.app.removeObject(amt)
if self.armature:
self.armature.rebuild()
else:
self.armature = amtpkg.rigdefs.createPoseRig(
human, self.armature.rigtype)
self.updateAll()
@self.rotSlider.mhEvent
def onChange(value):
bone = self.getSelectedBone()
if self.rotX.selected:
axis = 0
elif self.rotY.selected:
axis = 1
elif self.rotZ.selected:
axis = 2
bone.rotate(value, axis, self.rotWorld.selected)
self.updateSliders(bone)
@self.QXslider.mhEvent
def onChange(value):
bone = self.getSelectedBone()
bone.setRotationIndex(1, value, True)
self.updateSliders(bone)
@self.QYslider.mhEvent
def onChange(value):
bone = self.getSelectedBone()
bone.setRotationIndex(2, value, True)
self.updateSliders(bone)
@self.QZslider.mhEvent
def onChange(value):
bone = self.getSelectedBone()
bone.setRotationIndex(3, value, True)
self.updateSliders(bone)
@self.EXslider.mhEvent
def onChange(value):
bone = self.getSelectedBone()
bone.setRotationIndex(1, value, False)
self.updateSliders(bone)
@self.EYslider.mhEvent
def onChange(value):
bone = self.getSelectedBone()
bone.setRotationIndex(2, value, False)
self.updateSliders(bone)
@self.EZslider.mhEvent
def onChange(value):
bone = self.getSelectedBone()
bone.setRotationIndex(3, value, False)
self.updateSliders(bone)
@self.cube.mhEvent
def onMouseEntered(event):
gui3d.TaskView.onMouseEntered(self, event)
mh.redraw()
@self.cube.mhEvent
def onMouseDragged(event):
gui3d.app.selectedHuman.show()
self.getArmature().hide()
gui3d.TaskView.onMouseDragged(self, event)
if not self.showMesh.selected:
gui3d.app.selectedHuman.hide()
if self.showRig.selected:
self.getArmature().show()
@self.cube.mhEvent
def onMouseWheel(event):
gui3d.app.selectedHuman.show()
self.getArmature().hide()
gui3d.TaskView.onMouseWheel(self, event)
if not self.showMesh.selected:
gui3d.app.selectedHuman.hide()
if self.showRig.selected:
self.getArmature().show()
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Face Reconstruction')
toolbox = self.addLeftWidget(gui.SliderBox('Face Reconstruction'))
self.Dir = toolbox.addWidget(gui.BrowseButton(mode='dir'), 0, 0)
self.Dir.setLabel('Face Reference Directory')
self.Dir.directory = '.' #mh.getPath('scripts')
self.fast = toolbox.addWidget(gui.CheckBox("Fast Method", False))
self.semifast = toolbox.addWidget(gui.CheckBox("Normal Method", False))
self.slow = toolbox.addWidget(gui.CheckBox("Slow Method", False))
self.rslow = toolbox.addWidget(gui.CheckBox("Really Slow Method", False))
self.brute = toolbox.addWidget(gui.CheckBox("Bruteforce Method", False))
self.random = toolbox.addWidget(gui.CheckBox("Random Method (best)", True))
self.epoch = toolbox.addWidget(gui.Slider(5, 4, 20,
["Epoch rounds (only for random method)", ": %d"]))
self.iter = toolbox.addWidget(gui.Slider(3, 1, 50,
["Iterations Per Modifier (only for random method)", ": %d"]))
self.faceBtn = toolbox.addWidget(gui.Button("Do Face Reconstruction"))
self.cam = G.app.modelCamera
self.human = gui3d.app.selectedHuman
self.fcount = 0
cv2.namedWindow("Face Preview")
@self.faceBtn.mhEvent
def onClicked(event):
if self.Dir.directory == '.':
log.error("Not a valid reference folder. Aborting...")
return
avg = self.createavg()
if avg is None:
log.error("Not a valid reference folder. Aborting...")
return
log.notice(self.createavg())
modifierGroups = ['eyebrows', 'eyes', 'chin',
'forehead', 'head', 'mouth', 'nose', 'neck', 'ears',
'cheek']
modifiers = []
for mGroup in modifierGroups:
modifiers = modifiers + self.human.getModifiersByGroup(mGroup)
# Make sure not all modifiers are always set in the same order
# (makes it easy to vary dependent modifiers like ethnics)
random.shuffle(modifiers)
with open("Output.txt", "w", buffering=1) as text_file:
if self.fast.selected:
self.checkFace([0.2, 0.2], text_file, avg, modifiers)
self.checkFace([-0.4, 0.4], text_file, avg, modifiers)
if self.semifast.selected:
self.checkFace([-0.4, -0.2, 0.2, 0.4], text_file, avg, modifiers)
self.checkFace([-0.8, -0.6, 0.6, 0.8], text_file, avg, modifiers)
if self.slow.selected:
self.checkFace([-0.2, -0.1, 0.1, 0.2], text_file, avg, modifiers)
self.checkFace([-0.4, -0.3, 0.3, 0.4], text_file, avg, modifiers)
self.checkFace([-0.6, -0.5, 0.5, 0.6], text_file, avg, modifiers)
self.checkFace([-0.8, -0.7, 0.7, 0.8], text_file, avg, modifiers)
if self.rslow.selected:
self.checkFace([-0.2, -0.1, 0.1, 0.2], text_file, avg, modifiers)
self.checkFace([-0.4, -0.3, -0.2, -0.1, 0.1, 0.2, 0.3, 0.4], text_file, avg, modifiers)
self.checkFace([-0.6, -0.5,-0.4, -0.3, -0.2, -0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6], text_file, avg, modifiers)
self.checkFace([-0.8, -0.7,-0.6, -0.5,-0.4, -0.3, -0.2, -0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8], text_file, avg, modifiers)
if self.brute.selected:
self.checkFace([-0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8],text_file, avg, modifiers)
if self.random.selected:
ip = 0.2
for j in range(int(self.epoch.getValue())):
self.checkFace(None,text_file, avg, modifiers,imin=-ip,imax=ip,c=int(self.iter.getValue()),irandom=True)
ip = min(ip + 0.2, 1.0)
mh.redraw()
def __init__(self, category, backgroundChooserView):
self.backgroundImage = backgroundChooserView.backgroundImage
self.texture = backgroundChooserView.texture
self.backgroundChooserView = backgroundChooserView
gui3d.TaskView.__init__(self, category, 'Projection')
self.projectionBox = self.addLeftWidget(gui.GroupBox('Projection'))
self.backgroundBox = self.addLeftWidget(
gui.GroupBox('Background settings'))
# sliders
self.opacitySlider = self.backgroundBox.addWidget(
gui.Slider(value=backgroundChooserView.opacity,
min=0,
max=255,
label="Opacity: %d"))
self.foregroundTggl = self.backgroundBox.addWidget(
gui.ToggleButton("Show in foreground"))
@self.opacitySlider.mhEvent
def onChanging(value):
self.backgroundImage.mesh.setColor([255, 255, 255, value])
@self.opacitySlider.mhEvent
def onChange(value):
backgroundChooserView.opacity = value
self.backgroundImage.mesh.setColor([255, 255, 255, value])
@self.foregroundTggl.mhEvent
def onClicked(value):
self.backgroundChooserView.setShowBgInFront(
self.foregroundTggl.selected)
@self.backgroundImage.mhEvent
def onMouseDragged(event):
if event.button in [mh.Buttons.LEFT_MASK, mh.Buttons.MIDDLE_MASK]:
dx = float(event.dx) / 30.0
dy = float(-event.dy) / 30.0
self.backgroundChooserView.moveBackground(dx, dy)
elif event.button == mh.Buttons.RIGHT_MASK:
scale = self.backgroundChooserView.getBackgroundScale()
scale += float(event.dy) / 100.0
self.backgroundChooserView.setBackgroundScale(scale)
self.dragButton = self.backgroundBox.addWidget(
gui.ToggleButton('Move && Resize'))
@self.dragButton.mhEvent
def onClicked(event):
self.backgroundImage.mesh.setPickable(self.dragButton.selected)
gui3d.app.selectedHuman.mesh.setPickable(
not self.dragButton.selected)
mh.updatePickingBuffer()
self.chooseBGButton = self.backgroundBox.addWidget(
gui.Button('Choose background'))
@self.chooseBGButton.mhEvent
def onClicked(event):
mh.changeTask('Textures', 'Background')
self.projectBackgroundButton = self.projectionBox.addWidget(
gui.Button('Project background'))
@self.projectBackgroundButton.mhEvent
def onClicked(event):
self.projectBackground()
self.projectLightingButton = self.projectionBox.addWidget(
gui.Button('Project lighting'))
@self.projectLightingButton.mhEvent
def onClicked(event):
self.projectLighting()
self.projectUVButton = self.projectionBox.addWidget(
gui.Button('Project UV topology'))
@self.projectUVButton.mhEvent
def onClicked(event):
self.projectUV()
displayBox = self.addRightWidget(gui.GroupBox('Display settings'))
self.shadelessButton = displayBox.addWidget(
gui.ToggleButton('Shadeless'))
@self.shadelessButton.mhEvent
def onClicked(event):
gui3d.app.selectedHuman.mesh.setShadeless(
1 if self.shadelessButton.selected else 0)
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Background')
self.backgroundsFolder = os.path.join(mh.getPath(''), 'backgrounds')
if not os.path.exists(self.backgroundsFolder):
os.makedirs(self.backgroundsFolder)
self.backgroundsFolders = [
os.path.join('data', 'backgrounds'), self.backgroundsFolder
]
self.extensions = ['bmp', 'png', 'tif', 'tiff', 'jpg', 'jpeg', 'clear']
self.texture = mh.Texture()
self.sides = {
'front': [0, 0, 0],
'back': [0, 180, 0],
'left': [0, 90, 0],
'right': [0, -90, 0],
'top': [90, 0, 0],
'bottom': [-90, 0, 0],
'other': None
}
self.filenames = {} # Stores (filename, aspect)
self.transformations = {} # Stores ((posX,posY), scaleY)
for side in self.sides.keys():
self.filenames[side] = None
self.transformations[side] = [(0.0, 0.0), 1.0]
mesh = geometry3d.RectangleMesh(20, 20, centered=True)
self.backgroundImage = gui3d.app.addObject(
gui3d.Object([0, 0, 1], mesh, visible=False))
self.backgroundImage.mesh.setCameraProjection(0) # Set to model camera
self.opacity = 100
mesh.setColor([255, 255, 255, self.opacity])
mesh.setPickable(False)
mesh.setShadeless(True)
mesh.setDepthless(True)
mesh.priority = -90
self.backgroundImageToggle = gui.Action('background',
'Background',
self.toggleBackground,
toggle=True)
gui3d.app.main_toolbar.addAction(self.backgroundImageToggle)
gui3d.app.actions.background = self.backgroundImageToggle
#self.filechooser = self.addTopWidget(fc.FileChooser(self.backgroundsFolders, self.extensions, None))
#self.addLeftWidget(self.filechooser.sortBox)
self.filechooser = self.addRightWidget(
fc.IconListFileChooser(self.backgroundsFolders, self.extensions,
None, None, 'Background'))
self.filechooser.setIconSize(50, 50)
self.addLeftWidget(self.filechooser.createSortBox())
self.backgroundBox = self.addLeftWidget(gui.GroupBox('Side'))
self.bgSettingsBox = self.addLeftWidget(
gui.GroupBox('Background settings'))
self.radioButtonGroup = []
for side in [
'front', 'back', 'left', 'right', 'top', 'bottom', 'other'
]:
radioBtn = self.backgroundBox.addWidget(
gui.RadioButton(self.radioButtonGroup,
label=side.capitalize(),
selected=len(self.radioButtonGroup) == 0))
radioBtn.side = side
self.opacitySlider = self.bgSettingsBox.addWidget(
gui.Slider(value=self.opacity, min=0, max=255,
label="Opacity: %d"))
self.foregroundTggl = self.bgSettingsBox.addWidget(
gui.ToggleButton("Show in foreground"))
@self.opacitySlider.mhEvent
def onChanging(value):
self.backgroundImage.mesh.setColor([255, 255, 255, value])
@self.opacitySlider.mhEvent
def onChange(value):
self.opacity = value
self.backgroundImage.mesh.setColor([255, 255, 255, value])
@self.foregroundTggl.mhEvent
def onClicked(value):
self.setShowBgInFront(self.foregroundTggl.selected)
@self.filechooser.mhEvent
def onFileSelected(filename):
side = self.getSelectedSideCheckbox()
if os.path.splitext(filename)[1] == ".clear":
filename = None
if self.filenames[side]:
oldBg = self.filenames[side][0]
else:
oldBg = None
gui3d.app.do(
BackgroundAction("Change background", self, side, oldBg,
filename))
if self.sides[side]:
gui3d.app.selectedHuman.setRotation(self.sides[side])
mh.redraw()
FPS = 60
BG_COLOR = pygame.Color('black')
pygame.init()
screen = pygame.display.set_mode(WINDOW_SIZE)
screen.fill(BG_COLOR)
# init groups
buttons = pygame.sprite.Group()
bodies = body.System()
# init bodies
data.read_data(bodies)
# init gui
slider = gui.Slider(buttons)
start_stop = gui.StartStop(buttons)
clock = pygame.time.Clock()
running = True
while running:
for event in pygame.event.get():
buttons.update(event)
if event.type == pygame.QUIT:
running = False
data.write_data()
screen.fill(BG_COLOR)
# determining how fast is the system drawn based on the position of the slider.
dt = slider.calc_value()
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Perspective')
self.human = gui3d.app.selectedHuman
self.humanPos = [0.0, 0.0, 0.0]
self.currentframe = 0
self.framesloaded = 0
animbox = self.addLeftWidget(gui.GroupBox('Frames'))
self.avFramesText = animbox.addWidget(
gui.TextView('Available frames: 0'))
self.playbackSlider = animbox.addWidget(
gui.Slider(label=['Current frame', ': %d']))
self.playbackSlider.setMin(0)
@self.playbackSlider.mhEvent
def onChange(value):
self.currentframe = int(value)
self.updateFrame()
self.nextframeButton = animbox.addWidget(gui.Button('Next frame'))
@self.nextframeButton.mhEvent
def onClicked(event):
anim = self.human.getActiveAnimation()
if anim:
if self.currentframe >= anim.nFrames - 1:
self.currentframe = 0
else:
self.currentframe += 1
self.updateFrame()
self.playbackSlider.setValue(self.currentframe)
self.prevframeButton = animbox.addWidget(gui.Button('Previous frame'))
@self.prevframeButton.mhEvent
def onClicked(event):
anim = self.human.getActiveAnimation()
if anim:
if self.currentframe <= 0:
self.currentframe = anim.nFrames - 1
else:
self.currentframe -= 1
self.updateFrame()
self.playbackSlider.setValue(self.currentframe)
projbox = self.addLeftWidget(gui.GroupBox('Projection'))
self.projRadioButtonGroup = []
self.persButton = projbox.addWidget(
gui.RadioButton(self.projRadioButtonGroup,
'Perspective',
selected=G.app.modelCamera.projection))
@self.persButton.mhEvent
def onClicked(event):
G.app.guiCamera.projection = True
G.app.guiCamera.fixedRadius = True
G.app.modelCamera.projection = True
G.app.modelCamera.fixedRadius = True
if G.app.backgroundGradient:
G.app.removeObject(G.app.backgroundGradient)
G.app.backgroundGradient = None
# G.app.modelCamera.updateCamera()
self.orthButton = projbox.addWidget(
gui.RadioButton(self.projRadioButtonGroup,
'Orthogonal',
selected=not G.app.modelCamera.projection))
@self.orthButton.mhEvent
def onClicked(event):
G.app.guiCamera.projection = False
G.app.guiCamera.fixedRadius = False
G.app.modelCamera.projection = False
G.app.modelCamera.fixedRadius = False
G.app.loadBackgroundGradient()
# G.app.modelCamera.updateCamera()
self.fovslider = projbox.addWidget(
gui.Slider(label=['Camera focus', '= %.2f'],
min=25.0,
max=130.0,
value=90.0))
@self.fovslider.mhEvent
def onChange(value):
G.app.modelCamera.setFovAngle(value)
G.app.guiCamera.setFovAngle(value)
#G.app.modelCamera.updateCamera()
G.app.redraw()
posbox = self.addLeftWidget(gui.GroupBox('Position'))
self.xposslider = posbox.addWidget(
gui.Slider(label=['X-position', '= %.2f'],
min=-10.0,
max=10.0,
value=0.0))
@self.xposslider.mhEvent
def onChange(value):
self.humanPos[0] = value
G.app.selectedHuman.setPosition(self.humanPos)
self.updateFrame()
self.yposslider = posbox.addWidget(
gui.Slider(label=['Y-position', '= %.2f'],
min=-10.0,
max=10.0,
value=0.0))
@self.yposslider.mhEvent
def onChange(value):
self.humanPos[1] = value
G.app.selectedHuman.setPosition(self.humanPos)
self.updateFrame()
self.zposslider = posbox.addWidget(
gui.Slider(label=['Z-position', '= %.2f'],
min=-10.0,
max=10.0,
value=0.0))
@self.zposslider.mhEvent
def onChange(value):
self.humanPos[2] = value
G.app.selectedHuman.setPosition(self.humanPos)
self.updateFrame()
self.resetButton = posbox.addWidget(gui.Button('Reset position'))
@self.resetButton.mhEvent
def onClicked(event):
self.humanPos = [0.0, 0.0, 0.0]
self.xposslider.setValue(0.0)
self.yposslider.setValue(0.0)
self.zposslider.setValue(0.0)
G.app.selectedHuman.setPosition(self.humanPos)
self.updateFrame()
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Random')
toolbox = self.addLeftWidget(gui.SliderBox('Tools'))
self.macro = toolbox.addWidget(gui.CheckBox("Macro", True))
self.height = toolbox.addWidget(gui.CheckBox("Height"))
self.face = toolbox.addWidget(gui.CheckBox("Face"))
self.symmetry = toolbox.addWidget(
gui.Slider(value=-1.0, min=-1.0, max=1.0, label="Symmetry"))
self.amount = toolbox.addWidget(gui.Slider(value=0.5, label="Amount"))
self.create = toolbox.addWidget(gui.Button("Replace current"))
self.modify = toolbox.addWidget(gui.Button("Adjust current"))
self.lastRandoms = {}
@self.create.mhEvent
def onClicked(event):
#human = gui3d.app.selectedHuman
# human.resetMeshValues()
self.lastRandoms = {}
if self.macro.selected:
self.storeLastRandom('gender', 0.5, random.random() - 0.5)
self.storeLastRandom('age', 0.5, random.random() - 0.5)
self.storeLastRandom('muscle', 0.5, random.random() - 0.5)
self.storeLastRandom('weight', 0.5, random.random() - 0.5)
if self.height.selected:
self.storeLastRandom('height', 0, random.random() * 2 - 1)
if self.face.selected:
category = gui3d.app.getCategory('Modelling')
taskview = category.getTaskByName('Face')
modifiers = taskview.getModifiers()
symmetricModifiers = taskview.getSymmetricModifierPairNames()
for pair in symmetricModifiers:
#print "symmetric: "+pair['left']+' and '+pair['right']
leftValue = random.gauss(0, 0.5)
rightValue = random.gauss(0, 0.5)
# store randoms for later
self.storeLastRandom(pair['left'], 0, leftValue)
self.storeLastRandom(pair['right'], 0, rightValue)
singularModifiers = taskview.getSingularModifierNames()
for modName in singularModifiers:
#print "singular: "+modName
# get random gaussian
value = random.gauss(0, 0.5)
# non-asymmetric modifiers should only go 0..1
m = modifiers[modName]
if m.clampValue(-1.0) >= 0:
value = abs(value)
# store for later
self.storeLastRandom(modName, 0, value)
self.setModifiers()
@self.modify.mhEvent
def onClicked(event):
human = gui3d.app.selectedHuman
if self.macro.selected:
self.storeLastRandom('gender', human.getGender(),
random.random() - 0.5)
self.storeLastRandom('age', human.getAge(),
random.random() - 0.5)
self.storeLastRandom('weight', human.getWeight(),
random.random() - 0.5)
self.storeLastRandom('muscle', human.getMuscle(),
random.random() - 0.5)
if self.height.selected:
self.storeLastRandom('height', human.getHeight(),
random.random() - 0.5)
if self.face.selected:
category = gui3d.app.getCategory('Modelling')
taskview = category.getTaskByName('Face')
modifiers = taskview.getModifiers()
symmetricModifiers = taskview.getSymmetricModifierPairNames()
for pair in symmetricModifiers:
#print "symmetric: "+pair['left']+' and '+pair['right']
leftValue = random.gauss(0, 0.5)
rightValue = random.gauss(0, 0.5)
# store randoms for later
self.storeLastRandom(
pair['left'], modifiers[pair['left']].getValue(human),
leftValue)
self.storeLastRandom(
pair['right'],
modifiers[pair['right']].getValue(human), rightValue)
singularModifiers = taskview.getSingularModifierNames()
for modName in singularModifiers:
#print "singular: "+modName
# get random gaussian
value = random.gauss(0, 0.5)
# non-asymmetric modifiers should only go 0..1
m = modifiers[modName]
if m.clampValue(-1.0) >= 0:
value = abs(value)
# store for later
self.storeLastRandom(modName,
modifiers[modName].getValue(human),
value)
self.setModifiers()
@self.amount.mhEvent
def onChange(value):
self.setModifiers()
@self.symmetry.mhEvent
def onChange(value):
self.setModifiers()
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Animations')
# we need a different color to make the standard icons visible
#
pcolor = "background-color :#e0e0e0"
standardIcon = QApplication.style().standardIcon
self.human = gui3d.app.selectedHuman
self.currentframe = 0
box = self.addLeftWidget(gui.GroupBox('Animations'))
self.playbackSlider = box.addWidget(gui.Slider(label='Frame'))
self.playbackSlider.setMin(0)
self.frameLbl = box.addWidget(gui.TextView(''))
self.frameLbl.setTextFormat(u"Frame: %s", 0)
playerbox = box.addWidget(gui.QtWidgets.QGroupBox('Position'))
layout = gui.QtWidgets.QGridLayout()
playerbox.setLayout(layout)
self.btn1 = gui.Button()
self.btn1.setIcon(standardIcon(QStyle.SP_MediaSkipBackward))
self.btn1.setStyleSheet(pcolor)
self.btn1.setToolTip("Set to first frame")
layout.addWidget(self.btn1, 0, 0)
self.btn2 = gui.Button()
self.btn2.setIcon(standardIcon(QStyle.SP_MediaSeekBackward))
self.btn2.setStyleSheet(pcolor)
self.btn2.setToolTip("One frame backward")
layout.addWidget(self.btn2, 0, 1)
self.btn3 = gui.Button()
self.btn3.setIcon(standardIcon(QStyle.SP_MediaSeekForward))
self.btn3.setStyleSheet(pcolor)
self.btn3.setToolTip("One frame forward")
layout.addWidget(self.btn3, 0, 2)
self.btn4 = gui.Button()
self.btn4.setIcon(standardIcon(QStyle.SP_MediaSkipForward))
self.btn4.setStyleSheet(pcolor)
self.btn4.setToolTip("Set to last frame")
layout.addWidget(self.btn4, 0, 3)
self.messageBox = box.addWidget(gui.TextView(''))
@self.btn1.mhEvent
def onClicked(event):
self.currentframe = 0
self.updateFrame()
@self.btn2.mhEvent
def onClicked(event):
if self.currentframe > 0:
self.currentframe -= 1
self.updateFrame()
@self.btn3.mhEvent
def onClicked(event):
if self.currentframe < self.nFrames - 1:
self.currentframe += 1
self.updateFrame()
@self.btn4.mhEvent
def onClicked(event):
if self.nFrames > 1:
self.currentframe = self.nFrames - 1
self.updateFrame()
@self.playbackSlider.mhEvent
def onChange(value):
self.currentframe = int(value)
self.updateFrame()
@self.playbackSlider.mhEvent
def onChanging(value):
self.currentframe = int(value)
self.updateFrame()
def makeProps(self):
SceneItem.makeProps(self)
self.posbox = self.widget.addWidget(
VectorInput("Position", self.light.position))
self.posboxSliderX = self.widget.addWidget(
gui.Slider(value=self.light.position[0],
min=-50,
max=50,
label=['Light X position', ' %.2f']))
self.posboxSliderY = self.widget.addWidget(
gui.Slider(value=self.light.position[1],
min=-50,
max=50,
label=['Light y position', ' %.2f']))
self.posboxSliderZ = self.widget.addWidget(
gui.Slider(value=self.light.position[2],
min=-50,
max=50,
label=['Light Z position', ' %.2f']))
# self.focbox = self.widget.addWidget(
# VectorInput("Focus", self.light.focus))
# self.focboxSliderX = self.widget.addWidget(gui.Slider(value=self.light.focus[0], min=0, max=1, label=['FocusX',' %.2f']))
# self.focboxSliderY = self.widget.addWidget(gui.Slider(value=self.light.focus[0], min=0, max=1, label=['FocusY',' %.2f']))
# self.focboxSliderZ = self.widget.addWidget(gui.Slider(value=self.light.focus[0], min=-0, max=1, label=['FocusZ',' %.2f']))
self.colbox = self.widget.addWidget(
VectorInput("Color", self.light.color, True))
self.specular2 = (1, 1, 1)
self.specbox = self.widget.addWidget(
VectorInput("Specular", self.light.specular, True))
self.specboxSlider = self.widget.addWidget(
gui.Slider(value=self.light.specular[0],
min=0,
max=1,
label=['Specular intensity', ' %.2f']))
# self.fov = self.widget.addWidget(
# VectorInput("Spot angle", [self.light.fov]))
# self.fovSlider = self.widget.addWidget(gui.Slider(value=0, min=0, max=180, label=['Spot angle',' %.2f']))
# self.att = self.widget.addWidget(
# VectorInput("Attenuation", [self.light.attenuation]))
# self.soft = self.widget.addWidget(
# BooleanInput("Soft light", self.light.areaLights > 1))
# self.size = self.widget.addWidget(
# VectorInput("Softness", [self.light.areaLightSize]))
# self.samples = self.widget.addWidget(
# VectorInput("Samples", [self.light.areaLights]))
self.removebtn = self.widget.addWidget(
gui.Button('Remove light ' + str(self.lightid)))
@self.posbox.mhEvent
def onChange(value):
self.light.position = tuple(value)
#self.posboxSliderX.setValue()
@self.posboxSliderX.mhEvent
def onChanging(value):
self.light.position = (value, self.posboxSliderY.getValue(),
self.posboxSliderZ.getValue())
self.posbox.setValue(self.light.position)
@self.posboxSliderY.mhEvent
def onChanging(value):
self.light.position = (self.posboxSliderX.getValue(), value,
self.posboxSliderZ.getValue())
self.posbox.setValue(self.light.position)
@self.posboxSliderZ.mhEvent
def onChanging(value):
self.light.position = (self.posboxSliderX.getValue(),
self.posboxSliderY.getValue(), value)
self.posbox.setValue(self.light.position)
# @self.focbox.mhEvent
# def onChange(value):
# self.light.focus = tuple(value)
# @self.focboxSliderX.mhEvent
# def onChanging(value):
# self.light.focus = (value,self.focboxSliderY.getValue(),self.focboxSliderZ.getValue())
# self.focbox.setValue(self.light.focus)
# @self.focboxSliderY.mhEvent
# def onChanging(value):
# self.light.focus = (self.focboxSliderX.getValue(),value,self.focboxSliderZ.getValue())
# self.focbox.setValue(self.light.focus)
# @self.focboxSliderZ.mhEvent
# def onChanging(value):
# self.light.focus = (self.focboxSliderX.getValue(),self.focboxSliderY.getValue(),value)
# self.focbox.setValue(self.light.focus)
@self.colbox.mhEvent
def onChange(value):
self.light.color = tuple(value)
@self.specbox.mhEvent
def onChange(value):
self.light.specular = tuple(value)
@self.specboxSlider.mhEvent
def onChanging(value):
self.specular2 = self.specbox.getValue()
self.light.specular = (self.specular2[0] * value,
self.specular2[1] * value,
self.specular2[2] * value)
#self.specbox.setValue(self.light.specular)
# @self.fov.mhEvent
# def onChange(value):
# self.light.fov = value[0]
# log.message('fov : %s', value)
# @self.fovSlider.mhEvent
# def onChanging(value):
# self.light.fov = value
# self.fov.setValue([value])
# log.message('titi : %s', value)
# @self.att.mhEvent
# def onChange(value):
# self.light.attenuation = value[0]
# @self.soft.mhEvent
# def onChange(value):
# if value and self.light.areaLights <= 1:
# self.light.areaLights = 2
# self.samples.setValue([2])
# elif self.light.areaLights > 1:
# self.light.areaLights = 1
# self.samples.setValue([1])
# @self.size.mhEvent
# def onChange(value):
# self.light.attenuation = value[0]
# @self.samples.mhEvent
# def onChange(value):
# self.light.areaLights = int(value[0])
# self.soft.setValue(self.light.areaLights > 1)
@self.removebtn.mhEvent
def onClicked(event):
self.sceneview.scene.removeLight(self.light)
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Povray')
# for path to PovRay binaries file
binary = ''
bintype = []
pathBox = self.addLeftWidget(gui.GroupBox('Povray bin path'))
# this part load old settings values for next session; str(povray_bin)
povray_bin = gui3d.app.settings.get('povray_bin', '')
self.path = pathBox.addWidget(gui.TextEdit(str(povray_bin)), 0, 0, 1,
2)
self.browse = pathBox.addWidget(gui.BrowseButton('dir'), 1, 0, 1, 1)
self.browse.setPath(povray_bin)
if sys.platform == 'win32':
self.browse.setFilter(
'Executable programs (*.exe);;All files (*.*)')
#
if os.name == 'nt':
#
if os.environ['PROCESSOR_ARCHITECTURE'] == 'x86':
self.win32sse2Button = pathBox.addWidget(
gui.CheckBox('Use SSE2 bin', True))
#
@self.path.mhEvent
def onChange(value):
gui3d.app.settings[
'povray_bin'] = 'Enter your path' if not value else str(value)
@self.browse.mhEvent
def onClicked(path):
if os.path.isdir(path):
gui3d.app.settings['povray_bin'] = path
self.path.setText(path)
#------------------------------------------------------------------------------------
filter = []
# Options box
optionsBox = self.addLeftWidget(gui.GroupBox('Options'))
self.doSubdivide = optionsBox.addWidget(
gui.CheckBox('Subdivide mesh', True))
self.useSSS = optionsBox.addWidget(
gui.CheckBox('Use S.S. Scattering', True))
self.SSSA = optionsBox.addWidget(
gui.Slider(value=0.3, label="SSS Amount"))
self.AA = optionsBox.addWidget(
gui.Slider(value=0.4, label="AntiAliasing"))
materialsBox = self.addRightWidget(gui.GroupBox('Materials'))
self.skinoil = materialsBox.addWidget(
gui.Slider(value=0.4, label="Skin oil"))
self.rough = materialsBox.addWidget(
gui.Slider(value=0.5, label="Skin roughness"))
self.wrinkles = materialsBox.addWidget(
gui.Slider(value=0.2, label="Skin wrinkles"))
self.hairSpec = materialsBox.addWidget(
gui.CheckBox('Hair shine', False))
self.hspecA = materialsBox.addWidget(
gui.Slider(value=0.5, label="Shine strength"))
self.hairThick = materialsBox.addWidget(
gui.Slider(value=0.67, label="Hair thickness"))
# box
#optionsBox = self.addLeftWidget(gui.GroupBox('Options'))
#Buttons
# Simplified the gui a bit for the average user. Uncomment to clutter it up with developer - useful stuff.
#source=[]
#self.iniButton = optionsBox.addWidget(gui.RadioButton(source, 'Use ini settings'))
#self.guiButton = optionsBox.addWidget(gui.RadioButton(source, 'Use gui settings', selected = True))
#format=[]
#self.arrayButton = optionsBox.addWidget(gui.RadioButton(format, 'Array format'))
#self.mesh2Button = optionsBox.addWidget(gui.RadioButton(format, 'Mesh2 format', selected = True))
#action=[]
#self.exportButton = optionsBox.addWidget(gui.RadioButton(action , 'Export only', selected = True))
#self.exportandrenderButton = optionsBox.addWidget(gui.RadioButton(action , 'Export and render'))
self.renderButton = optionsBox.addWidget(gui.Button('Render'))
#
@self.renderButton.mhEvent
def onClicked(event):
reload(
mh2povray
) # Avoid having to close and reopen MH for every coding change (can be removed once testing is complete)
# it is necessary to put this code here, so that it is executed with the 'renderButton.event'
if os.name == 'nt':
#
if os.environ['PROCESSOR_ARCHITECTURE'] == "x86":
binary = 'win32'
#
if self.win32sse2Button.selected:
binary = 'win32sse2'
#
else:
binary = 'win64'
# for Ubuntu.. atm
if sys.platform == 'linux2':
binary = 'linux'
#
mh2povray.povrayExport(
gui3d.app.selectedHuman.mesh,
gui3d.app,
{
'source':
'gui', # 'ini' if self.iniButton.selected else 'gui',
'format':
'mesh2', # 'array' if self.arrayButton.selected else 'mesh2',
'action':
'render', # 'export' if self.exportButton.selected else 'render',
'subdivide': True if self.doSubdivide.selected else False,
'AA': 0.5 - 0.49 * self.AA.getValue(),
'bintype': binary,
'SSS': True if self.useSSS.selected else False,
'SSSA': 6 * self.SSSA.getValue(), # power of 2
'skinoil': 0.001 *
(10**(4 * self.skinoil.getValue())), # exponential slider
'rough': 0.001 *
(10**(2 * self.rough.getValue())), # exponential slider
'wrinkles': 0.5 * self.wrinkles.getValue(),
'hairSpec': True if self.hairSpec.selected else False,
'hspecA': 0.1 *
(10**(2 * self.hspecA.getValue())), # exponential slider
'hairThin': 5**(2 * (1 - self.hairThick.getValue()))
}) # exponential slider
def __init__(self, category):
gui3d.TaskView.__init__(self, category, 'Perspective')
self.isOrthoView = True
self.createShortCut()
self.human = gui3d.app.selectedHuman
self.currentframe = 0
self.framesloaded = 0
self.fov = self.fovangle_loaded = G.app.modelCamera.getFovAngle()
projbox = self.addLeftWidget(gui.GroupBox('BVH Viewer'))
self.avFramesText = projbox.addWidget(gui.TextView('Available frames: 0'))
self.playbackSlider = projbox.addWidget(gui.Slider(label=['Current frame', ': %d']))
self.playbackSlider.setMin(0)
self.invMouseWheel = G.app.getSetting('invertMouseWheel')
@self.playbackSlider.mhEvent
def onChange(value):
self.currentframe = int(value)
self.updateFrame()
self.nextframeButton = projbox.addWidget(gui.Button('Next frame'))
@self.nextframeButton.mhEvent
def onClicked(event):
anim = self.human.getActiveAnimation()
if anim:
if self.currentframe >= anim.nFrames-1:
self.currentframe = 0
else:
self.currentframe += 1
self.updateFrame()
self.playbackSlider.setValue(self.currentframe)
self.prevframeButton = projbox.addWidget(gui.Button('Previous frame'))
@self.prevframeButton.mhEvent
def onClicked(event):
anim = self.human.getActiveAnimation()
if anim:
if self.currentframe <= 0:
self.currentframe = anim.nFrames-1
else:
self.currentframe -= 1
self.updateFrame()
self.playbackSlider.setValue(self.currentframe)
projbox = self.addLeftWidget(gui.GroupBox('Projection'))
self.projRadioButtonGroup = []
self.persButton = projbox.addWidget(gui.RadioButton(self.projRadioButtonGroup, 'Perspective',selected=G.app.modelCamera.projection))
@self.persButton.mhEvent
def onClicked(event):
self.toggleView()
self.orthButton = projbox.addWidget(gui.RadioButton(self.projRadioButtonGroup, 'Orthogonal',selected=not G.app.modelCamera.projection))
@self.orthButton.mhEvent
def onClicked(event):
self.toggleView()
self.focalDistanceLbl = projbox.addWidget(gui.TextView('Focal distance= '))
self.updateFocalDistance(self.fov)
self.fovslider = projbox.addWidget(gui.Slider(label=['Focus angle', '= %.2f'], min=1.0, max=90.0, value=self.fov))
@self.fovslider.mhEvent
def onChange(value):
for cam in G.cameras:
cam.setFovAngle(value)
cam.changed()
self.updateFocalDistance(value)
self.trans= G.cameras[0].getPosition()
posbox = self.addLeftWidget(gui.GroupBox('Camera Translation'))
self.xposslider = posbox.addWidget(gui.Slider(label=['X-translation', '= %.2f'], min=-1.0, max=1.0, value=self.trans[0]))
@self.xposslider.mhEvent
def onChange(value):
for cam in G.cameras:
self.trans[0] = value
cam.setPosition (self.trans)
cam.changed()
self.yposslider = posbox.addWidget(gui.Slider(label=['Y-translation', '= %.2f'], min=-1.0, max=1.0, value=self.trans[1]))
@self.yposslider.mhEvent
def onChange(value):
for cam in G.cameras:
cam.translation[1] = value
cam.setPosition (self.trans)
cam.changed()
self.resetButton = posbox.addWidget(gui.Button('Reset translation'))
@self.resetButton.mhEvent
def onClicked(event):
for cam in G.cameras:
cam.translation = [0.0, 0.0, 0.0]
cam.pickedPos = cam.translation
cam.changed()
self.xposslider.setValue (0.0)
self.yposslider.setValue (0.0)
self.updateFrame()
@self.mhEvent
def onMouseWheel(event):
if self.isOrthoView == True:
G.app.onMouseWheel(event)
else:
zoomOut = event.wheelDelta > 0
if self.invMouseWheel:
zoomOut = not zoomOut
if zoomOut:
if self.fov <= 1:
return
self.fov -= 1
else:
if self.fov >=90:
return
self.fov += 1
for cam in G.cameras:
cam.setFovAngle(self.fov)
cam.changed()
self.updateFocalDistance(self.fov)
self.fovslider.setValue (self.fov)
@self.mhEvent
def onMouseDragged(event):
G.app.onMouseDragged(event)
self.updateCoords()
