def create_uv(self, data, stage=None):
if not stage:
stage = self.make_satge()
if not stage:
return
geometries = common.sort_dictionary(data)
for geometry in geometries:
location = geometry.replace(':', '_')
sdf_path = Sdf.Path(location.replace('|', '/'))
current_data = data[geometry]
for path in sdf_path.GetPrefixes():
UsdGeom.Xform.Define(stage, path)
mesh_define = UsdGeom.Mesh.Define(stage,
sdf_path.GetPrefixes()[-1])
uv_sets = common.sort_dictionary(current_data)
for index, uv_set in enumerate(uv_sets):
uv_d = current_data[uv_set]
uv_points = []
for x in range(len(uv_d['u_array'])):
uv_points.append((uv_d['u_array'][x], uv_d['u_array'][x]))
current_set = 'st'
if index > 0:
current_set = uv_set
uv_data = [uv_points, uv_d['uv_ids']]
self.make_uv_points_ids(mesh_define, current_set, uv_data)
return stage
def create_pipe_ids(self, mobject, id_data):
attributes = common.sort_dictionary(id_data)
self.remove_pipe_ids(mobject, id_data)
data = {}
hidden = {True: False, False: True}
for attribute in attributes:
short = id_data[attribute]['short']
type_attribute = OpenMaya.MFnTypedAttribute()
sample_mobject = OpenMaya.MObject()
sample_mobject = type_attribute.create(attribute, short,
OpenMaya.MFnData.kString)
type_attribute.setKeyable(False)
type_attribute.setReadable(True)
type_attribute.setChannelBox(False)
type_attribute.setWritable(id_data[attribute]['locked'])
type_attribute.setHidden(hidden[id_data[attribute]['show']])
mfn_dependency_node = OpenMaya.MFnDependencyNode()
mfn_dependency_node.setObject(mobject)
mfn_dependency_node.addAttribute(sample_mobject)
mplug = mfn_dependency_node.findPlug(type_attribute.name())
if not id_data[attribute]['value']:
data.setdefault(attribute, 'no value updated')
else:
mplug.setString(id_data[attribute]['value'].encode())
data.setdefault(attribute, id_data[attribute]['value'])
mplug.setLocked(id_data[attribute]['locked'])
return data
def create_asset_ids(self, stage, root, data):
define = UsdGeom.Xform.Define(stage, '/{}'.format(root))
ids = common.sort_dictionary(data)
for id in ids:
primvar = define.CreatePrimvar(id, Sdf.ValueTypeNames.String)
primvar.Set(data[id]['value'])
primvar.SetInterpolation('constant')
return stage
def create_studio_model(studio_model_path, merge):
from maya import OpenMaya
from studio_usd_pipe.api import studioModel
from studio_usd_pipe.api import studioNurbscurve
# create polygon mesh
studio_model = common.read_json(studio_model_path)
model_data = studio_model['mesh']
model_nodes = common.sort_dictionary(model_data)
smodel = studioModel.Model()
contents = {}
for node in model_nodes:
node_contents = model_data[node]
mfn_mesh = smodel.create_model(node, node_contents, merge=merge)
contents.setdefault(node.split('|')[-1], mfn_mesh.parent(0))
# create nurbs curve
scurve = studioNurbscurve.Nurbscurve()
curve_data = studio_model['curve']
curve_nodes = common.sort_dictionary(curve_data)
for node in curve_nodes:
node_contents = curve_data[node]
mfn_curve = scurve.create_curve(node, node_contents, merge=merge)
contents.setdefault(node.split('|')[-1], mfn_curve.parent(0))
# create transform
transform_data = studio_model['transform']
for node, node_contents in transform_data.items():
mfn_transform = smodel.create_transform(node,
node_contents,
merge=merge)
contents.setdefault(node.split('|')[-1], mfn_transform.object())
locations = model_nodes + curve_nodes + transform_data.keys()
hierarchy = common.flatten_to_dictionary(locations, '|')
stack = hierarchy.items()
while stack:
parent, children = stack.pop()
if not children:
continue
if not isinstance(children, dict):
continue
mfndag_parent = OpenMaya.MFnDagNode(contents[parent])
for child in children:
mfndag_child = OpenMaya.MFnDagNode(contents[child])
smodel.set_parent(mfndag_child, mfndag_parent)
stack.extend(children.items())
return True, studio_model_path, 'success'
def set_context_widgets(self, inputs, layout):
sizepolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
sorted_date = common.sort_dictionary(inputs)
for index, each in enumerate(sorted_date):
contents = inputs[each]
label = QtWidgets.QLabel(self)
label.setObjectName('label_%s' % each)
label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
label.setText(contents['label'])
label.setSizePolicy(sizepolicy)
layout.addWidget(label, index, 0, 1, 1)
if contents['type'] in ['str', 'path', 'dirname', 'list']:
lineedit = QtWidgets.QLineEdit(self)
lineedit.setObjectName('lineedit_%s' % each)
value = contents['value']
if contents['type'] == 'list':
value = ', '.join(contents['value'])
lineedit.setText(value)
lineedit.setStatusTip('%s,%s,%s,%s' %
(each, contents['env'], contents['type'],
contents['order']))
layout.addWidget(lineedit, index, 1, 1, 1)
if contents['type'] in ['path', 'dirname']:
button = QtWidgets.QPushButton(self)
button.setObjectName('button_%s' % each)
button.setText('...')
button.setMinimumSize(QtCore.QSize(30, 0))
button.setMaximumSize(QtCore.QSize(30, 16777215))
layout.addWidget(button, index, 2, 1, 1)
button.clicked.connect(
partial(self.find_directory, lineedit, contents))
if contents['type'] in ['int']:
spinbox = QtWidgets.QSpinBox(self)
spinbox.setObjectName('spinbox_%s' % each)
spinbox.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
spinbox.setMinimum(0)
value = 999999999
if contents['type'] == 'bool':
value = 1
spinbox.setMaximum(value)
spinbox.setValue(contents['value'])
spinbox.setStatusTip('%s,%s,%s,%s' %
(each, contents['env'], contents['type'],
contents['order']))
layout.addWidget(spinbox, index, 1, 1, 1)
if contents['type'] in ['bool']:
combobox = QtWidgets.QComboBox(self)
combobox.setObjectName('combobox_%s' % each)
combobox.addItems(['False', 'True'])
combobox.setCurrentIndex(contents['value'])
combobox.setStatusTip('%s,%s,%s,%s' %
(each, contents['env'], contents['type'],
contents['order']))
layout.addWidget(combobox, index, 1, 1, 1)
def set_default(self):
inputs = self.shows.get_show_configure_data()
order = self.shows.get_next_order()
inputs['show']['order']['value'] = order
self.set_widgets('current_show', 'show', inputs['show'], order)
sorted_application = common.sort_dictionary(
inputs['show_applications'])
for index, application in enumerate(sorted_application):
self.set_widgets('show_applications', application,
inputs['show_applications'][application], index)
def release(self):
packing_data = sum(self.extracted_data.values(), [])
valid = self.move_to_publish(packing_data)
if not valid:
print '#warnings', 'deployed to spublish failed!...'
return False, 'deployed to spublish failed!...'
release_inputs = self.make_release_inputs()
dbs = database.DataBase(self.current_show, self.current_pipe)
dbs.create(release_inputs)
print '\n#header registered info'
sorted_data = common.sort_dictionary(release_inputs)
for each in sorted_data:
print '%s: ' % each.rjust(15), release_inputs[each]['value']
print 'successfully registered spublish'
return True, 'successfully registered spublish'
def setup_applications(self, application_type, application_contents, listwidget):
if not application_contents:
return
sorted_contents = common.sort_dictionary(application_contents)
for each in sorted_contents:
if each == 'show':
continue
contents = application_contents[each]
print '%s|%s' % (application_type, each)
swidgets.add_listwidget_item(
listwidget,
contents['version'][1],
key='%s|%s' % (application_type, each),
icon_path=contents['icon'][1]
)
print 'version: '.rjust(15), contents['version'][1]
print 'source: '.rjust(15), contents['exe'][1]
print 'path: '.rjust(15), contents['path'][1], '\n'
def show_applications(current_show, verbose=False):
show = studioShow.Show()
data = show.get_show_preset_data(current_show)
if not data:
return None
versions = []
for application in show.application_types:
if application not in data:
continue
if not data[application]:
continue
applications = common.sort_dictionary(data[application])
for each in applications:
name = [each, data[application][each]['version'][1]]
versions.append(name)
if verbose:
print application.rjust(25), name
return versions
def create_kuv(self, mobject, data):
mfn_mesh = OpenMaya.MFnMesh(mobject)
self.delete_uv_sets(mfn_mesh, set_names=None)
default_set_name = self.get_default_uvset(mfn_mesh)
sorted_data = common.sort_dictionary(data)
for index, set_name in enumerate(sorted_data):
contents = data[set_name]
u_array = self.create_float_array(contents['u_array'])
v_array = self.create_float_array(contents['v_array'])
uv_counts = self.create_int_array(contents['uv_counts'])
uv_ids = self.create_int_array(contents['uv_ids'])
if index == 0:
mfn_mesh.clearUVs(default_set_name)
if default_set_name != set_name:
mfn_mesh.renameUVSet(default_set_name, set_name)
else:
set_name = mfn_mesh.createUVSetWithName(set_name)
mfn_mesh.setUVs(u_array, v_array, set_name)
mfn_mesh.assignUVs(uv_counts, uv_ids, set_name)
mfn_mesh.updateSurface()
return mfn_mesh
def create_model(self, data, stage=None):
if not stage:
stage = self.make_satge()
if not stage:
return
geometries = common.sort_dictionary(data)
for geometry in geometries:
location = geometry.replace(':', '_')
sdf_path = Sdf.Path(location.replace('|', '/'))
current_data = data[geometry]
for path in sdf_path.GetPrefixes():
UsdGeom.Xform.Define(stage, path)
mesh_define = UsdGeom.Mesh.Define(stage,
sdf_path.GetPrefixes()[-1])
self.make_m_subdivision(mesh_define, current_data['subdmesh'])
self.make_m_doublesided(mesh_define, current_data['double_sided'])
self.make_m_extent(mesh_define, current_data['bounding'])
self.make_m_face_vertex_counts(mesh_define,
current_data['vertex_count'])
self.make_m_face_vertex_indices(mesh_define,
current_data['vertex_list'])
self.make_m_points(mesh_define, current_data['vertices'])
return stage
def create_curve(self, data, stage=None):
if not stage:
stage = self.make_satge()
if not stage:
return
geometries = common.sort_dictionary(data)
for geometry in geometries:
location = geometry.replace(':', '_')
sdf_path = Sdf.Path(location.replace('|', '/'))
current_data = data[geometry]
for path in sdf_path.GetPrefixes():
UsdGeom.Xform.Define(stage, path)
curev_define = UsdGeom.NurbsCurves.Define(
stage,
sdf_path.GetPrefixes()[-1])
self.make_c_vertex_counts(curev_define, [11])
self.make_c_extent(curev_define, current_data['bounding'])
self.make_c_knots(curev_define, current_data['knots'])
self.make_c_order(curev_define, [4])
self.make_c_points(curev_define, current_data['points'])
self.make_c_ranges(curev_define, (0, 8))
self.make_c_widths(curev_define, [1])
return stage
def create_surface(self, root, data, stage=None):
if not stage:
stage = self.make_satge()
if not stage:
return
# make geomery hierarchy
for material in data:
for geometry in data[material]['geometries']:
location = geometry.replace(':', '_')
sdf_path = Sdf.Path(location.replace('|', '/'))
for path in sdf_path.GetPrefixes():
UsdGeom.Xform.Define(stage, path)
mesh_define = UsdGeom.Mesh.Define(stage,
sdf_path.GetPrefixes()[-1])
look_path = Sdf.Path('/{}/Looks'.format(root))
UsdGeom.Scope.Define(stage, look_path)
materials = common.sort_dictionary(data)
for material in materials: # make materials
contents = data[material]
material_path = look_path.AppendPath(material)
UsdShade.Material.Define(stage, material_path)
# make shader and attributes
for node, node_contents in contents['nodes'].items():
shader_path = material_path.AppendPath(node)
shader_define = UsdShade.Shader.Define(stage, shader_path)
shader_define.CreateIdAttr(node_contents['type'])
if 'parameters' not in node_contents:
continue
for parameter, parameter_contents in node_contents[
'parameters'].items():
current_type, current_value = self.get_prameter_values(
parameter_contents['type'],
parameter_contents['value'])
if not current_type or current_value == 'null':
print '#need to update attribute configure'
print '\tmaterial', material, node, parameter
print '\t', parameter, parameter_contents[
'type'], parameter_contents['value']
print '\t', current_type, current_value
print '\t', type(current_type)
# raise Exception('function get_prameter_values need to update')
# print '\t\t>>>>>', current_type, parameter_contents['value']
shader_define.CreateInput(parameter,
current_type).Set(current_value)
# shader connections
for material, contents in data.items():
for node, node_contents in contents['nodes'].items():
if 'connections' not in node_contents:
continue
for parameter, connection_contents in node_contents[
'connections'].items():
source_attribute, source_node = connection_contents[
'value'].split('@')
shader_path = look_path.AppendPath('%s/%s' %
(material, node))
source_path = look_path.AppendPath('%s/%s' %
(material, source_node))
shader_define = UsdShade.Shader.Define(stage, shader_path)
source_define = UsdShade.Shader.Define(stage, source_path)
current_type, current_value = self.get_prameter_values(
connection_contents['type'], None)
shader_input = shader_define.CreateInput(
parameter, current_type)
shader_input.ConnectToSource(source_define,
source_attribute)
for material in data:
# material assignments
material_path = look_path.AppendPath(material)
material_define = UsdShade.Material.Define(stage, material_path)
for geometry in data[material]['geometries']:
location = geometry.replace(':', '_')
sdf_path = Sdf.Path(location.replace('|', '/'))
mesh_define = UsdGeom.Mesh.Define(stage, sdf_path)
UsdShade.MaterialBindingAPI(mesh_define).Bind(material_define)
# material to shader connection
shader = data[material]['surface']['shader']
attribute = data[material]['surface']['attribute']
shader_path = look_path.AppendPath('%s/%s' % (material, shader))
material_define = UsdShade.Material.Define(stage, material_path)
shader_define = UsdShade.Shader.Define(stage, shader_path)
shader_output = material_define.CreateOutput(
'ri:surface', Sdf.ValueTypeNames.Token)
shader_output.ConnectToSource(shader_define, attribute)
return stage