def create_studio_shader(studio_shader_path, merge):
from studio_usd_pipe.api import studioShader
studio_model = common.read_json(studio_shader_path)
surface_data = studio_model['surface']
sshader = studioShader.Shader()
for node, contenst in surface_data.items():
shading_engine = sshader.create_shadernet(node, contenst, merge=merge)
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 create_shader_usd(output_path):
from studio_usd_pipe.api import studioUsd
from studio_usd_pipe.api import studioShader
sshader = studioShader.Shader()
root = get_root()
mobject = sshader.get_mobject(root)
surface_data = sshader.get_surface_data(mobject)
pipe_ids, valid = sshader.get_pipe_id_data(mobject, id_data=None)
final_data = {'surface': surface_data, 'asset_id': pipe_ids}
susd = studioUsd.Susd(path=output_path)
susd.create_surface_usd(root, final_data)
return output_path
def create_studio_shader(output_path):
from studio_usd_pipe.api import studioShader
sshader = studioShader.Shader()
root = get_root()
mobject = sshader.get_mobject(root)
mesh_data = sshader.get_surface_data(mobject)
final_data = {
'surface': mesh_data,
}
with (open(output_path, 'w')) as content:
content.write(json.dumps(final_data, indent=4))
return output_path
def surface(self, replace=False):
'''
from studio_usd_pipe.core import mayacreate
path = '/venture/shows/batman/assets/batman/surface/1.0.0/batman.shader'
mcreate = mayacreate.Create(path)
mcreate.surface()
'''
sshader = studioShader.Shader()
surface_data = self.studio_data['surface']
for node, contenst in surface_data.items():
shading_engine = sshader.create_shadernet(node,
contenst,
replace=replace)
def check_shader_assigned_geometries():
from studio_usd_pipe.api import studioShader
sshader = studioShader.Shader()
root = get_root()
mobject = sshader.get_mobject(root)
shader_data = sshader.get_scene_shading_engines(mobject)
geometries = []
for geometry, shader_engines in shader_data.items():
if shader_engines:
continue
geometries.append(geometry.fullPathName().encode())
if geometries:
return False, geometries, 'found geometries with out shader assignment'
return True, [], 'all geometries are assigned user shader'
def create_shader_maya(output_path):
from maya import OpenMaya
from studio_usd_pipe.api import studioShader
sshader = studioShader.Shader()
root = get_root()
mobject = sshader.get_mobject(root)
shader_data = sshader.get_scene_shading_engines(mobject)
shading_engines = []
for geometry in shader_data:
for index in range(shader_data[geometry].length()):
mfn_dependency_node = OpenMaya.MFnDependencyNode(
shader_data[geometry][index])
if mfn_dependency_node.name() == 'initialShadingGroup':
continue
shading_engines.append(mfn_dependency_node.name())
sshader.export_selected(shading_engines, output_path, force=True)
return output_path
def create_shader_source_images(caption, temp_output_path, remap_output_path):
'''
from studio_usd_pipe.utils import maya_asset
reload(maya_asset)
caption = 'batman'
output_path = '/usr/tmp/test_show/assets/batman/shader/0.0.1/'
remap_output_path = '/venture/shows/batman/assets/batman/shader/0.0.1/'
maya_asset.create_shader_source_images(caption, output_path, remap_output_path)
'''
from studio_usd_pipe.api import studioShader
sshader = studioShader.Shader()
root = get_root()
mobject = sshader.get_mobject(root)
temp_source_image_path = os.path.join(temp_output_path, 'source_images')
source_image_path = os.path.join(remap_output_path, 'source_images')
if not os.path.isdir(temp_source_image_path):
os.makedirs(temp_source_image_path)
input_data = sshader.get_source_image_data(mobject)
output_data = sshader.set_source_images(input_data, source_image_path)
# copy to temp directory
source_images = set()
for node in input_data:
for attribute in input_data[node]:
source_images.add(input_data[node][attribute]['value'])
lores_data = {}
all_source_images = []
for source_image in source_images:
temp_source_image = os.path.join(temp_source_image_path,
os.path.basename(source_image))
shutil.copy2(source_image, temp_source_image)
lowres_source_image = sshader.create_lowres_source_images(
source_image, temp_source_image_path)
lores_data.setdefault(source_image, lowres_source_image)
all_source_images.append(temp_source_image)
all_source_images.append(lowres_source_image)
source_image_data = os.path.join(temp_output_path,
'%s.sourceimage' % caption)
final_data = {
'input': input_data,
'output': output_data,
'lowres': lores_data
}
with (open(source_image_data, 'w')) as content:
content.write(json.dumps(final_data, indent=4))
final_source_image_data = all_source_images + [source_image_data]
return final_source_image_data
def check_source_images():
from studio_usd_pipe.api import studioShader
sshader = studioShader.Shader()
root = get_root()
mobject = sshader.get_mobject(root)
input_data = sshader.get_source_image_data(mobject)
if not input_data:
return True, []
valid = {}
for node in input_data:
for attribute in input_data[node]:
source_image = input_data[node][attribute]['value']
if not os.path.isfile(source_image):
valid.setdefault(False, []).append([node, source_image])
continue
valid.setdefault(True, []).append([node, source_image])
if False in valid:
return False, valid[False]
return True, valid[True]
def check_default_shader_geometries():
from maya import OpenMaya
from studio_usd_pipe.api import studioShader
sshader = studioShader.Shader()
root = get_root()
mobject = sshader.get_mobject(root)
shader_data = sshader.get_scene_shading_engines(mobject)
geometries = []
for geometry, shader_engines in shader_data.items():
if not shader_engines:
continue
for index in range(shader_engines.length()):
mfn_dependency_node = OpenMaya.MFnDependencyNode(
shader_engines[index])
if mfn_dependency_node.name() != 'initialShadingGroup':
continue
if geometry.fullPathName() in geometries:
continue
geometries.append(geometry.fullPathName())
if geometries:
return False, list(
geometries), 'found geometries with default shader assignment'
return True, [], 'all geometries are user assigned shader'
