public static MFnDependencyNode CreateLayeredTextureNode(List <MFnDependencyNode> imageNodes)
{
//MFnDependencyNode layeredTextureNode = new MFnDependencyNode();
//layeredTextureNode.create("layeredTexture");
MFnDependencyNode layeredTextureNode = CreateShadingNode(ShadingNodeType.Utility, "layeredTexture");
MPlug layeredTexInputsPlug = layeredTextureNode.findPlug(ConstantValue.plugName_layeredTextureInputs);
//check place2DTextures
MDGModifier dGModifier = new MDGModifier();
for (int i = 0; i < imageNodes.Count; i++)
{
//place2dTexture setting
MFnDependencyNode p2dNode = GetPlace2dTextureForTex(imageNodes[i]);
p2dNode.findPlug("wrapU").setBool(false);
p2dNode.findPlug("translateFrameU").setFloat(i);
//set tex default color to 0
imageNodes[i].findPlug(ConstantValue.plugName_fileTexDefaultColorR).setFloat(0);
imageNodes[i].findPlug(ConstantValue.plugName_fileTexDefaultColorG).setFloat(0);
imageNodes[i].findPlug(ConstantValue.plugName_fileTexDefaultColorB).setFloat(0);
//move uv
MSelectionList matList = GetMaterialsWithTex(imageNodes[i]);
for (int j = 0; j < matList.length; j++)
{
MObject matObj = new MObject();
matList.getDependNode((uint)j, matObj);
string matName = new MFnDependencyNode(matObj).absoluteName;
Debug.Log("move uv for mat:" + matName);
MoveUV(i, 0, matName);
}
MPlug layeredTexInputPlug = layeredTexInputsPlug.elementByLogicalIndex((uint)i);
MPlug texOutColorPlug = imageNodes[i].findPlug(ConstantValue.plugName_fileTexOutputColor);
MPlug layeredTexInputColor = layeredTexInputPlug.child((int)ConstantValue.LayeredTextureInputDataIndex.Color);
dGModifier.connect(texOutColorPlug, layeredTexInputColor);
//set blendMode to add
MPlug blendMode = layeredTexInputPlug.child((int)ConstantValue.LayeredTextureInputDataIndex.BlendMode);
if (i < imageNodes.Count - 1)
{
blendMode.setInt((int)ConstantValue.LayeredTextureBlendMode.Add);
}
else
{
blendMode.setInt((int)ConstantValue.LayeredTextureBlendMode.None);
}
}
dGModifier.doIt();
return(layeredTextureNode);
}
public static float[] asFloatArray(this MPlug mPlug)
{
float[] array = new float[mPlug.numChildren];
for (uint index = 0; index < mPlug.numChildren; index++)
{
array[index] = mPlug.child(index).asFloat();
}
return(array);
}
// This function is a utility that can be used to extract vector values from
// plugs.
//
private MVector vectorPlugValue(MPlug plug)
{
if (plug.numChildren == 3)
{
double x, y, z;
MPlug rx = plug.child(0);
MPlug ry = plug.child(1);
MPlug rz = plug.child(2);
x = rx.asDouble();
y = ry.asDouble();
z = rz.asDouble();
MVector result = new MVector(x, y, z);
return result;
}
else
{
MGlobal.displayError("Expected 3 children for plug " + plug.name);
MVector result = new MVector(0, 0, 0);
return result;
}
}
// This function is a utility that can be used to extract vector values from
// plugs.
//
private MVector vectorPlugValue(MPlug plug)
{
if (plug.numChildren == 3)
{
double x, y, z;
MPlug rx = plug.child(0);
MPlug ry = plug.child(1);
MPlug rz = plug.child(2);
x = rx.asDouble();
y = ry.asDouble();
z = rz.asDouble();
MVector result = new MVector(x, y, z);
return(result);
}
else
{
MGlobal.displayError("Expected 3 children for plug " + plug.name);
MVector result = new MVector(0, 0, 0);
return(result);
}
}
static bool CopyShaderParam(MPlug from, MPlug to, ShaderParamType spt = ShaderParamType.Color)
{
if (from == null || to == null)
{
return(false);
}
MPlugArray plugArr = new MPlugArray();
from.connectedTo(plugArr, true, false);
if (plugArr.length == 0)
{
switch (spt)
{
case ShaderParamType.Color:
{
to.child(0).setFloat(from.child(0).asFloat());
to.child(1).setFloat(from.child(1).asFloat());
to.child(2).setFloat(from.child(2).asFloat());
break;
}
case ShaderParamType.Float:
{
to.setFloat(from.asFloat());
break;
}
}
}
else
{
MDGModifier dGModifier = new MDGModifier();
Debug.Log(from.source.partialName(true));
dGModifier.connect(from.source, to);
dGModifier.doIt();
}
return(true);
}
public static void ConvertToRSMaterial(MFnDependencyNode matNode, bool deleteOrigin)
{
//replace output to shadingEngine
MPlug plug_matColorOutput = matNode.findPlug(ConstantValue.plugName_matColorOutput);
MPlugArray plugArr_matColorOutDest = new MPlugArray();
plug_matColorOutput.destinations(plugArr_matColorOutDest);
//get textures
MPlug plug_matColorInput = matNode.findPlug(ConstantValue.plugName_matColorInput);
MPlug plug_matTransparency = matNode.findPlug(ConstantValue.plugName_matTransparency);
MFnDependencyNode rsArchiNode = CreateShadingNode(ShadingNodeType.Shader, ConstantValue.nodeName_RS_Architectural);
if (matNode.name.StartsWith("mat_"))
{
rsArchiNode.setName("rs" + matNode.name);
}
else
{
rsArchiNode.setName("rsmat_" + matNode.name);
}
MPlug plug_rsArchiDiffuse = rsArchiNode.findPlug(ConstantValue.plugName_RS_diffuse);
MPlug plug_rsArchiTransColor = rsArchiNode.findPlug(ConstantValue.plugName_RS_transColor);
MPlug plug_rsArchiTransWeight = rsArchiNode.findPlug(ConstantValue.plugName_RS_transWeight);
MPlug plug_rsArchiOutColor = rsArchiNode.findPlug(ConstantValue.plugName_RS_outColor);
MDGModifier dGModifier = new MDGModifier();
for (int i = 0; i < plugArr_matColorOutDest.length; i++)
{
dGModifier.disconnect(plug_matColorOutput, plugArr_matColorOutDest[i]);
dGModifier.connect(plug_rsArchiOutColor, plugArr_matColorOutDest[i]);
}
CopyShaderParam(plug_matColorInput, plug_rsArchiDiffuse);
//if (plug_matColorInput.source == null)
//{
// plug_rsArchiDiffuse.child(0).setFloat(plug_matColorInput.child(0).asFloat());
// plug_rsArchiDiffuse.child(1).setFloat(plug_matColorInput.child(1).asFloat());
// plug_rsArchiDiffuse.child(2).setFloat(plug_matColorInput.child(2).asFloat());
//}
//else
//{
// dGModifier.connect(plug_matColorInput.source, plug_rsArchiDiffuse);
//}
CopyShaderParam(plug_matTransparency, plug_rsArchiTransColor);
if (plug_matTransparency.child(0).asFloat() == 0 && plug_matTransparency.child(1).asFloat() == 0 && plug_matTransparency.child(2).asFloat() == 0)
{
plug_rsArchiTransWeight.setFloat(1);
}
else
{
plug_rsArchiTransWeight.setFloat(0);
}
//if (plug_matTransparency.source == null)
//{
// //plug_rsArchiTransColor.setValue(plug_matColorInput.asMObject());
// float matTransparency = plug_matTransparency.asFloat();
// if (matTransparency == 0)
// {
// plug_rsArchiTransWeight.setFloat(0);
// plug_rsArchiTransColor.child(0).setFloat(0);
// plug_rsArchiTransColor.child(1).setFloat(0);
// plug_rsArchiTransColor.child(2).setFloat(0);
// }
// else
// {
// plug_rsArchiTransWeight.setFloat(1);
// plug_rsArchiTransColor.child(0).setFloat(plug_matTransparency.child(0).asFloat());
// plug_rsArchiTransColor.child(1).setFloat(plug_matTransparency.child(1).asFloat());
// plug_rsArchiTransColor.child(2).setFloat(plug_matTransparency.child(2).asFloat());
// }
//}
//else
//{
// dGModifier.connect(plug_matTransparency.source, plug_rsArchiTransColor);
// plug_rsArchiTransWeight.setFloat(1);
//}
if (deleteOrigin)
{
dGModifier.deleteNode(matNode.objectProperty);
}
dGModifier.doIt();
}
private MFnDependencyNode getTextureDependencyNode(MFnDependencyNode materialDependencyNode, string plugName, List <MFnDependencyNode> textureModifiers = null)
{
MPlug mPlug = materialDependencyNode.findPlug(plugName);
if (mPlug == null || mPlug.isNull || !mPlug.isConnected)
{
// a compound plug connected to a non-compound plug may not be marked as connected, try to get a child plug:
if (mPlug.isCompound)
{
// Retrieve the first non-empty plug and use the texture connected to it.
for (uint i = 0; i < mPlug.numChildren; i++)
{
MPlug child = mPlug.child(i);
if (child == null || child.isNull || !child.isConnected)
{
continue;
}
mPlug = child;
break;
}
}
if (mPlug == null || mPlug.isNull || !mPlug.isConnected)
{
return(null);
}
}
MObject sourceObject = mPlug.source.node;
MFnDependencyNode textureDependencyNode = new MFnDependencyNode(sourceObject);
RaiseMessage(materialDependencyNode.name + "." + plugName, logRankTexture);
// Bump texture uses an intermediate node
if (sourceObject.hasFn(MFn.Type.kBump))
{
Print(textureDependencyNode, logRankTexture, "Print bump node");
logRankTexture++;
if (textureModifiers != null)
{
textureModifiers.Add(textureDependencyNode);
}
return(getTextureDependencyNode(textureDependencyNode, "bumpValue", textureModifiers));
}
// If a reverse node is used as an intermediate node
if (sourceObject.hasFn(MFn.Type.kReverse))
{
Print(textureDependencyNode, logRankTexture, "Print reverse node");
// TODO - reverse?
logRankTexture++;
if (textureModifiers != null)
{
textureModifiers.Add(textureDependencyNode);
}
return(getTextureDependencyNode(textureDependencyNode, "input", textureModifiers));
}
// If a projection node is used as an intermediate node
if (sourceObject.hasFn(MFn.Type.kProjection))
{
Print(textureDependencyNode, logRankTexture, "Print projection node");
logRankTexture++;
if (textureModifiers != null)
{
textureModifiers.Add(textureDependencyNode);
}
return(getTextureDependencyNode(textureDependencyNode, "image", textureModifiers));
}
return(textureDependencyNode);
}
