def __init__(self):
# studioMaya.Maya.__init__(self)
super(Pack, self).__init__()
self.model = studioModel.Model()
self.shader = studioShader.Shader()
self.nurbscurve = studioNurbscurve.Nurbscurve()
self.nested_bundle = {}
self.flatted_bundle = {}
def create_model():
'''
:example
from studio_usd_pipe.core import asset
mpack.asset()
'''
from maya import OpenMaya
from studio_usd_pipe.api import studioNurbscurve
from studio_usd_pipe.api import studioShader
scurve = studioNurbscurve.Nurbscurve()
sshader = studioShader.Shader()
root = get_root()
world = get_world()
# remove depend nodes
depend_nodes = scurve.extract_depend_nodes(default=False)
for x in range(depend_nodes.length()):
scurve.remove_node(depend_nodes[x])
scurve.remove_nodes(depend_nodes)
# make model group
mesh_mobjects = scurve.extract_transform_primitive(OpenMaya.MFn.kMesh,
shape=False)
model_dag_node = scurve.create_group(root)
# make geometry hierarchy
for x in range(mesh_mobjects.length()):
scurve.set_locked(mesh_mobjects[x].node(),
attributes=None,
locked=False)
scurve.disconnect_chanelbox(mesh_mobjects[x].node())
scurve.set_parent(mesh_mobjects[x], model_dag_node.object())
# assigin default shader
sshader.assign_shading_engine(mesh_mobjects[x], shading_group=None)
# remove unwanted dag nodes
trans_dagpath_array = scurve.extract_top_transforms(default=False)
for x in range(trans_dagpath_array.length()):
if trans_dagpath_array[x].node() == model_dag_node.object():
continue
scurve.remove_node(trans_dagpath_array[x].node())
# scurve.remove_nodes(transform_mobjects)
# reset transforms
for x in range(mesh_mobjects.length()):
scurve.delete_history(mesh_mobjects[x])
scurve.freeze_transformations(mesh_mobjects[x])
scurve.set_default_position(mesh_mobjects[x].node())
# create world control
world_dependency_node = scurve.create_world(model_dag_node, parent=True)
# set the name
model_dag_node.setName(root)
world_dependency_node.setName(world)
# create asset id
id_data = resource.getPipeIDData()
scurve.create_maya_ids(model_dag_node.object(), id_data)
# OpenMaya.MGlobal.selectByName(model_dag_node.fullPathName())
OpenMaya.MGlobal.clearSelectionList()
scurve.set_perspective_view()
return True, [root], 're-generate hierarchy'
def model(self, replace=True):
# create polygon mesh
smodel = studioModel.Model()
model_data = self.studio_data['mesh']
model_nodes = smodel.sort_dictionary(model_data)
contents = {}
for node in model_nodes:
node_contents = model_data[node]
mfn_mesh = smodel.create_model(node,
node_contents,
replace=replace)
contents.setdefault(node.split('|')[-1], mfn_mesh.parent(0))
# create nurbs curve
scurve = studioNurbscurve.Nurbscurve()
curve_data = self.studio_data['curve']
curve_nodes = scurve.sort_dictionary(curve_data)
for node in curve_nodes:
node_contents = curve_data[node]
mfn_curve = scurve.create_curve(node,
node_contents,
replace=replace)
contents.setdefault(node.split('|')[-1], mfn_curve.parent(0))
# create transform
transform_data = self.studio_data['transform']
for node, node_contents in transform_data.items():
mfn_transform = smodel.create_transform(node,
node_contents,
replace=replace)
contents.setdefault(node.split('|')[-1], mfn_transform.object())
# create hierarchy
locations = model_nodes + curve_nodes + transform_data.keys()
stack = []
for location in locations:
nodes = location.split('|')[1:]
for x in range(len(nodes)):
if len(nodes) == x + 1:
continue
if [nodes[x + 1], nodes[x]] in stack:
continue
mfndag_child = OpenMaya.MFnDagNode(contents[nodes[x + 1]])
mfndag_parent = OpenMaya.MFnDagNode(contents[nodes[x]])
smodel.set_parent(mfndag_child.fullPathName(),
mfndag_parent.fullPathName())
stack.append([nodes[x + 1], nodes[x]])
def create_model_usd(output_path):
from studio_usd_pipe.api import studioUsd
from studio_usd_pipe.api import studioModel
from studio_usd_pipe.api import studioNurbscurve
reload(studioUsd)
smodel = studioModel.Model()
scurve = studioNurbscurve.Nurbscurve()
root = get_root()
mobject = smodel.get_mobject(root)
mesh_data = smodel.get_model_data(mobject)
curve_data = scurve.get_curve_data(mobject)
pipe_ids, valid = smodel.get_pipe_id_data(mobject, id_data=None)
final_data = {'mesh': mesh_data, 'curve': curve_data, 'asset_id': pipe_ids}
print '\nroot', root
susd = studioUsd.Susd(path=output_path)
susd.create_model_usd(root, final_data)
return output_path
def create_studio_model(output_path):
from studio_usd_pipe.api import studioModel
from studio_usd_pipe.api import studioNurbscurve
smodel = studioModel.Model()
scurve = studioNurbscurve.Nurbscurve()
root = get_root()
mobject = smodel.get_mobject(root)
mesh_data = smodel.get_model_data(mobject)
curve_data = scurve.get_curve_data(mobject)
transform_data = smodel.get_transform_data(mobject)
final_data = {
'mesh': mesh_data,
'curve': curve_data,
'transform': transform_data
}
with (open(output_path, 'w')) as content:
content.write(json.dumps(final_data, indent=4))
return output_path
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'