def createIDPNode(key, out = None):
#创建IDP材质组合
#
#参数out: 属性输出给哪个节点, 连接属性
#
#创建节点
if ARNOLD_IDP_TYPE.has_key(key):
try:
idp_shader = pm.PyNode(key)
SG = pm.PyNode('{0}SG'.format(key))
except:
idp_shader, SG = pm.createSurfaceShader('aiStandard', name = key)
idp_shader.aiEnableMatte.set(1)
aiMatteColor = ARNOLD_IDP_TYPE[key][0]
aiMatteColorA = ARNOLD_IDP_TYPE[key][1]
diffColor = ARNOLD_IDP_TYPE[key][2]
idp_shader.aiMatteColor.set(aiMatteColor)
idp_shader.aiMatteColorA.set(aiMatteColorA)
idp_shader.color.set(diffColor)
else :
return False
if out:
idp_shader.outColor >> out
else :
pass
return idp_shader, SG
def NSphere(self):
shaderName = self._baseName + '_mtl'
crv = pm.sphere(r=self.radius, n=self.name)
#### set invisible to render
crvShape = crv[0].getShape()
crvShape.castsShadows.set(False)
crvShape.receiveShadows.set(False)
crvShape.motionBlur.set(False)
crvShape.primaryVisibility.set(False)
crvShape.smoothShading.set(False)
crvShape.visibleInReflections.set(False)
crvShape.visibleInRefractions.set(False)
crvShape.doubleSided.set(False)
#### set Shader
shdr_name = '{}_{}'.format(shaderName, self.name)
sg_name = '{}{}'.format(shdr_name, 'SG')
if pm.objExists(shdr_name) or pm.objExists(sg_name):
try:
pm.delete(shdr_name)
pm.delete(sg_name)
except:
pass
shdr, sg = pm.createSurfaceShader('surfaceShader')
pm.rename(shdr, shdr_name)
pm.rename(sg, sg_name)
shdr.outColor.set(self.color.rgb)
shdr.outTransparency.set([self.color.a for i in range(3)])
pm.sets(sg, fe=crv[0])
return crv[0]
def create_dominant_color_shader(dag, tex_name_surfix=['co', 'color', 'diffuse', 'dif', 'base'],
sample_rate=None, max_auto_sample=50,
default_shader='aiStandardSurface', default_channel='baseColor'):
"""
Create an auto average-color lambert shader and assign it to input object.
Maybe does not work with TIFF texture ( cannot extract color ).
"""
if type(dag) == pm.nodetypes.Transform:
mesh = dag.getShape()
if not type(mesh) == pm.nodetypes.Mesh:
return None
elif type(dag) == pm.nodetypes.Mesh:
mesh = dag
else:
return None
avg_color = _detect_dominant_color(mesh, tex_name_surfix, sample_rate,
max_auto_sample, default_shader, default_channel)
if not avg_color:
return None
color_shader, sg = pm.createSurfaceShader('lambert')
color_shader.color.set(avg_color)
pm.connectAttr(color_shader.color, sg.surfaceShader, f=1)
pm.sets(sg, forceElement=mesh)
return color_shader
def createFresnel(out = None):
#创建菲涅尔节点组合
#
#参数out: 属性输出给哪个节点, 连接属性
#
#创建节点
samplerInfo = pm.createNode('samplerInfo', name = 'Fre_samplerInfo_arnold')
ramp = pm.createNode('ramp', name = 'Fre_ramp_arnold')
aiUtility, SG = pm.createSurfaceShader('aiUtility', name = 'Fresnel_arnold')
#修改属性
ramp.interpolation.set("Exponential Down")
ramp.colorEntryList[2].remove(b=1)
ramp.colorEntryList[1].position.set(1)
ramp.colorEntryList[0].color.set(1,1,1)
ramp.colorEntryList[1].color.set(0,0,0)
aiUtility.shadeMode.set(2)
#链接属性
samplerInfo.facingRatio >> ramp.uvCoord.uCoord
samplerInfo.facingRatio >> ramp.uvCoord.vCoord
ramp.outColor >> aiUtility.color
if out :
aiUtility.outColor >> out
else :
pass
return aiUtility, SG
def createZ(out = None):
#创建Z通道节点组合
#
#参数out: 属性输出给哪个节点, 连接属性
#
#创建节点
samplerInfo = pm.createNode('samplerInfo', name = 'z_samplerInfo_arnold')
multiplyDivide = pm.createNode('multiplyDivide', name = 'z_multiplyDivide_arnold')
setRange = pm.createNode('setRange', name = 'z_setRange_arnold')
aiUtility, SG = pm.createSurfaceShader('aiUtility', name = 'zdp_arnold')
#修改属性
multiplyDivide.input2X.set(-1)
setRange.minX.set(1)
setRange.oldMinX.set(0.1)
setRange.oldMaxX.set(500)
aiUtility.shadeMode.set(2)
#属性链接
samplerInfo.pointCameraZ >> multiplyDivide.input1X
multiplyDivide.outputX >> setRange.valueX
setRange.message >> aiUtility.colorR
setRange.message >> aiUtility.colorG
setRange.message >> aiUtility.colorB
if out :
aiUtility.outColor >> out
else :
pass
return aiUtility, SG
def useVRayMtl(currentPage, texture1):
shdr, sg = pm.createSurfaceShader( 'VRayMtl', currentPage[0]+"_shdr" )
pm.sets( sg, forceElement=currentPage )
filenode = pm.createNode('file', name=currentPage[0]+"_file")
filenode.fileTextureName.set(texture1)
pm.connectAttr( filenode+".outColor", shdr.color , force=1)
placement = pm.shadingNode('place2dTexture', asUtility=1, name='placeTextureName')
pm.connectAttr(placement.outUV, filenode.uvCoord, f=1)
pm.connectAttr(placement.outUvFilterSize, filenode.uvFilterSize, f=1)
pm.connectAttr(placement.coverage, filenode.coverage, f=1)
pm.connectAttr(placement.translateFrame, filenode.translateFrame, f=1)
pm.connectAttr(placement.rotateFrame, filenode.rotateFrame, f=1)
pm.connectAttr(placement.mirrorU, filenode.mirrorU, f=1)
pm.connectAttr(placement.mirrorV, filenode.mirrorV, f=1)
pm.connectAttr(placement.stagger, filenode.stagger, f=1)
pm.connectAttr(placement.wrapU, filenode.wrapU, f=1)
pm.connectAttr(placement.wrapV, filenode.wrapV, f=1)
pm.connectAttr(placement.repeatUV, filenode.repeatUV, f=1)
pm.connectAttr(placement.vertexUvOne, filenode.vertexUvOne, f=1)
pm.connectAttr(placement.vertexUvTwo, filenode.vertexUvTwo, f=1)
pm.connectAttr(placement.vertexUvThree, filenode.vertexUvThree, f=1)
pm.connectAttr(placement.vertexCameraOne, filenode.vertexCameraOne, f=1)
pm.connectAttr(placement.noiseUV, filenode.noiseUV, f=1)
pm.connectAttr(placement.offset, filenode.offset, f=1)
pm.connectAttr(placement.rotateUV, filenode.rotateUV, f=1)
pm.setAttr(placement.rotateFrame, 90)
pm.setAttr(placement.repeatU, -1)
def __init__(self, folder):
self.folder = folder
super(InstantLambert, self).__init__()
self.mapDict = {
'Bump': '',
'Norm': '',
'Disp': '',
'Color': '',
'Incd': '',
'SpeC': '',
'Tran': '',
'AmbC': '',
'RefC': ''
}
self.cmapAttr = {
'Color': 'color',
'Incd': 'incandescence',
'SpeC': 'specularColor',
'Tran': 'transparency',
'AmbC': 'ambientColor',
'RefC': 'reflectedColor'
}
self.createdShader = pm.createSurfaceShader('lambert', name=self.name)
self.processFolder()
for item in self.filenodes:
print item
self.connectFileNodes(item)
self.applyShader()
def createShader(shaderType='lambert', name=''):
shdr, sg = pm.createSurfaceShader(shaderType, name
return shdr, sg
def createFileTexture():
pass
def connectFileTextureToVRayMtl():
pass
def connectVRayMtlToVRayMtl2Sided():
pass
def assignShader(shadingGroup=None, objects=None):
# assign selection to the shader
print "###########"
if objects is None:
objects = pm.ls(sl=True, l=True)
for obj in objects:
try:
print obj,
pm.sets(i, e=True, forceElement=shadingGroup)
except:
pass
'''
def __init__(self, dnaPartInst, htype=LatticeType.Honeycomb, controller=None, parent=None):
"""
Parameters
----------
rows: rows grid size
cols: columns grid size
See Also
--------
Examples
--------
"""
super(SolidHelixGroup, self).__init__()
self.number_hash = {}
self.type = htype
self.helix_diameter = 2.0
self.pointscale = self.helix_diameter/(2*styles.SLICE_HELIX_RADIUS)
# initialize the column direction stuff
self.column_dir = X
self.row_dir = Y
self.helix_dir = Z
# the limits of the indices of the output raster
self.row_count = 0
self.column_count = 0
self.helix_count = 0
self.h_axis = 'Z'
self.row_axis = 'Y'
# initialize the unit size of a base cell
self.drow = 0 # the row direction
self.dcolumn = 0 # the direction normal to the row direction and the helical axis
self.dhelix = 0 # the helical axis
self.model_scale = 1
self.unit_scale = 2
self.N_bases = 1
self.N_bases_default = 3
# set up the above parameters
self.calculateParameters()
print "maya group created"
self.group = pc.general.group(em=True,name='helixgroup0')
# the coloring of the cylinders is set here
shdr, sg = pc.createSurfaceShader( 'blinn' )
self.colorshader = sg
colorfill = styles.orangefill
# maya takes RGB component values from 0 to 1
shdr.setAttr('color', colorfill.redF(),colorfill.greenF(),colorfill.blueF(), type='double3')
print pc.language.scriptJob( event=[u'SelectionChanged',self.cool])
def test_conversion_of_ai_standard_to_red_shift_material_created(self):
"""test conversion of aiStandard material
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# check if the material is created
self.assertIsInstance(rs_material, pm.nt.RedshiftMaterial)
def create(self):
"""creates the node
"""
node_type = self.specs.get('node_type')
secondary_type = self.specs.get('secondary_type')
if secondary_type == 'shader':
shader, shading_engine = pm.createSurfaceShader(node_type)
return shader
elif secondary_type == 'light':
light_transform = pm.shadingNode(node_type, asLight=1)
return light_transform.getShape()
def test_conversion_of_ai_standard_to_red_shift_material_sss_properties(
self):
"""test conversion of aiStandard material to RedshiftMaterial sss
properties
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
ms_color0 = (1, 0.5, 0)
ms_amount = 0.532
ms_radius0 = 1.434
emission_color = (0.57, 0.34, 0.54)
emission_weight = 0.5
ai_standard.KsssColor.set(ms_color0)
ai_standard.Ksss.set(ms_amount)
ai_standard.sssRadius.set([ms_radius0, ms_radius0, ms_radius0])
ai_standard.emissionColor.set(emission_color)
ai_standard.emission.set(emission_weight)
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
self.assertAlmostEqual(rs_material.ms_color0.get()[0],
ms_color0[0],
places=3)
self.assertAlmostEqual(rs_material.ms_color0.get()[1],
ms_color0[1],
places=3)
self.assertAlmostEqual(rs_material.ms_color0.get()[2],
ms_color0[2],
places=3)
self.assertAlmostEqual(rs_material.ms_amount.get(),
ms_amount,
places=3)
self.assertAlmostEqual(rs_material.ms_radius0.get(),
ms_radius0,
places=3)
self.assertAlmostEqual(rs_material.emission_color.get()[0],
emission_color[0],
places=3)
self.assertAlmostEqual(rs_material.emission_color.get()[1],
emission_color[1],
places=3)
self.assertAlmostEqual(rs_material.emission_color.get()[2],
emission_color[2],
places=3)
self.assertAlmostEqual(rs_material.emission_weight.get(),
emission_weight,
places=3)
def test_conversion_of_ai_standard_to_red_shift_material_sss_properties(self):
"""test conversion of aiStandard material to RedshiftMaterial sss
properties
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
ms_color0 = (1, 0.5, 0)
ms_amount = 0.532
ms_radius0 = 1.434
emission_color = (0.57, 0.34, 0.54)
emission_weight = 0.5
ai_standard.KsssColor.set(ms_color0)
ai_standard.Ksss.set(ms_amount)
ai_standard.sssRadius.set([ms_radius0, ms_radius0, ms_radius0])
ai_standard.emissionColor.set(emission_color)
ai_standard.emission.set(emission_weight)
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
self.assertAlmostEqual(
rs_material.ms_color0.get()[0], ms_color0[0], places=3
)
self.assertAlmostEqual(
rs_material.ms_color0.get()[1], ms_color0[1], places=3
)
self.assertAlmostEqual(
rs_material.ms_color0.get()[2], ms_color0[2], places=3
)
self.assertAlmostEqual(
rs_material.ms_amount.get(), ms_amount, places=3
)
self.assertAlmostEqual(
rs_material.ms_radius0.get(), ms_radius0, places=3
)
self.assertAlmostEqual(
rs_material.emission_color.get()[0], emission_color[0], places=3
)
self.assertAlmostEqual(
rs_material.emission_color.get()[1], emission_color[1], places=3
)
self.assertAlmostEqual(
rs_material.emission_color.get()[2], emission_color[2], places=3
)
self.assertAlmostEqual(
rs_material.emission_weight.get(), emission_weight, places=3
)
def delAllShaders(geos):
# 删除所有材质球
#
# 参数geos: 模型对象
try:
defaultShader = pm.PyNode("lambert1")
defaultSG = pm.PyNode("initialShadingGroup")
except:
defaultShader, defaultSG = pm.createSurfaceShader("lambert", name="lambert1")
pm.waitCursor(state=1)
pm.sets(defaultSG, forceElement=geos)
pm.mel.MLdeleteUnused()
pm.waitCursor(state=0)
def test_conversion_of_ai_standard_to_red_shift_material_created(self):
"""test conversion of aiStandard material
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# check if the material is created
self.assertIsInstance(
rs_material, pm.nt.RedshiftMaterial
)
def delAllShaders(geos):
#删除所有材质球
#
#参数geos: 模型对象
try:
defaultShader = pm.PyNode("lambert1")
defaultSG = pm.PyNode("initialShadingGroup")
except:
defaultShader, defaultSG = pm.createSurfaceShader('lambert',
name='lambert1')
pm.waitCursor(state=1)
pm.sets(defaultSG, forceElement=geos)
pm.mel.MLdeleteUnused()
pm.waitCursor(state=0)
def createRGBlight(out = None):
#创建RGBlight材质组合
#
#参数out: 属性输出给哪个节点, 连接属性
#
#创建节点
RGBlight_shader, SG = pm.createSurfaceShader("aiUtility", name = "RGBlight_arnold")
RGBlight_shader.shadeMode.set(1)
if out :
RGBlight_shader.outColor >> out
else :
pass
return RGBlight_shader, SG
def create(self):
"""creates the node
"""
node_type = self.specs.get('node_type')
secondary_type = self.specs.get('secondary_type')
if secondary_type == 'shader':
shader, shading_engine = pm.createSurfaceShader(node_type)
return shader
if secondary_type == 'utility':
shader = pm.shadingNode(node_type, asUtility=1)
return shader
elif secondary_type == 'light':
light_transform = pm.shadingNode(node_type, asLight=1)
return light_transform.getShape()
def createFOGlight(out = None):
#创建FOGlight材质组合
#
#参数out: 属性输出给哪个节点, 连接属性
#
#创建节点
FOGlight_arnold, SG = pm.createSurfaceShader("aiStandard", name = "FOGlight_arnold")
FOGlight_arnold.aiEnableMatte.set(1)
FOGlight_arnold.color.set(0,0,0)
if out :
FOGlight_arnold.outColor >> out
else :
pass
return FOGlight_arnold, SG
def createShadow(out = None):
#创建shadow材质组合
#
#参数out: 属性输出给哪个节点, 连接属性
#
#创建节点
shadow_shader, SG = pm.createSurfaceShader("aiShadowCatcher", name = "shadow_arnold")
shadow_shader.shadowColor.set(1,1,1)
shadow_shader.hardwareColor.set(0,1,0)
if out :
shadow_shader.outColor >> out
else :
pass
return shadow_shader, SG
def createCOCC(out = None):
#创建AO材质球
#
#参数out: 属性输出给哪个节点, 连接属性
#
#创建节点
aiAO, SG = pm.createSurfaceShader('aiAmbientOcclusion', name = 'cocc_arnold')
#修改属性
aiAO.samples.set(5)
if out :
aiAO.outColor >> out
else :
pass
return aiAO, SG
def create_shader(type='PxrSurface'):
"""
Create shaders and shading groups.
Kwargs:
type (str): type of material shader to create, for ie 'blinn'
tag (str): tag to set in ATTR_MATERIAL, usually the
surfacing project or surfacing object
Returns:
tuple. PyNode shader, and PyNode shading_group
"""
shader, shading_group = pm.createSurfaceShader(type)
pm.setAttr('%s.%s' % (shading_group, ATTR_MATERIAL), '', force=True)
pm.setAttr('%s.%s' % (shading_group, ATTR_MATERIAL_ASSIGN), '', force=True)
pm.setAttr('%s.%s' % (shading_group, ATTR_MATERIAL_VP), '', force=True)
return shader, shading_group
def prePressCmd() :
print "***prePressCmd***"
tools.deltemp()
global cvList
cvList = []
global post
post = om2.MPoint(0.0,0.0,0.0)
# 可視ライン用のシェーダを用意
if not pm.objExists("projection_line_shader") :
global shadingEngine
myShader , shadingEngine = pm.createSurfaceShader("surfaceShader")
pm.rename(myShader, "projection_line_shader")
else :
print "すでにライン用シェーダが存在します。"
myShader = pm.PyNode("projection_line_shader")
shadingEngine = pm.listConnections(myShader, t='shadingEngine')[0]
def createNOM(out = None):
#创建NOM材质球
#
#参数out: 属性输出给哪个节点, 连接属性
#
#创建节点
aiUtility, SG = pm.createSurfaceShader('aiUtility', name = 'nom_arnold')
#修改属性
aiUtility.shadeMode.set(2)
aiUtility.colorMode.set(3)
if out:
aiUtility.outColor >> out
else :
pass
return aiUtility, SG
def show_sketch(myface, cam=None, cur=None, overwrite=True, name =None):
print "スケッチの複製を前に出して見えるようにします．"
if not cur : cur = myface.curve
if not name : name = "curveshow"
if overwrite :
if pm.objExists(name) :
c = pm.PyNode(name)
pm.delete(c)
print "n"
cur = pm.duplicate(cur, n = name)[0]
print "n"
if not cam : cam = pm.PyNode(tools.getCamFromModelPanel())
campos = pm.getAttr(cam.translate)
print cur
for p in cur.cv :
ppos = pm.pointPosition(p)
newpos = ppos + (campos - ppos) * 0.1
pm.move(p, newpos)
pm.select(cur)
# レンダリング用のシェーダを設定
pm.setAttr(cur.aiRenderCurve,True)
pm.setAttr(cur.aiCurveWidth, 0.2)
# シェーダを確認
if not pm.objExists("ai_line_shader") :
global shadingEngine
myShader , shadingEngine = pm.createSurfaceShader("aiFlat")
pm.rename(myShader, "ai_line_shader")
else :
print "すでにライン用シェーダが存在します。"
myShader = pm.PyNode("ai_line_shader")
pm.setAttr(myShader.color, (1,0,0))
pm.connectAttr(myShader.outColor, cur.aiCurveShader)
pm.select(cur)
def test_conversion_of_ai_standard_to_red_shift_material_diffuse_properties(
self):
"""test conversion of aiStandard material to RedshiftMaterial diffuse
properties
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
diffuse_color = (1, 0.5, 0)
diffuse_weight = 0.532
diffuse_roughness = 0.8
transl_weight = 0.25
diffuse_direct = 0.95
diffuse_indirect = 0.89
ai_standard.color.set(diffuse_color)
ai_standard.Kd.set(diffuse_weight)
ai_standard.diffuseRoughness.set(diffuse_roughness)
ai_standard.Kb.set(transl_weight)
ai_standard.directDiffuse.set(diffuse_direct)
ai_standard.indirectDiffuse.set(diffuse_indirect)
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# check diffuse properties
self.assertAlmostEqual(rs_material.diffuse_color.get(),
diffuse_color,
places=3)
self.assertAlmostEqual(rs_material.diffuse_weight.get(),
diffuse_weight,
places=3)
self.assertAlmostEqual(rs_material.diffuse_roughness.get(),
diffuse_roughness,
places=3)
self.assertAlmostEqual(rs_material.transl_weight.get(),
transl_weight,
places=3)
self.assertAlmostEqual(rs_material.diffuse_direct.get(),
diffuse_direct,
places=3)
self.assertAlmostEqual(rs_material.diffuse_indirect.get(),
diffuse_indirect,
places=3)
def test_conversion_of_ai_standard_to_red_shift_material_diffuse_properties(self):
"""test conversion of aiStandard material to RedshiftMaterial diffuse
properties
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
diffuse_color = (1, 0.5, 0)
diffuse_weight = 0.532
diffuse_roughness = 0.8
transl_weight = 0.25
diffuse_direct = 0.95
diffuse_indirect = 0.89
ai_standard.color.set(diffuse_color)
ai_standard.Kd.set(diffuse_weight)
ai_standard.diffuseRoughness.set(diffuse_roughness)
ai_standard.Kb.set(transl_weight)
ai_standard.directDiffuse.set(diffuse_direct)
ai_standard.indirectDiffuse.set(diffuse_indirect)
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# check diffuse properties
self.assertAlmostEqual(
rs_material.diffuse_color.get(), diffuse_color, places=3
)
self.assertAlmostEqual(
rs_material.diffuse_weight.get(), diffuse_weight, places=3
)
self.assertAlmostEqual(
rs_material.diffuse_roughness.get(), diffuse_roughness, places=3
)
self.assertAlmostEqual(
rs_material.transl_weight.get(), transl_weight, places=3
)
self.assertAlmostEqual(
rs_material.diffuse_direct.get(), diffuse_direct, places=3
)
self.assertAlmostEqual(
rs_material.diffuse_indirect.get(), diffuse_indirect, places=3
)
def createCamSolidBG( camera=None ):
'''
카메라 백으로 사용할 솔리드한 Plane을 세움,
카메라 이름을 명시하거나, 모델패털을 포커스한 상태에서 실행.
Version : 2015-02-24
>>> camSolidBG()
(nt.Transform(u'persp_camSolidBG_grp'), nt.Transform(u'persp_camSolidBG_mesh'), nt.SurfaceShader(u'persp_camSolidBG_surfaceShader'), nt.ShadingEngine(u'persp_camSolidBG_SG'))
>>> camSolidBG( camera='side' )
(nt.Transform(u'side_camSolidBG_grp'), nt.Transform(u'side_camSolidBG_mesh'), nt.SurfaceShader(u'side_camSolidBG_surfaceShader'), nt.ShadingEngine(u'side_camSolidBG_SG'))
'''
if not camera:
camera = pm.modelPanel( pm.playblast(activeEditor=True).split('|')[-1], q=True, camera=True )
mesh = pm.polyPlane(sh=1, sw=1, ch=False)[0]
grp = pm.group()
pm.parentConstraint(camera, grp)
mesh.t.set(0,0,-500)
mesh.r.set(90,0,0)
mesh.s.set(150,150,150)
shader, SG = pm.createSurfaceShader('surfaceShader')
shader.outColor.set(0.5,0.5,0.5)
pm.select(mesh)
pm.hyperShade(assign=shader)
mesh.castsShadows.set(False)
mesh.receiveShadows.set(False)
mesh.motionBlur.set(False)
mesh.smoothShading.set(False)
mesh.visibleInReflections.set(False)
mesh.visibleInRefractions.set(False)
grp. rename('%s_camSolidBG_grp' % camera)
mesh. rename('%s_camSolidBG_mesh' % camera)
shader.rename('%s_camSolidBG_surfaceShader' % camera)
SG. rename('%s_camSolidBG_SG' % camera)
return grp, mesh, shader, SG
def test_conversion_of_ai_standard_to_red_shift_material_channels_with_textures(
self):
"""test conversion of aiStandard material to RedshiftMaterial channels
with textures
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
# create a diffuse texture
file_node = pm.shadingNode('file', asTexture=1)
file_node.outColor >> ai_standard.color
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# now expect the corresponding channel to also have the same connection
# from the file_node
self.assertIn(file_node, rs_material.diffuse_color.inputs())
def __init__(self, folder):
self.folder = folder
super(InstantaiStandardSurface, self).__init__()
self.mapDict = {
'DifC': '',
'DifR': '',
'Metl': '',
'SpeC': '',
'TraC': '',
'SubC': '',
'CoaC': '',
'CoaR': '',
'EmiC': '',
'EmiW': '',
'Opac': '',
'Bump': '',
'Norm': '',
'Disp': ''
}
self.cmapAttr = {
'DifC': 'baseColor',
'DifR': 'diffuseRoughness',
'Metl': 'metalness',
'SpeC': 'specularColor',
'TraC': 'transmissionColor',
'SubC': 'subsurfaceColor',
'CoaC': 'coatColor',
'CoaR': 'coatRoughness',
'EmiC': 'emissionColor',
'EmiW': 'emission',
'Opac': 'opacity'
}
self.createdShader = pm.createSurfaceShader('aiStandardSurface',
name=self.name)
self.processFolder()
for item in self.filenodes:
print item
self.connectFileNodes(item)
self.applyShader()
def test_conversion_of_ai_standard_to_red_shift_material_channels_with_textures(self):
"""test conversion of aiStandard material to RedshiftMaterial channels
with textures
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
# create a diffuse texture
file_node = pm.shadingNode('file', asTexture=1)
file_node.outColor >> ai_standard.color
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# now expect the corresponding channel to also have the same connection
# from the file_node
self.assertIn(
file_node,
rs_material.diffuse_color.inputs()
)
def test_conversion_of_ai_standard_to_red_shift_material_bump_properties(
self):
"""test conversion of aiStandard material to RedshiftMaterial channels
with textures
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
# create a diffuse texture
file_node = pm.shadingNode('file', asTexture=1)
bump2d_node = pm.shadingNode('bump2d', asUtility=1)
file_node.outAlpha >> bump2d_node.bumpValue
bump2d_node.outNormal >> ai_standard.normalCamera
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# now expect the corresponding channel to also have the same connection
# from the file_node
self.assertIn(bump2d_node, rs_material.bump_input.inputs())
def test_conversion_of_ai_standard_to_red_shift_material_bump_properties(self):
"""test conversion of aiStandard material to RedshiftMaterial channels
with textures
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
# create a diffuse texture
file_node = pm.shadingNode('file', asTexture=1)
bump2d_node = pm.shadingNode('bump2d', asUtility=1)
file_node.outAlpha >> bump2d_node.bumpValue
bump2d_node.outNormal >> ai_standard.normalCamera
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# now expect the corresponding channel to also have the same connection
# from the file_node
self.assertIn(
bump2d_node,
rs_material.bump_input.inputs()
)
def create_fac_ctl_shader():
fac_shadeGP = {
'green': (
[0,0.18,0,0.8],
['eyeLeftA_ctl',
'eyeLeftB_ctl',
'eyeLeftC_ctl',
'eyeLeftD_ctl',
'cheekLeftA_ctl',
'cheekLeftC_ctl',
'lipCenterA_ctl',
'lipCenterB_ctl',
'eyeRightA_ctl',
'eyeRightB_ctl',
'eyeRightC_ctl',
'eyeRightD_ctl',
'cheekRightA_ctl',
'cheekRightC_ctl']),
'blue': (
[0,0,0.4,0.6],
['eyebrowLeftA_ctl',
'eyebrowLeftC_ctl',
'lipLeftB_ctl',
'noseTop_ctl',
'eyebrowRightA_ctl',
'eyebrowRightC_ctl',
'lipRightB_ctl']),
'red': (
[0.24,0.028,0,0.75],
['eyebrowLeftB_ctl',
'eyeSubLeftC_ctl',
'eyeSubLeftD_ctl',
'lipLeftC_ctl',
'eyebrowRightB_ctl',
'eyeSubRightC_ctl',
'eyeSubRightD_ctl',
'lipRightC_ctl']),
'cyan':(
[0,0.193,0.193,0.8],
['eyeSubLeftA_ctl',
'eyeSubLeftB_ctl',
'noseLeftA_ctl',
'cheekLeftB_ctl',
'lipLeftA_ctl',
'eyeSubRightA_ctl',
'eyeSubRightB_ctl',
'noseRightA_ctl',
'cheekRightB_ctl',
'lipRightA_ctl'])}
for shader, (color,members) in fac_shadeGP.items():
shdr_name = 'fac_mtl_{}'.format(shader)
sg_name = '{}{}'.format(shdr_name,'SG')
if pm.objExists(shdr_name) or pm.objExists(sg_name):
try:
pm.delete(shdr_name)
pm.delete(sg_name)
except:
pass
shdr,sg = pm.createSurfaceShader('surfaceShader')
pm.rename(shdr,'fac_mtl_{}'.format(shader))
pm.rename(sg,'{}{}'.format(shdr.name(),'SG'))
shdr.outColor.set(color[:3])
shdr.outTransparency.set([color[-1],color[-1],color[-1]])
for member in members:
member = ul.get_node(member)
pm.sets(sg, fe=member)
def create_material(type_, name, **defaults):
'''Create and set default values for a shader node'''
mtl, sg = pmc.createSurfaceShader(type_, name=name)
set_attributes(mtl, **defaults)
return mtl, sg
def apply_spriteShader(self, options):
self.nparticle.aiOpaque.set(False)
# Append these three attribute to nparticle's aiExportAttributes as Default
parAttr_default = ["rgbPP", "opacityPP", "twistPP"]
parAttr_export = self.nparticle.aiExportAttributes.get().split()
for attr in parAttr_default:
if attr not in parAttr_export:
parAttr_export.append(attr)
self.nparticle.aiExportAttributes.set(" ".join(parAttr_export))
pre_name = str(self.nparticle)
ramp_color_name = "%s_color_ramp" % pre_name
ramp_opacity_name = "%s_opacity_ramp" % pre_name
ramp_color = None
ramp_opacity = None
if len(options["sequence"]):
shader, shader_group = pc.createSurfaceShader("aiStandard",
name="%s_shader" %
pre_name)
aiUserDataFloat = pc.shadingNode("aiUserDataFloat", asShader=True)
aiUserDataFloat.floatAttrName.set("spriteNumPP")
ramp_opacity = pc.shadingNode("ramp",
asTexture=True,
name=ramp_opacity_name)
ramp_opacity.interpolation.set(0)
ramp_opacity.colorEntryList[0].position.set(0)
ramp_opacity.outColor.connect(shader.opacity, f=True)
aiUserDataFloat.outValue.connect(ramp_opacity.uvCoord.vCoord,
f=True)
if options["use_as_color"]:
ramp_color = pc.shadingNode("ramp",
asTexture=True,
name=ramp_color_name)
ramp_color.interpolation.set(0)
ramp_color.colorEntryList[0].position.set(0)
ramp_color.outColor.connect(shader.color, f=True)
aiUserDataFloat.outValue.connect(ramp_color.uvCoord.vCoord,
f=True)
texPlacement = pc.shadingNode("place2dTexture", asUtility=True)
texPlacement.wrapU.set(0)
texPlacement.wrapV.set(0)
for i in range(len(options["sequence"])):
texFile = pc.shadingNode("file", asTexture=True)
texFile.fileTextureName.set(options["sequence"][i])
ConnectPlace2DTexture(texFile, texPlacement)
texFile.outTransparency.connect(
ramp_opacity.colorEntryList[i].color, f=True)
ramp_opacity.colorEntryList[i].position.set(
float(i) / len(options["sequence"]))
if options["use_as_color"]:
texFile.outColor.connect(
ramp_color.colorEntryList[i].color, f=True)
ramp_color.colorEntryList[i].position.set(
float(i) / len(options["sequence"]))
# If to use rgbPP
if options["use_rgbPP"]:
aiUserDataColor = pc.shadingNode("aiUserDataColor",
asShader=True)
aiUserDataColor.colorAttrName.set("rgbPP")
# If ramp_color had connected to shader's color
if ramp_color:
aiUserDataColor.outColor.connect(ramp_color.colorGain,
f=True)
else:
aiUserDataColor.outColor.connect(shader.color, f=True)
# If to use opacityPP
if options["use_opacityPP"]:
aiUserDataOpacity = pc.shadingNode("aiUserDataColor",
asShader=True)
aiUserDataOpacity.colorAttrName.set("opacityPP")
# If ramp_opacity had connected to shader's opacity
if ramp_opacity:
aiUserDataOpacity.outColor.connect(ramp_opacity.colorGain,
f=True)
else:
aiUserDataOpacity.outColor.connect(shader.opacity, f=True)
# If to use spriteTwistPP
if options["use_twistPP"]:
aiUserDataTwist = pc.shadingNode("aiUserDataFloat",
asShader=True)
aiUserDataTwist.floatAttrName.set("spriteTwistPP")
aiUserDataTwist.message.connect(texPlacement.rotateFrame,
f=True)
pc.sets(shader_group, forceElement=self.nparticle)
def test_conversion_of_ai_standard_to_red_shift_material_specular_properties(self):
"""test conversion of aiStandard material to RedshiftMaterial specular
properties
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
refl_color = (1, 0.5, 0)
refl_weight = 0.532
refl_roughness = 0.8
refl_aniso = 0.25
refl_aniso_rotation = 0.5
refl_brdf = 1
refl_fresnel_mode = 1
refl_reflectivity = 0.01
refl_direct = 0.95
refl_indirect = 0.89
ai_standard.KsColor.set(refl_color)
ai_standard.Ks.set(refl_weight)
ai_standard.specularRoughness.set(refl_roughness)
ai_standard.specularAnisotropy.set(refl_aniso)
ai_standard.specularRotation.set(refl_aniso_rotation)
ai_standard.specularDistribution.set(refl_brdf)
ai_standard.specularFresnel.set(refl_fresnel_mode)
ai_standard.Ksn.set(refl_reflectivity)
ai_standard.directSpecular.set(refl_direct)
ai_standard.indirectSpecular.set(refl_indirect)
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# check specular properties
self.assertAlmostEqual(
rs_material.refl_color.get(), refl_color, places=3
)
self.assertAlmostEqual(
rs_material.refl_weight.get(), refl_weight, places=3
)
self.assertAlmostEqual(
rs_material.refl_roughness.get(), refl_roughness, places=3
)
self.assertAlmostEqual(
rs_material.refl_aniso.get(), -0.5, places=3
)
self.assertAlmostEqual(
rs_material.refl_reflectivity.get()[0], refl_reflectivity, places=3
)
self.assertAlmostEqual(
rs_material.refl_reflectivity.get()[1], refl_reflectivity, places=3
)
self.assertAlmostEqual(
rs_material.refl_reflectivity.get()[2], refl_reflectivity, places=3
)
self.assertEqual(
rs_material.refl_edge_tint.get(), (1, 1, 1)
)
self.assertAlmostEqual(
rs_material.refl_direct.get(), refl_direct, places=3
)
self.assertAlmostEqual(
rs_material.refl_indirect.get(), refl_indirect, places=3
)
def test_conversion_of_ai_standard_to_red_shift_material_refraction_properties(self):
"""test conversion of aiStandard material to RedshiftMaterial
refraction properties
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
refr_color = (1, 0.5, 0)
refr_weight = 0.532
refr_ior = 1.434
refr_abbe = 29.942196
refr_roughness = 0.8
refr_transmittance = (0.57, 0.34, 0.54)
opacity_color = (0.5, 0.87, 0.12)
ai_standard.KtColor.set(refr_color)
ai_standard.Kt.set(refr_weight)
ai_standard.FresnelUseIOR.set(0)
ai_standard.IOR.set(refr_ior)
ai_standard.dispersionAbbe.set(refr_abbe)
ai_standard.refractionRoughness.set(refr_roughness)
ai_standard.transmittance.set(refr_transmittance)
ai_standard.opacity.set(opacity_color)
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
self.assertAlmostEqual(
rs_material.refr_color.get()[0], refr_color[0], places=3
)
self.assertAlmostEqual(
rs_material.refr_color.get()[1], refr_color[1], places=3
)
self.assertAlmostEqual(
rs_material.refr_color.get()[2], refr_color[2], places=3
)
self.assertAlmostEqual(
rs_material.refr_weight.get(), refr_weight, places=3
)
self.assertAlmostEqual(rs_material.refr_ior.get(), refr_ior, places=3)
self.assertEqual(rs_material.refr_use_base_IOR.get(), 0)
self.assertAlmostEqual(
rs_material.refr_abbe.get(), refr_abbe, places=3
)
self.assertAlmostEqual(
rs_material.refr_roughness.get(), refr_roughness, places=3
)
self.assertAlmostEqual(
rs_material.refr_transmittance.get()[0], refr_transmittance[0],
places=3
)
self.assertAlmostEqual(
rs_material.refr_transmittance.get()[1], refr_transmittance[1],
places=3
)
self.assertAlmostEqual(
rs_material.refr_transmittance.get()[2], refr_transmittance[2],
places=3
)
self.assertAlmostEqual(
rs_material.opacity_color.get()[0], opacity_color[0], places=3
)
self.assertAlmostEqual(
rs_material.opacity_color.get()[1], opacity_color[1], places=3
)
self.assertAlmostEqual(
rs_material.opacity_color.get()[2], opacity_color[2], places=3
)
def test_conversion_of_ai_standard_to_red_shift_material_refraction_properties(
self):
"""test conversion of aiStandard material to RedshiftMaterial
refraction properties
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
refr_color = (1, 0.5, 0)
refr_weight = 0.532
refr_ior = 1.434
refr_abbe = 29.942196
refr_roughness = 0.8
refr_transmittance = (0.57, 0.34, 0.54)
opacity_color = (0.5, 0.87, 0.12)
ai_standard.KtColor.set(refr_color)
ai_standard.Kt.set(refr_weight)
ai_standard.FresnelUseIOR.set(0)
ai_standard.IOR.set(refr_ior)
ai_standard.dispersionAbbe.set(refr_abbe)
ai_standard.refractionRoughness.set(refr_roughness)
ai_standard.transmittance.set(refr_transmittance)
ai_standard.opacity.set(opacity_color)
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
self.assertAlmostEqual(rs_material.refr_color.get()[0],
refr_color[0],
places=3)
self.assertAlmostEqual(rs_material.refr_color.get()[1],
refr_color[1],
places=3)
self.assertAlmostEqual(rs_material.refr_color.get()[2],
refr_color[2],
places=3)
self.assertAlmostEqual(rs_material.refr_weight.get(),
refr_weight,
places=3)
self.assertAlmostEqual(rs_material.refr_ior.get(), refr_ior, places=3)
self.assertEqual(rs_material.refr_use_base_IOR.get(), 0)
self.assertAlmostEqual(rs_material.refr_abbe.get(),
refr_abbe,
places=3)
self.assertAlmostEqual(rs_material.refr_roughness.get(),
refr_roughness,
places=3)
self.assertAlmostEqual(rs_material.refr_transmittance.get()[0],
refr_transmittance[0],
places=3)
self.assertAlmostEqual(rs_material.refr_transmittance.get()[1],
refr_transmittance[1],
places=3)
self.assertAlmostEqual(rs_material.refr_transmittance.get()[2],
refr_transmittance[2],
places=3)
self.assertAlmostEqual(rs_material.opacity_color.get()[0],
opacity_color[0],
places=3)
self.assertAlmostEqual(rs_material.opacity_color.get()[1],
opacity_color[1],
places=3)
self.assertAlmostEqual(rs_material.opacity_color.get()[2],
opacity_color[2],
places=3)
def test_conversion_of_ai_standard_to_red_shift_material_specular_properties(
self):
"""test conversion of aiStandard material to RedshiftMaterial specular
properties
"""
# create one aiStandard material
ai_standard, ai_standardSG = pm.createSurfaceShader('aiStandard')
refl_color = (1, 0.5, 0)
refl_weight = 0.532
refl_roughness = 0.8
refl_aniso = 0.25
refl_aniso_rotation = 0.5
refl_brdf = 1
refl_fresnel_mode = 1
refl_reflectivity = 0.01
refl_direct = 0.95
refl_indirect = 0.89
ai_standard.KsColor.set(refl_color)
ai_standard.Ks.set(refl_weight)
ai_standard.specularRoughness.set(refl_roughness)
ai_standard.specularAnisotropy.set(refl_aniso)
ai_standard.specularRotation.set(refl_aniso_rotation)
ai_standard.specularDistribution.set(refl_brdf)
ai_standard.specularFresnel.set(refl_fresnel_mode)
ai_standard.Ksn.set(refl_reflectivity)
ai_standard.directSpecular.set(refl_direct)
ai_standard.indirectSpecular.set(refl_indirect)
conversion_man = ai2rs.ConversionManager()
rs_material = conversion_man.convert(ai_standard)
# check specular properties
self.assertAlmostEqual(rs_material.refl_color.get(),
refl_color,
places=3)
self.assertAlmostEqual(rs_material.refl_weight.get(),
refl_weight,
places=3)
self.assertAlmostEqual(rs_material.refl_roughness.get(),
refl_roughness,
places=3)
self.assertAlmostEqual(rs_material.refl_aniso.get(), -0.5, places=3)
self.assertAlmostEqual(rs_material.refl_reflectivity.get()[0],
refl_reflectivity,
places=3)
self.assertAlmostEqual(rs_material.refl_reflectivity.get()[1],
refl_reflectivity,
places=3)
self.assertAlmostEqual(rs_material.refl_reflectivity.get()[2],
refl_reflectivity,
places=3)
self.assertEqual(rs_material.refl_edge_tint.get(), (1, 1, 1))
self.assertAlmostEqual(rs_material.refl_direct.get(),
refl_direct,
places=3)
self.assertAlmostEqual(rs_material.refl_indirect.get(),
refl_indirect,
places=3)
