bool getConnectedFileTexturePath(MString& plugName, MString& nodeName, MString& value, MObject& outFileNode) { MStatus stat; MObject obj = objectFromName(nodeName); if( obj == MObject::kNullObj) return false; MFnDependencyNode depFn(obj); MPlug plug = depFn.findPlug(plugName, &stat); if( !stat ) return false; //MGlobal::displayInfo(MString("is plug connected: ") + plug.name()); if( !plug.isConnected()) { //MGlobal::displayInfo(MString("plug is NOT connected: ") + plug.name()); return false; } MPlugArray parray; plug.connectedTo(parray, true, false, &stat); if( !stat ) return false; if( parray.length() == 0 ) return false; MPlug destPlug = parray[0]; MObject fileNode = destPlug.node(); std::cout << "filenode: " << getObjectName(fileNode).asChar() << " plug name " << destPlug.name() << "\n"; if( !fileNode.hasFn(MFn::kFileTexture) ) { std::cout << "node is not from type fileTexture.\n"; return false; } MFnDependencyNode fileDepFn(fileNode); MPlug ftn = fileDepFn.findPlug("fileTextureName", &stat); if(!stat) { std::cout << "fileTextureName not found at fileTexNode.\n"; return false; } MString fileTextureName = ftn.asString(); std::cout << "fileTextureName value: " << fileTextureName.asChar() <<"\n"; value = fileTextureName; outFileNode = fileNode; return true; }
bool getConnectedFileTexturePath(const MString& plugName, MString& nodeName, MString& value, MObject& outFileNode) { MStatus stat; MObject obj = objectFromName(nodeName); if (obj == MObject::kNullObj) return false; MFnDependencyNode depFn(obj); MPlug plug = depFn.findPlug(plugName, &stat); if (!stat) return false; if (!plug.isConnected()) { return false; } MPlugArray parray; plug.connectedTo(parray, true, false, &stat); if (!stat) return false; if (parray.length() == 0) return false; MPlug destPlug = parray[0]; MObject fileNode = destPlug.node(); if (!fileNode.hasFn(MFn::kFileTexture)) { return false; } MFnDependencyNode fileDepFn(fileNode); MPlug ftn = fileDepFn.findPlug("fileTextureName", &stat); if (!stat) { return false; } MString fileTextureName = ftn.asString(); value = fileTextureName; outFileNode = fileNode; return true; }
bool CoronaRenderer::isSunLight(std::shared_ptr<MayaObject> obj) { // a sun light has a transform connection to the coronaGlobals.sunLightConnection plug MObject coronaGlobals = objectFromName(MString("coronaGlobals")); MObjectArray nodeList; MStatus stat; getConnectedInNodes(MString("sunLightConnection"), coronaGlobals, nodeList); if( nodeList.length() > 0) { MObject sunObj = nodeList[0]; if(sunObj.hasFn(MFn::kTransform)) { MFnDagNode sunDagNode(sunObj); MObject sunDagObj = sunDagNode.child(0, &stat); if( sunDagObj == obj->mobject) return true; } } return false; }
MStatus MayaToCorona::doIt( const MArgList& args) { MStatus stat = MStatus::kSuccess; MArgDatabase argData(syntax(), args); if (argData.isFlagSet("-version", &stat)) { MStringArray res; for (auto v : getFullVersionString()) res.append(v.c_str()); setResult(res); return MS::kSuccess; } MGlobal::displayInfo("Executing mayaToCorona..."); setLogLevel(); if (argData.isFlagSet("-state", &stat)) { Logging::debug(MString("state: ???")); MayaTo::MayaToWorld::WorldRenderState rstate = MayaTo::getWorldPtr()->renderState; if (rstate == MayaTo::MayaToWorld::RSTATETRANSLATING) setResult("rstatetranslating"); if (rstate == MayaTo::MayaToWorld::RSTATERENDERING) setResult("rstaterendering"); if (rstate == MayaTo::MayaToWorld::RSTATEDONE) setResult("rstatedone"); if (rstate == MayaTo::MayaToWorld::RSTATENONE) setResult("rstatenone"); if (rstate == MayaTo::MayaToWorld::RSTATESTOPPED) setResult("rstatestopped"); return MS::kSuccess; } if (argData.isFlagSet("-canDoIPR", &stat)) { if(MayaTo::getWorldPtr()->canDoIPR()) setResult("yes"); else setResult("no"); return MS::kSuccess; } if ( argData.isFlagSet("-stopIpr", &stat)) { Logging::debug(MString("-stopIpr")); EventQueue::Event e; e.type = EventQueue::Event::IPRSTOP; theRenderEventQueue()->push(e); return MS::kSuccess; } if ( argData.isFlagSet("-pauseIpr", &stat)) { Logging::debug(MString("-pauseIpr")); Logging::debug(MString("-stopIpr")); EventQueue::Event e; e.type = EventQueue::Event::IPRPAUSE; theRenderEventQueue()->push(e); return MS::kSuccess; } // I have to request useRenderRegion here because as soon the command is finished, what happens immediatly after the command is // put into the queue, the value is set back to false. std::unique_ptr<MayaTo::CmdArgs> cmdArgs(new MayaTo::CmdArgs); MObject drg = objectFromName("defaultRenderGlobals"); MFnDependencyNode drgfn(drg); cmdArgs->useRenderRegion = drgfn.findPlug("useRenderRegion").asBool(); if ( argData.isFlagSet("-startIpr", &stat)) { Logging::debug(MString("-startIpr")); cmdArgs->renderType = MayaTo::MayaToWorld::WorldRenderType::IPRRENDER; } if (argData.isFlagSet("-width", &stat)) { argData.getFlagArgument("-width", 0, cmdArgs->width); Logging::debug(MString("width: ") + cmdArgs->width); } if (argData.isFlagSet("-height", &stat)) { argData.getFlagArgument("-height", 0, cmdArgs->height); Logging::debug(MString("height: ") + cmdArgs->height); } if ( argData.isFlagSet("-camera", &stat)) { MDagPath camera; MSelectionList selectionList; argData.getFlagArgument("-camera", 0, selectionList); stat = selectionList.getDagPath(0, camera); camera.extendToShape(); Logging::debug(MString("camera: ") + camera.fullPathName()); cmdArgs->cameraDagPath = camera; } EventQueue::Event e; e.cmdArgsData = std::move(cmdArgs); e.type = EventQueue::Event::INITRENDER; theRenderEventQueue()->push(e); // if (MGlobal::mayaState() == MGlobal::kBatch) { RenderQueueWorker::startRenderQueueWorker(); } return MStatus::kSuccess; }
void CoronaRenderer::defineLights() { // first get the globals node and serach for a directional light connection MObject coronaGlobals = objectFromName(MString("coronaGlobals")); MObjectArray nodeList; MStatus stat; if( this->mtco_renderGlobals->useSunLightConnection ) { getConnectedInNodes(MString("sunLightConnection"), coronaGlobals, nodeList); if( nodeList.length() > 0) { MObject sunObj = nodeList[0]; if(sunObj.hasFn(MFn::kTransform)) { // we suppose what's connected here is a dir light transform MVector lightDir(0, 0, 1); // default dir light dir MFnDagNode sunDagNode(sunObj); lightDir *= sunDagNode.transformationMatrix(); lightDir *= this->mtco_renderGlobals->globalConversionMatrix; lightDir.normalize(); MObject sunDagObj = sunDagNode.child(0, &stat); if( !stat ) logger.error("no child 0"); MColor sunColor(1); float colorMultiplier = 1.0f; if(sunDagObj.hasFn(MFn::kDirectionalLight)) { MFnDependencyNode sunNode(sunDagObj); getColor("color", sunNode, sunColor); getFloat("mtco_sun_multiplier", sunNode, colorMultiplier); }else{ logger.warning(MString("Sun connection is not a directional light - using transform only.")); } sunColor *= colorMultiplier * 10000.0; Corona::Sun sun; sun.active = true; sun.dirTo = Corona::Dir(lightDir.x, lightDir.y, lightDir.z).getNormalized(); sun.color = Corona::Rgb(sunColor.r,sunColor.g,sunColor.b); sun.visibleDirect = true; sun.visibleReflect = true; sun.visibleRefract = true; sun.sizeMultiplier = 2.0f; this->context.scene->getSun() = sun; } } } for( size_t lightId = 0; lightId < this->mtco_scene->lightList.size(); lightId++) { mtco_MayaObject *obj = (mtco_MayaObject *)this->mtco_scene->lightList[lightId]; if(!obj->visible) continue; if( this->isSunLight(obj)) continue; MFnDependencyNode depFn(obj->mobject); if( obj->mobject.hasFn(MFn::kPointLight)) { MColor col; getColor("color", depFn, col); float intensity = 1.0f; getFloat("intensity", depFn, intensity); int decay = 0; getEnum(MString("decayRate"), depFn, decay); MMatrix m = obj->transformMatrices[0] * this->mtco_renderGlobals->globalConversionMatrix; Corona::Pos LP(m[3][0],m[3][1],m[3][2]); PointLight *pl = new PointLight; pl->LP = LP; pl->distFactor = 1.0/this->mtco_renderGlobals->scaleFactor; pl->lightColor = Corona::Rgb(col.r, col.g, col.b); pl->lightIntensity = intensity; getEnum(MString("decayRate"), depFn, pl->decayType); this->context.scene->addLightShader(pl); } if( obj->mobject.hasFn(MFn::kSpotLight)) { MVector lightDir(0, 0, -1); MColor col; getColor("color", depFn, col); float intensity = 1.0f; getFloat("intensity", depFn, intensity); MMatrix m = obj->transformMatrices[0] * this->mtco_renderGlobals->globalConversionMatrix; lightDir *= obj->transformMatrices[0] * this->mtco_renderGlobals->globalConversionMatrix; lightDir.normalize(); Corona::Pos LP(m[3][0],m[3][1],m[3][2]); SpotLight *sl = new SpotLight; sl->LP = LP; sl->lightColor = Corona::Rgb(col.r, col.g, col.b); sl->lightIntensity = intensity; sl->LD = Corona::Dir(lightDir.x, lightDir.y, lightDir.z); sl->angle = 45.0f; sl->distFactor = 1.0/this->mtco_renderGlobals->scaleFactor; getEnum(MString("decayRate"), depFn, sl->decayType); getFloat("coneAngle", depFn, sl->angle); getFloat("penumbraAngle", depFn, sl->penumbraAngle); getFloat("dropoff", depFn, sl->dropoff); this->context.scene->addLightShader(sl); } if( obj->mobject.hasFn(MFn::kDirectionalLight)) { MVector lightDir(0, 0, -1); MColor col; getColor("color", depFn, col); float intensity = 1.0f; getFloat("intensity", depFn, intensity); MMatrix m = obj->transformMatrices[0] * this->mtco_renderGlobals->globalConversionMatrix; lightDir *= m; lightDir.normalize(); Corona::Pos LP(m[3][0],m[3][1],m[3][2]); DirectionalLight *dl = new DirectionalLight; dl->LP = LP; dl->lightColor = Corona::Rgb(col.r, col.g, col.b); dl->lightIntensity = intensity; dl->LD = Corona::Dir(lightDir.x, lightDir.y, lightDir.z); this->context.scene->addLightShader(dl); } if( obj->mobject.hasFn(MFn::kAreaLight)) { logger.warning(MString("Area light: ") + obj->shortName + " not yet supported."); MMatrix m = obj->transformMatrices[0] * this->mtco_renderGlobals->globalConversionMatrix; obj->geom = defineStdPlane(); Corona::AnimatedAffineTm atm; this->setAnimatedTransformationMatrix(atm, obj); obj->instance = obj->geom->addInstance(atm, NULL, NULL); //this->defineMaterial(obj->instance, obj); } } }
MObject getRenderGlobalsNode() { return objectFromName("appleseedGlobals"); }
void CoronaRenderer::defineMaterial(Corona::IInstance* instance, std::shared_ptr<MayaObject> mobj) { std::shared_ptr<mtco_MayaObject> obj = std::static_pointer_cast<mtco_MayaObject>(mobj); MFnDependencyNode globalsNode(objectFromName("coronaGlobals")); if (getBoolAttr("useGlobalMaterialOverride", globalsNode, false)) { MObject surfaceShader = getOtherSideNode(MString("globalMaterialOverride"), globalsNode.object()); // get shading group for reuse MFnDependencyNode surfaceShaderNode(surfaceShader); MPlug outColorPlug = surfaceShaderNode.findPlug("outColor"); MObject shadingGroupObject; if (outColorPlug.isConnected()) { MPlugArray outArray; outColorPlug.connectedTo(outArray, false, true); if (outArray.length() > 0) { shadingGroupObject = outArray[0].node(); } } if (shadingGroupObject != MObject::kNullObj) if (assingExistingMat(shadingGroupObject, obj)) return; Corona::SharedPtr<Corona::IMaterial> base = defineCoronaMaterial(surfaceShader, obj); Corona::IMaterialSet ms = Corona::IMaterialSet(base); setRenderStats(ms, obj); obj->instance->addMaterial(ms); return; } getObjectShadingGroups(obj->dagPath, obj->perFaceAssignments, obj->shadingGroups, false); if( obj->shadingGroups.length() > 0) { for (uint sgId = 0; sgId < obj->shadingGroups.length(); sgId++) { MObject shadingGroup = obj->shadingGroups[sgId]; Logging::debug(MString("---------- Check shading group: ") + getObjectName(shadingGroup) + " for existence on object named " + obj->fullName); if (assingExistingMat(shadingGroup, obj)) return; MObject surfaceShader = getConnectedInNode(shadingGroup, "surfaceShader"); // check obj set overrides MObject connectedSet = getConnectedObjSet(obj->dagPath); if (connectedSet != MObject::kNullObj) { MFnDependencyNode setFn(connectedSet); Logging::debug(MString("Found connected object set:") + setFn.name()); MPlug shaderOverride = setFn.findPlug("mtco_mtlOverride"); if (!shaderOverride.isNull()) { MObject connectedObject = getConnectedInNode(shaderOverride); if (connectedObject != MObject::kNullObj) surfaceShader = connectedObject; } } // raytype shader is a special case. Here a material set gets different materials, so I have to call defineCoronaMaterial several times MFnDependencyNode shaderMat(surfaceShader); Corona::SharedPtr<Corona::IMaterial> base = nullptr; Corona::SharedPtr<Corona::IMaterial> reflect = nullptr; Corona::SharedPtr<Corona::IMaterial> refract = nullptr; Corona::SharedPtr<Corona::IMaterial> direct = nullptr; if (shaderMat.typeName() == "CoronaRaytype") { MPlug basePlug = shaderMat.findPlug("base"); MPlug reflectPlug = shaderMat.findPlug("reflect"); MPlug refractPlug = shaderMat.findPlug("refract"); MPlug directPlug = shaderMat.findPlug("direct"); if (basePlug.isConnected()) { MObject inNode = getConnectedInNode(basePlug); base = defineCoronaMaterial(inNode, nullptr); } if (reflectPlug.isConnected()) { MObject inNode = getConnectedInNode(reflectPlug); reflect = defineCoronaMaterial(inNode, nullptr); } if (refractPlug.isConnected()) { MObject inNode = getConnectedInNode(refractPlug); refract = defineCoronaMaterial(inNode, nullptr); } if (directPlug.isConnected()) { MObject inNode = getConnectedInNode(directPlug); direct = defineCoronaMaterial(inNode, nullptr); } } else{ base = defineCoronaMaterial(surfaceShader, obj); } Corona::IMaterialSet ms = Corona::IMaterialSet(base); ms.overrides.direct = direct; ms.overrides.reflect = reflect; ms.overrides.refract = refract; setRenderStats(ms, obj); obj->instance->addMaterial(ms); } } else{ Corona::SharedPtr<Corona::IMaterial> mat = defineCoronaMaterial(MObject::kNullObj, nullptr); Corona::IMaterialSet ms = Corona::IMaterialSet(mat); setRenderStats(ms, obj); obj->instance->addMaterial(ms); } }