MStatus OccLightNode::initialize_shader_parameters()
{
//CM_TRACE_FUNC("OccLightNode::initialize_shader_parameters()");
MFnTypedAttribute tAttr;
MFnStringData tDefault;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
MFnLightDataAttribute lAttr;
MFnStringData stringData;
MStatus status, sstat;
CREATE_FLOAT(nAttr, akocc, "Kocc", "k", 1.0);
CREATE_INT(nAttr, asamples, "samples", "sam", 64);
CREATE_FLOAT(nAttr, amaxdist, "maxdist", "max", 1e36);
CREATE_STRING(tAttr,adistribution, "distribution", "dis", "cosine");
CREATE_BOOL(nAttr, a__nonspecular, "__nonspecular","nsp", 1);
IfMErrorWarn( attributeAffects( akocc, aOutColor ) );
IfMErrorWarn( attributeAffects( asamples, aOutColor ) );
IfMErrorWarn( attributeAffects( amaxdist, aOutColor ) );
IfMErrorWarn( attributeAffects( adistribution, aOutColor ) );
IfMErrorWarn( attributeAffects( a__nonspecular, aOutColor ) );
return MS::kSuccess;
}
MStatus PhysicalsunNode::initialize_shader_parameters()
{
//CM_TRACE_FUNC("PhysicalsunNode::initialize_shader_parameters()");
MFnTypedAttribute tAttr;
MFnStringData tDefault;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
MFnLightDataAttribute lAttr;
MFnStringData stringData;
MStatus status, sstat;
CREATE_FLOAT(nAttr, ai_multiplier, "multiplier", "mul", 1.0);
CREATE_COLOR(nAttr, ai_rgb_unit_conversion, "rgb_unit_conversion", "uc", 0.0, 0.0, 0.0);
CREATE_FLOAT(nAttr, ai_haze, "haze", "haz", 0.0);
CREATE_FLOAT(nAttr, ai_redblueshift, "redblueshift", "rbs", 0.0);
CREATE_FLOAT(nAttr, ai_saturation, "saturation", "sat", 0.7);
CREATE_FLOAT(nAttr, ai_horizon_height, "horizon_height", "hoh", 0.0);
CREATE_FLOAT(nAttr, ai_shadow_softness, "shadow_softness","ssf", 0.0);
CREATE_STRING(tAttr,ai_shadowmap, "shadowmap", "sm", "raytrace");
CREATE_INT(nAttr, ai_shadow_samples, "shadow_samples", "ssp", 3);
CREATE_BOOL(nAttr, ai_y_is_up, "y_is_up", "yup", false );
IfMErrorWarn( attributeAffects( ai_multiplier, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_rgb_unit_conversion, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_haze, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_redblueshift, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_saturation, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_horizon_height, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_shadow_softness, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_shadowmap, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_shadow_samples, aOutColor ) );
IfMErrorWarn( attributeAffects( ai_y_is_up, aOutColor ) );
return MS::kSuccess;
}
void Renderer::generate_pfxhair(liqRibNodePtr &ribNode__, liqRibPfxHairData* phair, const int degree)
{
CM_TRACE_FUNC("generate_pfxhair("<<ribNode__->getTransformNodeFullPath()<<")");
MStatus status;
MFnPfxGeometry pfxhair(phair->objDagPath, &status);
IfMErrorWarn(status);
MRenderLineArray profileArray;
MRenderLineArray creaseArray;
MRenderLineArray intersectionArray;
MRenderLineArray copy;
bool doLines = true;
bool doTwist = true;
bool doWidth = true;
bool doFlatness = false;
bool doParameter = false;
bool doColor = true;
bool doIncandescence = false;
bool doTransparency = true;
bool doWorldSpace = false;
IfMErrorWarn( pfxhair.getLineData( profileArray, creaseArray, intersectionArray, doLines, doTwist, doWidth, doFlatness, doParameter, doColor, doIncandescence, doTransparency, doWorldSpace) );
//todo
}
MStatus btSPHMgrNode::initialize()
{
_LogFunctionCall("btSPHMgrNode::initialize()");
MStatus status;
MFnUnitAttribute uAttr;
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
i_particleShape = nAttr.create(particleShape, ps, MFnNumericData::kInt, 0, &status);
IfMErrorWarn(status);
IfMErrorWarn(addAttribute(i_particleShape));
i_particlePPAttr = nAttr.create(particlePPAttr, pppa, MFnNumericData::kInt, 0, &status);
IfMErrorWarn(status);
IfMErrorWarn(addAttribute(i_particlePPAttr));
i_particleCount = nAttr.create( particleCount, pc, MFnNumericData::kInt, 300,&status);
IfMErrorWarn(status);
IfMErrorWarn(addAttribute( i_particleCount ));
i_obstacleAABB = tAttr.create(obstacleBox, obox, MFnData::kMesh, MObject::kNullObj, &status);
IfMErrorWarn(status);
IfMErrorWarn(addAttribute(i_obstacleAABB));
i_initAABB = tAttr.create(initBox, ibox, MFnData::kMesh, MObject::kNullObj, &status);
IfMErrorWarn(status);
IfMErrorWarn(addAttribute(i_initAABB));
return MS::kSuccess;
}
void liqIPRNodeMessage::onOtherNode(const MString &node, std::vector<MString> &updateObjectName)
{
MStringArray descendents;
MString cmd("listRelatives -allDescendents "+node);
MGlobal::executeCommand(cmd, descendents);
for(int i=0; i<descendents.length(); ++i)
{
addUpdateObject(updateObjectName, descendents[i]);//record descendents[i]
MDagPath dagPath;
getDagPathByName(dagPath, descendents[i].asChar());
if( dagPath.node().hasFn(MFn::kTransform) )
{
onOtherNode(descendents[i], updateObjectName);//visit descendents[i]
}
else if( dagPath.node().hasFn(MFn::kMesh) )
{
std::vector<std::string> shaderPlugs;
liquid::RendererMgr::getInstancePtr()->
getRenderer()->getValidShaderPlugsInShadingGroup(shaderPlugs);
IfMErrorWarn(dagPath.extendToShape());//extend to shape
std::vector<std::string> shadingGroups;
getShadingGroups(dagPath.fullPathName(), shadingGroups);
for(std::size_t j=0; j<shadingGroups.size(); ++j)//for each shading group
{
MString shadingGroup(shadingGroups[j].c_str());
for(std::size_t k=0; k<shaderPlugs.size(); ++k)//for each shader plug
{
MString shaderPlug(shaderPlugs[k].c_str());
int isShaderPlugExist;
cmd = "attributeQuery -node \""+shadingGroup+"\" -ex \""+shaderPlug+"\"";
IfMErrorMsgWarn(MGlobal::executeCommand( cmd, isShaderPlugExist), cmd);
if( isShaderPlugExist )
{
//get the source shade node of $shadingGroup.$shaderPlug
MStringArray shaders;
cmd = "listConnections -s true -d false -plugs false (\""+shadingGroup+"\" + \"."+shaderPlug+"\")";
IfMErrorMsgWarn(MGlobal::executeCommand( cmd, shaders), cmd);
if( shaders.length() > 0 )//has source shader node
{
onShaderNode(shaders[0], updateObjectName);
}//if( shaders.length() > 0 )//has source shader node
}//if( isShaderPlugExist )
}//for each shader plug
}//for each shading group
}//kMesh
}//for(int i=0; i<descendents.length(); ++i)
}
void Visitor::outputUpstreamShader(const char* shaderNodeName)
{
CM_TRACE_FUNC("Visitor::outputUpstreamShader("<<shaderNodeName<<")");
MString nodetype;
IfMErrorWarn(MGlobal::executeCommand( ("nodeType \""+MString(shaderNodeName)+"\""), nodetype));
_outputUpstreamShader(shaderNodeName, nodetype.asChar());
}
MStatus TestLightNode::initialize_shader_parameters()
{
//CM_TRACE_FUNC("TestLightNode::initialize_shader_parameters()");
MFnTypedAttribute tAttr;
MFnStringData tDefault;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
MFnLightDataAttribute lAttr;
MStatus status;
CREATE_COLOR(nAttr, alightcolor, "lightcolor", "lc", 1.0f, 1.0f, 1.0f);
CREATE_FLOAT(nAttr, aintensity, "intensity", "its", 1.0f);
IfMErrorWarn( attributeAffects( alightcolor, aOutColor ) );
IfMErrorWarn( attributeAffects( aintensity, aOutColor ) );
return MS::kSuccess;
}
MStatus TestLightNode::compute( const MPlug& plug, MDataBlock& block )
{
//CM_TRACE_FUNC("SkyLightNode::compute(job="<<plug.name()<<",block)");
// outColor or individual R, G, B channel
if( (plug == aOutColor) || (plug.parent() == aOutColor) ||
(plug == aOutTransparency) || (plug.parent() == aOutTransparency)
)
{
// init shader
MStatus status;
MFloatVector& lightcolor = block.inputValue(alightcolor).asFloatVector();
//rendering begin (maya software)
MFloatVector resultColor;
resultColor = lightcolor;
//rendering end
// set ouput color attribute
MDataHandle outColorHandle = block.outputValue( aOutColor, &status );
IfMErrorWarn(status);
outColorHandle.asFloatVector() = resultColor;
outColorHandle.setClean();
MDataHandle outTransHandle = block.outputValue( aOutTransparency, &status );
IfMErrorWarn(status);
outTransHandle.asFloatVector() = MFloatVector(0.0, 0.0, 0.0);
outTransHandle.setClean();
}
else {
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
bool liqIPRNodeMessage::isShaderNode(const MString &node)const
{
MString cmd;
MString nodetype;
cmd = "nodeType \""+node+"\"";
IfMErrorWarn(MGlobal::executeCommand( cmd, nodetype));
if( liquidmaya::ShaderMgr::getSingletonPtr()->hasShaderType(nodetype.asChar()) )
{
return true;
}else{
return false;
}
}
void liqIPRNodeMessage::gatherUpdateObjects(std::vector<MString>& objects)
{
MStatus status;
//get selection list
MSelectionList selection;
IfMErrorWarn(MGlobal::getActiveSelectionList( selection ));
for ( unsigned int i=0; i<selection.length(); i++ )
{
MObject node;
IfMErrorWarn(selection.getDependNode( i, node ));
MFnDependencyNode nodeFn(node, &status);
IfMErrorWarn(status);
const MString nodeName(nodeFn.name());
objects.push_back(nodeName);//record current node
if( isShaderNode(nodeName) )
{
onShaderNode(nodeName, objects);
}
else{
onOtherNode(nodeName, objects);
}
}
//add current camera shape node
MStringArray cameraShapeFullPaths;
IfMErrorWarn(MGlobal::executeCommand("string $cam = `getAttr liquidGlobals.renderCamera`; ls -long $cam;", cameraShapeFullPaths));
objects.push_back(cameraShapeFullPaths[0]);
//add current camera transform node
}
MStatus liqIPRNodeMessage::doIt( const MArgList& args)
//
// Takes the nodes that are on the active selection list and adds an
// attriubte changed callback to each one.
//
{
MStatus stat;
for( unsigned i( 0 ); i < args.length(); i++ )
{
MString arg = args.asString( i, &stat );
IfMErrorWarn(stat);
if( (arg == kRegisterFlag) || (arg == kRegisterFlagLong) ){
isRunningIPR = 1;
liqRibTranslator::getInstancePtr()->IPRRenderBegin();
IfMErrorWarn(registerCallback());
//liqRibTranslator::getInstancePtr()->IPRDoIt();
}
else if( (arg == kUnregisterFlag) || (arg == kUnregisterFlagLong) ){
IfMErrorWarn(unregisterCallback());
liqRibTranslator::getInstancePtr()->IPRRenderEnd();
isRunningIPR = 0;
}
else if( (arg == kIsRunningIPR) || (arg == kIsRunningIPRLong) ){
setResult(isRunningIPR);
}
else{
liquidMessage2(messageError,"Parameter [%s] is undefined in liqIPRNodeMessage.", arg.asChar());
return MS::kUnknownParameter;
}
}
return MS::kSuccess;
}
bool RNodeVisitorMgr::visit(const char *node)
{
CM_TRACE_FUNC("RNodeVisitorMgr::visit("<<node<<")");
MString nodeType;
IfMErrorWarn( MGlobal::executeCommand( ("nodeType \""+MString(node)+"\""), nodeType) );
std::map<
std::string,
liquid::RenderNodeVisitorInterface2*
>::iterator i = m_map.find(nodeType.asChar());
if( i == m_map.end())//not found
{
return false;
}
return i->second->visit(node);
}
bool RNodeVisitorMgr::onCreateInstance(const char *node)
{
//in batch mode, this function is called after the rendering,
//so it complains the cm::trace file is not open, so I omit this CM_TRACE_FUNC()
//CM_TRACE_FUNC("RNodeVisitorMgr::onCreateInstance("<<node<<")");
MString nodeType;
IfMErrorWarn( MGlobal::executeCommand( ("nodeType \""+MString(node)+"\""), nodeType) );
std::map<
std::string,
liquid::RenderNodeVisitorInterface2*
>::iterator i = m_map.find(nodeType.asChar());
if( i == m_map.end())//not found
{
return false;
}
return i->second->onCreateInstance(node);
}
void Visitor::postOutput()
{
CM_TRACE_FUNC("Visitor::postOutput()");
//compile the shader
MString shaderdir(getShaderDirectory());
MString outSLO(renderman::getShaderFilePath_SLO(shaderNodeName.c_str()));
MString srcSL (renderman::getShaderFilePath_SRC(shaderNodeName.c_str()));
MString result;
//NOTE:
// the include directory can't contain '.', so I move _3delight to %LIQUID_ROOT%\dependence
//"shader.exe -o \"outSLO\" -I\"%LIQUID_ROOT%\dependence\_3delight" \"srcSL\""
IfMErrorWarn(MGlobal::executeCommand("system(\"shader -o \\\""+outSLO+"\\\" -I\\\"%LIQUID_ROOT%/dependence/_3delight\\\" \\\""+srcSL+"\\\"\")", result, true));
//show the error if there is.
std::string strRes(result.toLowerCase().asChar());
if(strRes.find("error") != std::string::npos)
{
liqAssert(strRes.c_str());
}
}
// @node maya shader node name
void Visitor::visitFile(const char* node)
{
CM_TRACE_FUNC("Visitor::visitFile("<<node<<")");
OutputHelper o(RSLfile);
o.addInclude("file.h");
o.beginRSL( node );
MString mayaTexName(getFileNodeImageName(node));
MString texName = mayaTexName + ".tex";
//system("txmake mayaTexName texName");
IfMErrorWarn(MGlobal::executeCommand("system(\"txmake "+mayaTexName+" "+texName+"\")", true));
//input
o.addRSLVariable( "", "float", "alphaGain", "alphaGain", node);
o.addRSLVariable("uniform", "float", "alphaIsLuminance", "alphaIsLuminance", node);
o.addRSLVariable( "", "float", "alphaOffset", "alphaOffset", node);
o.addRSLVariable( "", "color", "colorGain", "colorGain", node);
o.addRSLVariable( "", "color", "colorOffset", "colorOffset", node);
o.addRSLVariable( "", "color", "defaultColor", "defaultColor", node);
o.addRSLVariable( "", "float2", "uvCoord", "uvCoord",node);
//texName
o.addRSLVariable("uniform", "float", "filterType", "filterType", node);
o.addRSLVariable("uniform", "float", "filter", "filter", node);
o.addRSLVariable( "", "float", "filterOffset", "filterOffset", node);
o.addRSLVariable("uniform", "float", "invert", "invert", node);
o.addRSLVariable("uniform", "float", "fileHasAlpha", "fileHasAlpha", node);
//o.addRSLVariable("index", "num_channels", "num_channels", node);
//output
o.addRSLVariable( "", "float", "outAlpha", "outAlpha", node);
o.addRSLVariable( "", "vector", "outColor", "outColor", node);
o.addRSLVariable( "", "vector", "outTransparency", "outTransparency", node);
o.addToRSL("{");
o.addToRSL(" color _outColor;");
o.addToRSL(" color _outTransparency;");
o.addToRSL(" maya_file("
//Inputs
"alphaGain, \n\t"
"alphaIsLuminance, \n\t"
"alphaOffset, \n\t"
"colorGain, \n\t"
"colorOffset, \n\t"
"defaultColor, \n\t"
"\""+texName+"\", \n\t"
"filterType, \n\t"
"filter, \n\t"
"filterOffset, \n\t"
"invert, \n\t"
"uvCoord, \n\t"
//Outputs
"outAlpha, \n\t"
"_outColor, \n\t"
"_outTransparency \n"
" );");
o.addToRSL(" outColor = vector _outColor;");
o.addToRSL(" outTransparency = vector _outTransparency;");
o.addToRSL("}");
o.endRSL();
}
MStatus OccLightNode::initialize()
{
MFnTypedAttribute tAttr;
MFnStringData tDefault;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
MFnLightDataAttribute lAttr;
MStatus status;
MObject string;
// Create input attributes
aRmanShader = tAttr.create( MString("rmanShader"), MString("rms"), MFnData::kString, tDefault.create(getTypeName()), &status );
MAKE_INPUT(tAttr);
aRmanShaderType = tAttr.create( MString("rmanShaderType"), MString("rst"), MFnData::kString, tDefault.create(getShaderClasscification()), &status );
MAKE_INPUT(tAttr);
aRmanShaderLong = tAttr.create( MString("rmanShaderLong"), MString("rml"), MFnData::kString, aRmanShaderLong, &status );
MAKE_INPUT(tAttr);
aRmanShaderLif = tAttr.create( MString("rmanShaderLif"), MString("lif"), MFnData::kString, aRmanShaderLif, &status );
MAKE_INPUT(tAttr);
aRmanParams = tAttr.create( MString("rmanParams"), MString("rpr"), MFnData::kStringArray, aRmanParams, &status );
MAKE_INPUT(tAttr);
aRmanDetails = tAttr.create( MString("rmanDetails"), MString("rdt"), MFnData::kStringArray, aRmanDetails, &status );
MAKE_INPUT(tAttr);
aRmanTypes = tAttr.create( MString("rmanTypes"), MString("rty"), MFnData::kStringArray, aRmanTypes, &status );
MAKE_INPUT(tAttr);
aRmanDefaults = tAttr.create( MString("rmanDefaults"), MString("rdf"), MFnData::kStringArray, aRmanDefaults, &status );
MAKE_INPUT(tAttr);
aRmanArraySizes = tAttr.create( MString("rmanArraySizes"), MString("ras"), MFnData::kIntArray, aRmanArraySizes, &status );
MAKE_INPUT(tAttr);
aRmanLifCmds = tAttr.create( MString("rmanLifCmds"), MString("rlc"), MFnData::kStringArray, aRmanLifCmds, &status );
MAKE_INPUT(tAttr);
aRmanMethods = tAttr.create( MString("rmanMethods"), MString("rmt"), MFnData::kStringArray, aRmanMethods, &status );
MAKE_INPUT(tAttr);
aRmanIsOutput = tAttr.create( MString("rmanIsOutput"), MString("rio"), MFnData::kIntArray, aRmanIsOutput, &status );
MAKE_INPUT(tAttr);
aRmanAccept = tAttr.create( MString("rmanAccept"), MString("rma"), MFnData::kStringArray, aRmanAccept, &status );
MAKE_INPUT(tAttr);
aOutColor = nAttr.createColor("outColor", "oc");
MAKE_OUTPUT(nAttr);
aOutTransparency = nAttr.createColor("outTransparency", "ot");
MAKE_OUTPUT(nAttr);
IfMErrorWarn( addAttribute( aRmanShader ) );
IfMErrorWarn( addAttribute( aRmanShaderType ) );
IfMErrorWarn( addAttribute( aRmanShaderLong ) );
IfMErrorWarn( addAttribute( aRmanShaderLif ) );
IfMErrorWarn( addAttribute( aRmanParams ) );
IfMErrorWarn( addAttribute( aRmanDetails ) );
IfMErrorWarn( addAttribute( aRmanTypes ) );
IfMErrorWarn( addAttribute( aRmanDefaults ) );
IfMErrorWarn( addAttribute( aRmanArraySizes ) );
IfMErrorWarn( addAttribute( aRmanLifCmds ) );
IfMErrorWarn( addAttribute( aRmanMethods) );
IfMErrorWarn( addAttribute( aRmanIsOutput) );
IfMErrorWarn( addAttribute( aRmanAccept) );
IfMErrorWarn( addAttribute( aOutColor ) );
IfMErrorWarn( addAttribute( aOutTransparency ) );
initialize_shader_parameters();
return MS::kSuccess;
}
void OutputHelper::addRSLVariable(const MString& inputQualifier, MString rslType, const MString& rslName,
const MString& mayaName, const MString& mayaNode)
{
MString cmd;
// If the user specified that the type was an array of floats
// (eg "float2"), extract the size and set the type to float.
int rslTypeSize = 1;
MString matchedStr;
IfMErrorWarn(MGlobal::executeCommand("match(\"float[0-9]+$\",\""+rslType+"\")", matchedStr));
if(matchedStr != "")
{
IfMErrorWarn(MGlobal::executeCommand("match(\"[0-9]+$\",\""+rslType+"\")", matchedStr));
rslTypeSize = matchedStr.asInt();
rslType = "float";
}
// Create the plug's name, and check for convertible connections.
MString plug(mayaNode+"."+mayaName);
int connected = liquidmaya::ShaderMgr::getSingletonPtr()->convertibleConnection(plug.asChar());
// If there are no convertible connections, then we have to
// write out the variable into the shader's body.
if( connected == 0 )
{
//rslTypeSize(int) --> rslTypeSizeStr(string)
MString rslTypeSizeStr;
rslTypeSizeStr.set(rslTypeSize);
// Write out the description of the variable.
rslShaderBody += (" "+inputQualifier + " " + rslType + " " + rslName);
rslShaderBody += ( rslTypeSize != 1 )?
( "[" + rslTypeSizeStr + "] = " )
:( " = " + rslType + " " );
// Write out the value of the variable.
if( rslType=="color"
||rslType=="point"
||rslType=="normal"
||rslType=="vector")
{
MDoubleArray val; val.setLength(3);
IfMErrorWarn(MGlobal::executeCommand("getAttr \""+plug+"\"", val));
//val(double) --> valStr(string)
MStringArray valStr; valStr.setLength(3);
valStr[0].set(val[0]);
valStr[1].set(val[1]);
valStr[2].set(val[2]);
rslShaderBody +="("+valStr[0]+","+valStr[1]+","+valStr[2]+")";
}else if(rslType=="string"){
MString val;
IfMErrorWarn(MGlobal::executeCommand("getAttr \""+plug+"\"", val));
rslShaderBody +="\""+val+"\"";
}else if(rslType=="float"){
if(rslTypeSize == 1){
double val;
IfMErrorWarn(MGlobal::executeCommand("getAttr \""+plug+"\"", val));
//val(double) --> valStr(string)
MString valStr;
valStr.set(val);
rslShaderBody += valStr;
}else{
rslShaderBody += "{ ";
MDoubleArray val; val.setLength(rslTypeSize);
IfMErrorWarn(MGlobal::executeCommand("getAttr \""+plug+"\"", val));
for(int i=0; i<rslTypeSize; ++i){
if( i != 0 ){
rslShaderBody += ", ";
}
//val[i](double) --> valStr(string)
MString valStr;
valStr.set(val[i]);
rslShaderBody += valStr;
}
rslShaderBody += " }";
}
}
rslShaderBody += ";\n";
}//if( $connected == 0 )
// Otherwise, we have a convertible connection, so we'll be
// adding the variable to the block's header.
else{
rslShaderHeader += " ";
// Note if it's connected as an output.
if(connected == 2){
rslShaderHeader += "output ";
}
// Write out the description.
rslShaderHeader += ( rslType + " " + rslName );
if( rslTypeSize != 1 )
{
rslShaderHeader += "[]";
}
rslShaderHeader += ";\n";
//
if(connected == 1)
{
MStringArray srcPlug;
IfMErrorWarn(MGlobal::executeCommand("listConnections -source true -plugs true \""+plug+"\"", srcPlug));
assert(srcPlug.length()==1);
rslShaderBody +="//"+plug+" <-- "+srcPlug[0]+"\n";
}
}//else
}
void Renderer::_write_pfxhair(liqRibPfxHairData* pData, const structJob ¤tJob__)
{
CM_TRACE_FUNC("_write_pfxhair("<<pData->getFullPathName()<<","<<currentJob__.name<<")");
//
if( pData->isEmpty() )
{
liquidMessage2(messageWarning, "pfxHair is empty: %s", pData->getFullPathName());
return;
}
//
liqRibNodePtr ribNode__ = liqRibTranslator::getInstancePtr()->htable->find(
pData->objDagPath.fullPathName(),
pData->objDagPath,
MRT_Unknown
);
assert( ribNode__!=0 );
assert( ribNode__->path().fullPathName() == pData->objDagPath.fullPathName() );
const bool bMotionBlur =
ribNode__->motion.transformationBlur &&
( ribNode__->object( 1 ) ) &&
//( ribNode__->object(0)->type != MRT_Locator ) && // Why the f**k do we not allow motion blur for locators?
( !currentJob__.isShadow || currentJob__.deepShadows );
bool bGeometryMotion =
liqglo.liqglo_doDef
&& bMotionBlur
&& ( ribNode__->object(0)->type != MRT_RibGen );
unsigned int sample_first = 0;
unsigned int sample_last = bGeometryMotion? (liqglo.liqglo_motionSamples - 1):sample_first;
_s("\n// Renderer::exportOneGeometry_Mesh("<<ribNode__->name.asChar()<<","<<sample_first<<","<<sample_last<<")");
const liqRibDataPtr data = ribNode__->object(sample_first)->getDataPtr();
//
// //
MStatus status;
int degree;
MFnDagNode fnDN(data->objDagPath);
IfMErrorWarn( liquidGetPlugValue(fnDN, "degree", degree, status) );
//
// MIntArray triangleCounts,triangleVertices;
// IfMErrorWarn(fnMesh.getTriangles(triangleCounts, triangleVertices));
//
// MString currentUVsetName;
// IfMErrorWarn(fnMesh.getCurrentUVSetName(currentUVsetName));
//
// geometry data (shape)
_s("\n//############################### mesh #");
_s("//shape full path name="<<data->getFullPathName());
#ifdef TRANSFORM_SHAPE_PAIR
const std::string objectName(ribNode__->name.asChar());//shape
#else// SHAPE SHAPE_object PAIR
const std::string objectName(getObjectName(ribNode__->name.asChar()));//shape+"_object"
#endif
//todo
}
void Helper4::addVariableSS(const std::string& param_name_as, const std::string& param_type_as, const std::string& param_name_maya )
{
//std::string ss_name(getSurfaceShaderName(m_nodename,m_ss_model));
asr::ParamArray ss_params;
{
std::string param_value;
const std::string plugName(param_name_maya);
MString fullPlugName((m_nodename+"."+plugName).c_str());
int connected = liquidmaya::ShaderMgr::getSingletonPtr()->convertibleConnection(fullPlugName.asChar());
if(connected ==0)
{
if( isType("color", param_type_as) )
{
MDoubleArray val;
val.setLength(3);
IfMErrorWarn(MGlobal::executeCommand("getAttr (\""+fullPlugName+"\")", val));
param_value = m_nodename+"_"+plugName;
createColor3(m_assembly->colors(), param_value.c_str(), val[0], val[1], val[2]);
}
else if( isType("scalar", param_type_as) )
{
MDoubleArray val;
val.setLength(3);
IfMErrorWarn(MGlobal::executeCommand("getAttr (\""+fullPlugName+"\")", val));
//val contains (r,b,g) value, but I only use val[0] for 'scalar'
MString strVal0;
strVal0.set(val[0]);
param_value = strVal0.asChar();
}
else if( isType("string", param_type_as))
{
MString val;
IfMErrorWarn(MGlobal::executeCommand("getAttr (\""+fullPlugName+"\")", val));
param_value = val.asChar();
}
else {
liquidMessage2(messageWarning,"only [color],[scalar],[string] are handled for an unconnected plug in Surface Shader. "
"the plug of %s is unhandled.", fullPlugName.asChar());
param_value = "unhandled";
}
}
else if(connected == 1)//the plug is linked in.
{
if( isType("texture_instance", param_type_as) )
{
MStringArray srcPlug;
IfMErrorWarn(MGlobal::executeCommand("listConnections -source true -plugs true \""+fullPlugName+"\"", srcPlug));
assert(srcPlug.length()==1);
MStringArray src;
srcPlug[0].split('.',src);
MString srcNode(src[0]);
if( is2DTexture(srcNode) || is3DTexture(srcNode) )
{
//visitFile(srcNode.asChar());
param_value = getTextureInstanceName(srcNode.asChar());
}else{
liquidMessage2(messageWarning,"only [texture2D],[texture3D] are handled for a texture_instance connected-in plug in Surface Shader."
"the plug of %s is unhandled.", fullPlugName.asChar());
param_value = "unhandled";
}
}
else{
liquidMessage2(messageWarning,"only [texture_instance] is handled for a connected-in plug in Surface Shader."
"the plug of %s is unhandled.", fullPlugName.asChar());
param_value = "unhandled";
}
}else{
liquidMessage2(messageWarning,"[%s] is connected out.", fullPlugName.asChar());
}
//
addVariableSS(param_name_as, param_value);
}
}
void Helper4::addVariableBSDF( const std::string& param_name_as, const std::string& param_type_as, const std::string& param_name_maya )
{
std::string param_value;
const std::string plugName(param_name_maya);
MString fullPlugName((m_nodename+"."+plugName).c_str());
int connected = liquidmaya::ShaderMgr::getSingletonPtr()->convertibleConnection(fullPlugName.asChar());
if( connected == 0 )
{
if( isType("color", param_type_as) )
{
MDoubleArray val;
val.setLength(3);
IfMErrorWarn(MGlobal::executeCommand("getAttr (\""+fullPlugName+"\")", val));
param_value = m_nodename+"_"+plugName;
createColor3(m_assembly->colors(), param_value.c_str(), val[0], val[1], val[2]);
}
else if( isType("scalar", param_type_as) )
{
MDoubleArray val;
val.setLength(3);
IfMErrorWarn(MGlobal::executeCommand("getAttr (\""+fullPlugName+"\")", val));
//val contains (r,b,g) value, but I only use val[0] for 'scalar'
MString strVal0;
strVal0.set(val[0]);
param_value = strVal0.asChar();
}
else {
liquidMessage2(messageWarning,"only [color],[scalar] are handled for an unconnected plug in BSDF. "
"the plug of %s is unhandled.", fullPlugName.asChar());
param_value = "unhandled";
}
}
else if(connected == 1)//the color plug is linked in.
{
if( isType("texture_instance", param_type_as) )
{
MStringArray srcPlug;
IfMErrorWarn(MGlobal::executeCommand("listConnections -source true -plugs true \""+fullPlugName+"\"", srcPlug));
assert(srcPlug.length()==1);
MStringArray src;
srcPlug[0].split('.',src);
MString srcNode(src[0]);
if( is2DTexture(srcNode) || is3DTexture(srcNode) )
{
//visitFile(srcNode.asChar());
param_value = getTextureInstanceName(srcNode.asChar());
}else{
liquidMessage2(messageWarning,"type of [%s] is unhandled.(not 2Dtexture and 3Dtexture). [%s]", srcNode.asChar(), fullPlugName.asChar());
param_value = "unhandled";
}
}
else if( isType("bsdf", param_type_as) )
{
//bsdf0 value
MString srcBSDFModel;
IfMErrorWarn(MGlobal::executeCommand("getAttr (\""+fullPlugName+"\")", srcBSDFModel));
MStringArray srcPlug;
IfMErrorWarn(MGlobal::executeCommand("listConnections -source true -plugs true \""+fullPlugName+"\"", srcPlug));
assert(srcPlug.length()==1);
MStringArray src;
srcPlug[0].split('.',src);
MString srcNode(src[0]);
param_value = srcNode.asChar();
}
else{
liquidMessage2(messageWarning,"only [texture_instance],[bsdf] are handled for a connected-in plug in BSDF."
"the plug of %s is unhandled.", fullPlugName.asChar());
param_value = "unhandled";
}
}else{// $(fullPlugName) is connected out
// if $(fullPlugName) plug is connected out to "bsdf0"/"bsdf1" of a "bsdf_mix" node,
// we also need to create this plug for appleseed
// get destination node(s)
MStringArray desNodePlug;
IfMErrorWarn(MGlobal::executeCommand("listConnections -destination true -plugs true \""+fullPlugName+"\"", desNodePlug));
// check whether $(fullPlugName) is connected to a BSDF node
bool isConnectedToA_BSDFMixNode = false;
MString desPlug;
for(std::size_t i = 0; i< desNodePlug.length(); ++i)
{
MStringArray des;
desNodePlug[i].split('.',des);
MString desNode(des[0]);
//destination node BSDF type
MString desNodeBSDFType;
IfMErrorWarn(MGlobal::executeCommand( "getAttr \""+desNode+".rmanShaderType\"", desNodeBSDFType));
if(desNodeBSDFType == "bsdf_mix")
{
isConnectedToA_BSDFMixNode = true;
desPlug = des[1];
}
}
// if $(fullPlugName) is connected out to "bsdf0"/"bsdf1" of a "bsdf_mix" node
// we also need to create this plug for appleseed
if( isConnectedToA_BSDFMixNode && (desPlug=="bsdf0" ||desPlug=="bsdf1") )
{
if( isType("color", param_type_as) )
{
MDoubleArray val;
val.setLength(3);
IfMErrorWarn(MGlobal::executeCommand("getAttr (\""+fullPlugName+"\")", val));
param_value = m_nodename+"_"+plugName;
createColor3(m_assembly->colors(), param_value.c_str(), val[0], val[1], val[2]);
}
else if( isType("scalar", param_type_as) )
{
MDoubleArray val;
val.setLength(3);
IfMErrorWarn(MGlobal::executeCommand("getAttr (\""+fullPlugName+"\")", val));
//val contains (r,b,g) value, but I only use val[0] for 'scalar'
MString strVal0;
strVal0.set(val[0]);
param_value = strVal0.asChar();
}
else if( isType("texture_instance", param_type_as) )
{
MStringArray srcPlug;
IfMErrorWarn(MGlobal::executeCommand("listConnections -source true -plugs true \""+fullPlugName+"\"", srcPlug));
assert(srcPlug.length()==1);
MStringArray src;
srcPlug[0].split('.',src);
MString srcNode(src[0]);
if( is2DTexture(srcNode) || is3DTexture(srcNode) )
{
//visitFile(srcNode.asChar());
param_value = getTextureInstanceName(srcNode.asChar());
}else{
liquidMessage2(messageWarning,"type of [%s] is unhandled.(not 2Dtexture and 3Dtexture). [%s]", srcNode.asChar(), fullPlugName.asChar());
param_value = "unhandled";
}
}
else {
liquidMessage2(messageWarning,"only [color],[scalar],[texture_instance] are handled for an connected-out plug in BSDF. "
"the plug of %s is unhandled.", fullPlugName.asChar());
param_value = "unhandled";
}
}//if( nodetype=="bsdf_mix" && (desPlug=="bsdf0" ||desPlug=="bsdf1") )
else {
liquidMessage2(messageWarning,"[%s] is connected out. But not connected to brdf node, or not brdf0/brdf1 of a brdf node."
" So I don't create the value for this plug.", fullPlugName.asChar());
}
}
//
addVariableBSDF(param_name_as, param_value);
}
/// \brief This function is called once when our plugin is loaded. We can use
/// it to register any custom nodes, mel functions etc.
/// \param obj - a handle to the loaded plugin
/// \return an MStatus error code
///
EXPORT MStatus initializePlugin( MObject obj )
{
_LogFunctionCall("initializePlugin()");
init_logs("c:/bulletSPH.log");
MStatus status;
// a classification for where the node will appear on the create menus
// of the multilister and hypershade.
const MString UserClassify( "shader/surface" );
MFnPlugin plugin( obj, "Rob Bateman", "1.0", "Any");
//
//status = plugin.registerNode( btSPHContext::typeName,
// btSPHContext::typeId,
// btSPHContext::creator,
// btSPHContext::initialize,
// MPxNode::kLocatorNode );
//IfMErrorMsgReturn(status, "regist btSPHContext error.", status);
//MCallbackId CallbackID_AddSPHContext =
// MDGMessage::addNodeAddedCallback(
// btSPHContext::addedCallback,
// btSPHContext::typeName, &status
// );
//IfMErrorWarn(status);
//MCallbackId CallbackID_RemoveSPHContext =
// MDGMessage::addNodeRemovedCallback(
// btSPHContext::removedCallback,
// btSPHContext::typeName, &status
// );
//IfMErrorWarn(status);
////
status = plugin.registerNode( btSPHNode::typeName,
btSPHNode::typeId,
btSPHNode::creator,
btSPHNode::initialize,
MPxNode::kEmitterNode );
IfMErrorMsgReturn(status, "regist btSPHNode error.", status);
MCallbackId CallbackID_AddSPHNode =
MDGMessage::addNodeAddedCallback(
btSPHNode::addedCallback,
btSPHNode::typeName, &status
);
IfMErrorWarn(status);
MCallbackId CallbackID_RemoveSPHNode =
MDGMessage::addNodeRemovedCallback(
btSPHNode::removedCallback,
btSPHNode::typeName, &status
);
IfMErrorWarn(status);
////
//status = plugin.registerNode( simpleFluidEmitter::typeName,
// simpleFluidEmitter::typeId,
// simpleFluidEmitter::creator,
// simpleFluidEmitter::initialize,
// MPxNode::kFluidEmitterNode );
//IfMErrorWarn(status);
//
////
//status = plugin.registerNode( torusField::typeName,
// torusField::typeId,
// torusField::creator,
// torusField::initialize,
// MPxNode::kFieldNode );
//IfMErrorWarn(status);
//
status = plugin.registerNode(
particleAttrNode::typeName,
particleAttrNode::typeId,
particleAttrNode::creator,
particleAttrNode::initialize,
MPxNode::kParticleAttributeMapperNode );
IfMErrorWarn(status);
//
status = plugin.registerCommand(
btSPHCmd::typeName,
btSPHCmd::creator,
btSPHCmd::newSyntax);
IfMErrorMsgReturn(status, "regist btSPHCmd error.", status);
//
status = plugin.registerNode(
btSPHMgrNode::typeName,
btSPHMgrNode::typeId,
btSPHMgrNode::creator,
btSPHMgrNode::initialize,
MPxNode::kDependNode );
IfMErrorWarn(status);
//
MGlobal::executeCommand("source \"SPHMain.mel\"; g_btSPH_Start();");
return status;
}
MStatus liqIPRNodeMessage::registerCallback()
{
//MGlobal::displayInfo( "liqIPRNodeMessage::registerCallback()");
MStatus stat;
std::vector<MString> updateObjectName;
MCallbackId id;
gatherUpdateObjects(updateObjectName);
for ( unsigned int i=0; i<updateObjectName.size(); i++ )
{
MSelectionList selection;
IfMErrorWarn(MGlobal::getSelectionListByName(updateObjectName[i], selection));
if( selection.length() == 0 )//not found
continue;
MObject obj;
IfMErrorWarn(selection.getDependNode( 0, obj ));
MGlobal::displayInfo(MString("add callback for node: ") + updateObjectName[i]);
//AttributeChangedCallback
id = MNodeMessage::addAttributeChangedCallback( obj, liquidIPR_AttributeChangedCallback, NULL, &stat);
IfMErrorWarn(stat);
if ( stat ) {
callbackIds.append( id );
} else {
cout << "MNodeMessage.addAttributeChangedCallback("<<updateObjectName[i]<<") failed\n";
}
//AttributeAddedOrRemovedCallback
//NodeDirtyCallback
// id = MNodeMessage::addNodeDirtyCallback( node, liquidIPR_NodeDirtyCallback, NULL, &stat);
// IfMErrorWarn(stat);
// if ( stat ) {
// callbackIds.append( id );
// } else {
// cout << "MNodeMessage.addNodeDirtyCallback failed\n";
// }
//addNodeDirtyPlugCallback
// id = MNodeMessage::addNodeDirtyPlugCallback( node, liquidIPR_NodeDirtyPlugCallback, NULL, &stat);
// IfMErrorWarn(stat);
// if ( stat ) {
// callbackIds.append( id );
// } else {
// cout << "MNodeMessage.addNodeDirtyPlugCallback failed\n";
// }
//addNameChangedCallback
//addNodeAboutToDeleteCallback
//addNodePreRemovalCallback
//addNodeDestroyedCallback
//addKeyableChangeOverride
//
}
return MS::kSuccess;
}
