def create_studio_uv(studio_uv_path, merge):
from studio_usd_pipe.api import studioModel
smodel = studioModel.Model()
studio_uv = common.read_json(studio_uv_path)
uv_data = studio_uv['mesh']
for node, contenst in uv_data.items():
mfn_mesh = smodel.create_uv(node, contenst)
return True, studio_uv_path, 'success'
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_uv_usd(output_path):
from studio_usd_pipe.api import studioUsd
from studio_usd_pipe.api import studioModel
smodel = studioModel.Model()
root = get_root()
mobject = smodel.get_mobject(root)
mesh_data = smodel.get_uv_data(mobject)
pipe_ids, valid = smodel.get_pipe_id_data(mobject, id_data=None)
final_data = {'mesh': mesh_data, 'asset_id': pipe_ids}
susd = studioUsd.Susd(path=output_path)
susd.create_uv_usd(root, final_data)
return output_path
def create_studio_uv(output_path):
from studio_usd_pipe.api import studioModel
from studio_usd_pipe.api import studioNurbscurve
smodel = studioModel.Model()
root = get_root()
mobject = smodel.get_mobject(root)
mesh_data = smodel.get_uv_data(mobject)
final_data = {
'mesh': mesh_data,
}
with (open(output_path, 'w')) as content:
content.write(json.dumps(final_data, indent=4))
return output_path
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'
def validate_uv_sets():
from maya import OpenMaya
from studio_usd_pipe.api import studioModel
reload(studioModel)
smodel = studioModel.Model()
root = get_root()
mobject = smodel.get_mobject(root)
transform_mesh = smodel.extract_transform_primitive(OpenMaya.MFn.kMesh,
shape=True,
parent_mobject=mobject)
data = {}
for x in range(transform_mesh.length()):
uvsets = smodel.get_uvsets(transform_mesh[x])
for uvset in uvsets:
valid = smodel.has_valid_uvset(transform_mesh[x], uvset)
data.setdefault(valid, []).append(
[transform_mesh[x].fullPathName(), uvset])
if False in data:
return False, data[False], 'found in-valid uvsets'
return True, [None], 'all uv sets are valid'
def uv(self, replace=True):
smodel = studioModel.Model()
uv_data = self.studio_data['mesh']
for node, contenst in uv_data.items():
mfn_mesh = smodel.create_uv(node, contenst)
