TheaSDK::Normal3D TheaRenderer::getSunDirection() { MFnDependencyNode depFn(getRenderGlobalsNode()); std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr; std::shared_ptr<TheaRenderer> renderer = std::static_pointer_cast<TheaRenderer>(MayaTo::getWorldPtr()->worldRendererPtr); TheaSDK::Normal3D sunDir; MObjectArray nodeList; getConnectedInNodes(MString("sunLightConnection"), getRenderGlobalsNode(), nodeList); if( nodeList.length() > 0) { MVector lightDir(0,0,1); MFnDagNode sunDagNode(nodeList[0]); //lightDir *= this->mtth_renderGlobals->globalConversionMatrix.inverse(); lightDir *= sunDagNode.transformationMatrix(); lightDir *= renderGlobals->globalConversionMatrix; lightDir.normalize(); return TheaSDK::Normal3D(lightDir.x,lightDir.y,lightDir.z); } float sunDirX = 0.0f, sunDirY = 0.0f, sunDirZ = 1.0f; MPlug sunDirPlug = depFn.findPlug("sunDirection"); if (!sunDirPlug.isNull()) { sunDirX = sunDirPlug.child(0).asFloat(); sunDirY = sunDirPlug.child(1).asFloat(); sunDirZ = sunDirPlug.child(2).asFloat(); } return TheaSDK::Normal3D(sunDirX, sunDirY, sunDirZ); }
void CoronaRenderer::defineColorMapping() { float gamma = 2.2f; #if MAYA_API_VERSION > 2015 if (MColorManagementUtilities::isColorManagementEnabled()) gamma = 1.0f; #endif MFnDependencyNode depFn(getRenderGlobalsNode()); context.colorMappingData->colorTemperature = getFloatAttr("colorMapping_colorTemperature", depFn, 6500.0f); context.colorMappingData->contrast = getFloatAttr("colorMapping_contrast", depFn, 1.0f); context.colorMappingData->gamma = gamma; context.colorMappingData->tint = toCorona(getColorAttr("colorMapping_tint", depFn)); context.colorMappingData->exposure.simple.exponent = getFloatAttr("colorMapping_simpleExposure", depFn, 0.0f); context.colorMappingData->highlightCompression = getFloatAttr("colorMapping_highlightCompression", depFn, 1.0f); context.colorMappingData->photographicExposure = getEnumInt("exposure_type", depFn) == 1; // release 0.39 override camera settings if (context.colorMappingData->photographicExposure) { context.colorMappingData->exposure.photographic.fStop = getFloatAttr("colorMapping_fStop", depFn, 5.6); context.colorMappingData->exposure.photographic.iso = getFloatAttr("colorMapping_iso", depFn, 100.0); context.colorMappingData->exposure.photographic.shutterSpeed = 1.0f / getFloatAttr("colorMapping_shutterSpeed", depFn, 250.0f); if ( this->renderCam != MObject::kNullObj) { MFnDependencyNode camFn(renderCam); if (getBoolAttr("mtco_overrideRenderSettings", camFn, false)) { context.settings->set(Corona::PARAM_COLORMAP_ISO, getFloatAttr("mtco_iso", camFn, 1.0)); context.settings->set(Corona::PARAM_COLORMAP_F_STOP, getFloatAttr("fStop", camFn, 5.6)); context.settings->set(Corona::PARAM_COLORMAP_SHUTTER_SPEED, 1.0f / getFloatAttr("mtco_shutterSpeed", camFn, 250.0f)); } } } }
void TheaRenderer::defineIBLNode(TheaSDK::XML::EnvironmentOptions::IBLMap& iblMap, const char *attName) { MFnDependencyNode depFn(getRenderGlobalsNode()); std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr; std::shared_ptr<TheaRenderer> renderer = std::static_pointer_cast<TheaRenderer>(MayaTo::getWorldPtr()->worldRendererPtr); MObject fileNodeObject = getConnectedFileTextureObject(MString(attName), depFn); if(fileNodeObject != MObject::kNullObj) { MFnDependencyNode fileNode(fileNodeObject); MString fileName; getString(MString("fileTextureName"), fileNode, fileName); if( fileName.length() > 1) { iblMap.bitmapFilename = fileName.asChar(); float intensity = 0.0f, rotation = 0.0f; getFloat("mtth_file_iblIntensity", fileNode, intensity); iblMap.intensity = intensity; getFloat("mtth_file_iblRotation", fileNode, rotation); iblMap.rotation = rotation; int wrapping = 0; getEnum(MString("mtth_file_iblWrapping"), fileNode, wrapping); iblMap.wrapping = (TheaSDK::IBLWrapping)wrapping; iblMap.enabled = true; return; } } iblMap.enabled = false; }
void MayaToCorona::setLogLevel() { MObject globalsObj = getRenderGlobalsNode(); if (globalsObj == MObject::kNullObj) { Logging::setLogLevel(Logging::Debug); return; } MFnDependencyNode globalsNode(globalsObj); int logLevel = getIntAttr("translatorVerbosity", globalsNode, 0); Logging::setLogLevel((Logging::LogLevel)logLevel); }
void CoronaRenderer::defineColorMapping() { float gamma = 2.2f; #if MAYA_API_VERSION > 2015 if (MColorManagementUtilities::isColorManagementEnabled()) gamma = 1.0f; #endif MFnDependencyNode depFn(getRenderGlobalsNode()); context.colorMappingData->colorTemperature = getFloatAttr("colorMapping_colorTemperature", depFn, 6500.0f); context.colorMappingData->contrast = getFloatAttr("colorMapping_contrast", depFn, 1.0f); context.colorMappingData->gamma = gamma; context.colorMappingData->tint = toCorona(getColorAttr("colorMapping_tint", depFn)); context.colorMappingData->exposure.simple.exponent = getFloatAttr("colorMapping_simpleExposure", depFn, 0.0f); context.colorMappingData->highlightCompression = getFloatAttr("colorMapping_highlightCompression", depFn, 1.0f); context.colorMappingData->photographicExposure = getEnumInt("exposure_type", depFn) == 1; // release 0.39 override camera settings if (context.colorMappingData->photographicExposure) { context.colorMappingData->exposure.photographic.fStop = getFloatAttr("colorMapping_fStop", depFn, 5.6); context.colorMappingData->exposure.photographic.iso = getFloatAttr("colorMapping_iso", depFn, 100.0); context.colorMappingData->exposure.photographic.shutterSpeed = 1.0f / getFloatAttr("colorMapping_shutterSpeed", depFn, 250.0f); std::shared_ptr<MayaScene> mayaScene = MayaTo::getWorldPtr()->worldScenePtr; for (auto cam : mayaScene->camList) { if (!isCameraRenderable(cam->mobject) && (!(cam->dagPath == mayaScene->uiCamera))) continue; MFnDependencyNode camFn(cam->mobject); if (getBoolAttr("mtco_overrideRenderSettings", camFn, false)) { context.settings->set(Corona::PARAM_COLORMAP_ISO, getFloatAttr("mtco_iso", camFn, 1.0)); context.settings->set(Corona::PARAM_COLORMAP_F_STOP, getFloatAttr("fStop", camFn, 5.6)); context.settings->set(Corona::PARAM_COLORMAP_SHUTTER_SPEED, 1.0f / getFloatAttr("mtco_shutterSpeed", camFn, 250.0f)); } } } }
// during creation, the renderGlobals class initializes itself with the // necessaray information from the defaultRenderGlobals node // All additional information should be done in a derived class RenderGlobals::RenderGlobals() { Logging::debug("RenderGlobals::RenderGlobals()"); this->good = false; this->currentRenderPass = nullptr; this->currentRenderPassElementId = 0; this->maxTraceDepth = 4; this->doMb = false; this->doDof = false; this->mbStartTime = 0.0f; this->mbEndTime = 0.0f; this->currentFrame = 0.0f; this->currentFrameNumber = 0.0f; this->motionBlurRange = 0.4f; this->motionBlurType = 0; // center this->xftimesamples = 2; this->geotimesamples = 2; this->createDefaultLight = false; this->exportSceneFile = false; this->adaptiveSampling = false; this->imageName = ""; this->basePath = ""; this->exportSceneFileName = ""; this->useSunLightConnection = false; this->imagePath = ""; this->getDefaultGlobals(); this->imageFormatString = getEnumString(MString("imageFormat"), MFnDependencyNode(getRenderGlobalsNode())); this->internalUnit = MDistance::internalUnit(); this->internalAxis = MGlobal::isYAxisUp() ? YUp : ZUp; this->scaleFactor = 1.0f; this->setRendererUnit(); this->setRendererAxis(); this->defineGlobalConversionMatrix(); this->currentFrameIndex = 0; this->sceneScale = 1.0; this->filterSize = 3.0; }
bool isSunLight(MObject& obj) { MObjectArray nodeList; MStatus stat; MObject sun = obj; if (obj.hasFn(MFn::kDirectionalLight)) { MFnDagNode sunDagNode(obj); sun = sunDagNode.parent(0); } getConnectedInNodes(MString("physicalSunConnection"), getRenderGlobalsNode(), nodeList); if (nodeList.length() > 0) { MObject sunObj = nodeList[0]; if (sunObj.hasFn(MFn::kTransform)) { if (sunObj == sun) return true; } } return false; }
void CoronaRenderer::updateLight(std::shared_ptr<MayaObject> mobj) { std::shared_ptr<mtco_MayaObject> obj(std::static_pointer_cast<mtco_MayaObject>(mobj)); if (obj->lightShader != nullptr) { if (this->context.scene->hasLightShader(obj->lightShader)) this->context.scene->deleteLightShader(obj->lightShader); } if (obj->removed) return; if (MayaTo::getWorldPtr()->renderType == MayaTo::MayaToWorld::WorldRenderType::IPRRENDER) { obj->transformMatrices.clear(); obj->transformMatrices.push_back(obj->dagPath.inclusiveMatrix()); } MFnDependencyNode rGlNode(getRenderGlobalsNode()); MObject coronaGlobals = getRenderGlobalsNode(); std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr; std::shared_ptr<MayaScene> mayaScene = MayaTo::getWorldPtr()->worldScenePtr; MObjectArray nodeList; MStatus stat; MFnDependencyNode glFn(getRenderGlobalsNode()); Corona::Rgb bgRgb = toCorona(getColorAttr("bgColor", glFn)); int bgType = getEnumInt("bgType", glFn); MayaObject *sunLight = nullptr; 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] * 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 / renderGlobals->scaleFactor; pl->lightColor = Corona::Rgb(col.r, col.g, col.b); pl->lightIntensity = intensity; getEnum(MString("decayRate"), depFn, pl->decayType); pl->lightRadius = getFloatAttr("lightRadius", depFn, 0.0) * renderGlobals->scaleFactor; pl->doShadows = getBoolAttr("useRayTraceShadows", depFn, true); col = getColorAttr("shadowColor", depFn); pl->shadowColor = Corona::Rgb(col.r, col.g, col.b); for (auto excludedObj : obj->excludedObjects) { pl->excludeList.nodes.push(excludedObj.get()); } this->context.scene->addLightShader(pl); obj->lightShader = 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] * renderGlobals->globalConversionMatrix; lightDir *= obj->transformMatrices[0] * 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 / renderGlobals->scaleFactor; getEnum(MString("decayRate"), depFn, sl->decayType); getFloat("coneAngle", depFn, sl->angle); getFloat("penumbraAngle", depFn, sl->penumbraAngle); getFloat("dropoff", depFn, sl->dropoff); sl->lightRadius = getFloatAttr("lightRadius", depFn, 0.0) * renderGlobals->scaleFactor; sl->doShadows = getBoolAttr("useRayTraceShadows", depFn, true); col = getColorAttr("shadowColor", depFn); sl->shadowColor = Corona::Rgb(col.r, col.g, col.b); for (auto excludedObj : obj->excludedObjects) { sl->excludeList.nodes.push(excludedObj.get()); } Corona::AffineTm tm; setTransformationMatrix(sl->lightWorldInverseMatrix, m); ShadingNetwork network(obj->mobject); sl->lightColorMap = defineAttribute(MString("color"), depFn, network, oslRenderer); this->context.scene->addLightShader(sl); obj->lightShader = sl; } if (obj->mobject.hasFn(MFn::kDirectionalLight)) { if (getBoolAttr("mtco_useAsSun", depFn, false)) { if (sunLight != nullptr) { Logging::error(MString("A sun light is already defined, ignoring ") + obj->shortName); return; } sunLight = obj.get(); MVector lightDir(0, 0, 1); // default dir light dir lightDir *= obj->transformMatrices[0]; lightDir *= renderGlobals->globalConversionMatrix; lightDir.normalize(); MColor sunColor(1); MFnDependencyNode sunNode(obj->mobject); getColor("color", sunNode, sunColor); sunColor *= getFloatAttr("intensity", sunNode, 1.0f); //float colorMultiplier colorMultiplier = getFloatAttr("mtco_sun_multiplier", sunNode, 1.0f); const float intensityFactor = (1.f - cos(Corona::SUN_PROJECTED_HALF_ANGLE)) / (1.f - cos(getFloatAttr("sunSizeMulti", rGlNode, 1.0f) * Corona::SUN_PROJECTED_HALF_ANGLE)); sunColor *= intensityFactor * 1.0;// 2000000; Corona::Sun sun; Corona::ColorOrMap bgCoMap = this->context.scene->getBackground(); SkyMap *sky = dynamic_cast<SkyMap *>(bgCoMap.getMap()); Corona::Rgb avgColor(1, 1, 1); if (sky != nullptr) { avgColor = sky->sc(); } Corona::Rgb sColor(sunColor.r, sunColor.g, sunColor.b); sun.color = sColor * avgColor; 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 = getFloatAttr("sunSizeMulti", rGlNode, 1.0); this->context.scene->getSun() = sun; if (sky != nullptr) { sky->initSky(); this->context.scene->setBackground(bgCoMap); avgColor = sky->sc(); this->context.scene->getSun().color = sColor * avgColor; } } else{ MVector lightDir(0, 0, -1); MVector lightDirTangent(1, 0, 0); MVector lightDirBiTangent(0, 1, 0); MColor col; getColor("color", depFn, col); float intensity = 1.0f; getFloat("intensity", depFn, intensity); MMatrix m = obj->transformMatrices[0] * renderGlobals->globalConversionMatrix; lightDir *= m; lightDirTangent *= m; lightDirBiTangent *= 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); dl->LT = Corona::Dir(lightDirTangent.x, lightDirTangent.y, lightDirTangent.z); dl->LBT = Corona::Dir(lightDirBiTangent.x, lightDirBiTangent.y, lightDirBiTangent.z); dl->lightAngle = getFloatAttr("lightAngle", depFn, 0.0); dl->doShadows = getBoolAttr("useRayTraceShadows", depFn, true); col = getColorAttr("shadowColor", depFn); dl->shadowColor = Corona::Rgb(col.r, col.g, col.b); for (auto excludedObj : obj->excludedObjects) { dl->excludeList.nodes.push(excludedObj.get()); } this->context.scene->addLightShader(dl); obj->lightShader = dl; } } if (obj->mobject.hasFn(MFn::kAreaLight)) { MMatrix m = obj->transformMatrices[0] * renderGlobals->globalConversionMatrix; if ( obj->geom == nullptr) obj->geom = defineStdPlane(); obj->geom->deleteAllInstances(); Corona::AnimatedAffineTm atm; this->setAnimatedTransformationMatrix(atm, obj); obj->instance = obj->geom->addInstance(atm, nullptr, nullptr); if (getBoolAttr("mtco_envPortal", depFn, false)) { Corona::EnviroPortalMtlData data; Corona::SharedPtr<Corona::IMaterial> mat = data.createMaterial(); Corona::IMaterialSet ms = Corona::IMaterialSet(mat); obj->instance->addMaterial(ms); } else{ Corona::NativeMtlData data; MColor lightColor = getColorAttr("color", depFn); float intensity = getFloatAttr("intensity", depFn, 1.0f); lightColor *= intensity; Corona::ColorOrMap com; // experimental direct corona texture if (getBoolAttr("mtco_noOSL", depFn, false)) { MObject fileNode = getConnectedInNode(obj->mobject, "color"); if ((fileNode != MObject::kNullObj) && (fileNode.hasFn(MFn::kFileTexture))) { MFnDependencyNode fileDep(fileNode); mtco_MapLoader loader(fileNode); Corona::SharedPtr<Corona::Abstract::Map> texmap = loader.loadBitmap(""); com = Corona::ColorOrMap(bgRgb, texmap); } } else { com = defineAttribute(MString("color"), obj->mobject, oslRenderer); OSLMap *oslmap = (OSLMap *)com.getMap(); if (oslmap != nullptr) { oslmap->multiplier = intensity; } else{ Corona::Rgb col = com.getConstantColor() * intensity; com.setColor(col); } } data.emission.color = com; data.castsShadows = getBoolAttr("mtco_castShadows", depFn, false); for (auto excludedObj : obj->excludedObjects) { data.emission.excluded.nodes.push(excludedObj.get()); } data.emission.disableSampling = false; data.emission.useTwoSidedEmission = getBoolAttr("mtco_doubleSided", depFn, false); Corona::SharedPtr<Corona::IMaterial> mat = data.createMaterial(); Corona::IMaterialSet ms = Corona::IMaterialSet(mat); ms.visibility.direct = getBoolAttr("mtco_areaVisible", depFn, true); ms.visibility.reflect = getBoolAttr("mtco_visibleInReflection", depFn, true); ms.visibility.refract = getBoolAttr("mtco_visibleInRefraction", depFn, true); obj->instance->addMaterial(ms); } } }
bool RenderGlobals::getDefaultGlobals() { MSelectionList defaultGlobals; defaultGlobals.add("defaultRenderGlobals"); if( defaultGlobals.length() == 0 ) { Logging::debug("defaultRenderGlobals not found. Stopping."); return false; } MCommonRenderSettingsData data; MRenderUtil::getCommonRenderSettings(data); MObject node; defaultGlobals.getDependNode(0, node); MFnDependencyNode fnRenderGlobals(node); MTime tv = MAnimControl::currentTime(); this->currentFrameNumber = (float)(tv.value()); tv = data.frameStart; this->startFrame = (float)(tv.value()); tv = data.frameEnd; this->endFrame = (float)(tv.value()); tv = data.frameBy; this->byFrame = (float)(tv.value()); // check if we are in a batch render mode or if we are rendering from UI if( MGlobal::mayaState() == MGlobal::kBatch ) { this->inBatch = true; if( data.isAnimated() ) { Logging::debug(MString("animation on, rendering frame sequence from ") + this->startFrame + " to " + this->endFrame); // these are the frames that are supposed to be rendered in batch mode this->doAnimation = true; for( double frame = this->startFrame; frame <= this->endFrame; frame += this->byFrame) this->frameList.push_back((float)frame); }else{ Logging::debug(MString("animation off, rendering current frame")); this->frameList.push_back(this->currentFrameNumber ); this->doAnimation = false; } }else{ // we are rendering from the UI so only render the current frame this->inBatch = false; this->frameList.push_back(this->currentFrameNumber ); this->doAnimation = false; // at the moment, if rendering comes from UI dont do animation } this->imgHeight = data.height; this->imgWidth = data.width; this->pixelAspect = data.pixelAspectRatio; this->regionLeft = 0; this->regionRight = this->imgWidth; this->regionBottom = 0; this->regionTop = this->imgHeight; regionLeft = getIntAttr("left", fnRenderGlobals, 0); regionRight = getIntAttr("rght", fnRenderGlobals, imgWidth); regionBottom = getIntAttr("bot", fnRenderGlobals, 0); regionTop = getIntAttr("top", fnRenderGlobals, imgHeight); getBool(MString("enableDefaultLight"), fnRenderGlobals, this->createDefaultLight); getString(MString("preRenderMel"), fnRenderGlobals, this->preFrameScript); getString(MString("postRenderMel"), fnRenderGlobals, this->postFrameScript); getString(MString("preRenderLayerMel"), fnRenderGlobals, this->preRenderLayerScript); getString(MString("postRenderLayerMel"), fnRenderGlobals, this->postRenderLayerScript); MFnDependencyNode depFn(getRenderGlobalsNode()); this->maxTraceDepth = getIntAttr("maxTraceDepth", depFn, 4); this->doMb = getBoolAttr("doMotionBlur", depFn, false); this->doDof = getBoolAttr("doDof", depFn, false); this->motionBlurRange = getFloatAttr("motionBlurRange", depFn, 0.4f); this->motionBlurType = 0; // center this->xftimesamples = getIntAttr("xftimesamples", depFn, 2); this->geotimesamples = getIntAttr("geotimesamples", depFn, 2); this->createDefaultLight = false; this->renderType = RenderType::FINAL; this->exportSceneFile = getBoolAttr("exportSceneFile", depFn, false); this->adaptiveSampling = getBoolAttr("adaptiveSampling", depFn, false); this->imageName = getStringAttr("imageName", depFn, ""); this->basePath = getStringAttr("basePath", depFn, ""); this->exportSceneFileName = getStringAttr("exportSceneFileName", depFn, ""); this->imagePath = getStringAttr("imagePath", depFn, ""); this->threads = getIntAttr("threads", depFn, 4); this->translatorVerbosity = getEnumInt("translatorVerbosity", depFn); this->rendererVerbosity = getEnumInt("rendererVerbosity", depFn); this->useSunLightConnection = getBoolAttr("useSunLightConnection", depFn, false); this->tilesize = getIntAttr("tileSize", depFn, 64); this->sceneScale = getFloatAttr("sceneScale", depFn, 1.0f); this->filterSize = getFloatAttr("filterSize", depFn, 3.0f); this->good = true; return true; }
void CoronaRenderer::defineSettings() { MFnDependencyNode depFn(getRenderGlobalsNode()); std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr; int w = renderGlobals->getWidth(); int h = renderGlobals->getHeight(); context.settings->set(Corona::PARAM_IMAGE_WIDTH, w); context.settings->set(Corona::PARAM_IMAGE_HEIGHT, h); if (MayaTo::getWorldPtr()->renderType == MayaTo::MayaToWorld::WorldRenderType::IPRRENDER) context.settings->set(Corona::PARAM_MINIMIZE_PRECOMP, true); if (getBoolAttr("lockSamplingPattern",depFn, false)) context.settings->set(Corona::PARAM_RANDOM_SEED, 1234); else context.settings->set(Corona::PARAM_RANDOM_SEED, 0); if (renderGlobals->getUseRenderRegion()) { int left, bottom, right, top; renderGlobals->getRenderRegion(left, bottom, right, top); context.settings->set(Corona::PARAM_IMAGE_REGION_START_X, left); context.settings->set(Corona::PARAM_IMAGE_REGION_START_Y, bottom); context.settings->set(Corona::PARAM_IMAGE_REGION_END_X, right); context.settings->set(Corona::PARAM_IMAGE_REGION_END_Y, top); } int renderer = getIntAttr("renderer", depFn, 0); if( renderer == 0) // progressive context.settings->set(Corona::PARAM_RENDER_ENGINE, Corona::RENDER_ENGINE_PROGRESSIVE); if( renderer == 1) // bucket rendering context.settings->set(Corona::PARAM_RENDER_ENGINE, Corona::RENDER_ENGINE_BUCKET); if( renderer == 2) // vcm rendering context.settings->set(Corona::PARAM_RENDER_ENGINE, Corona::RENDER_ENGINE_VCM); //context.settings->set(Corona::PARAM_RESUME_RENDERING, false); context.settings->set(Corona::PARAM_BUCKET_SIZE, getIntAttr("image_bucketSize", depFn, 64)); context.settings->set(Corona::PARAM_BUCKET_SAMPLES_PER_ITERATION, getIntAttr("buckets_initialSamples", depFn, 4)); context.settings->set(Corona::PARAM_BUCKET_PASSES, getIntAttr("buckets_adaptiveSteps", depFn, 4)); context.settings->set(Corona::PARAM_BUCKET_ADAPTIVE_THRESHOLD, getFloatAttr("buckets_adaptiveThreshold", depFn, 0.03f)); context.settings->set(Corona::PARAM_PROGRESSIVE_PASS_LIMIT, getIntAttr("progressive_maxPasses", depFn, 0)); context.settings->set(Corona::PARAM_PROGRESSIVE_TIME_LIMIT, getIntAttr("progressive_timeLimit", depFn, 60) * 1000); context.settings->set(Corona::PARAM_VCM_MODE, getEnumInt("vcm_mode", depFn)); context.settings->set(Corona::PARAM_PPM_INITIAL_RADIUS, getFloatAttr("ppm_initialRadius", depFn, 2.0f)); //context.settings->set(Corona::PARAM_BIDIR_DO_MIS, getBoolAttr("bidir_doMis", depFn, true)); context.settings->set(Corona::PARAM_PPM_PHOTONS_PER_ITER, getIntAttr("ppm_photonsPerIter", depFn, 5000000)); context.settings->set(Corona::PARAM_PPM_ALPHA, getFloatAttr("ppm_alpha", depFn, .666f)); context.settings->set(Corona::PARAM_MAX_SAMPLE_INTENSITY, getFloatAttr("maxPtSampleIntensity", depFn, 20.0f)); context.settings->set(Corona::PARAM_NUM_THREADS, getIntAttr("threads", depFn, 4)); if (getBoolAttr("exportSceneFile", depFn, false)) context.settings->set(Corona::PARAM_EXPORT_PATH, renderGlobals->exportSceneFileName.asChar()); context.settings->set(Corona::PARAM_THREAD_PRIORITY, Corona::IScheduler::PRIORITY_BELOW_NORMAL); // always render with low priority Corona::DisplaceSubdivType subdivTypes[] = { Corona::DisplaceSubdivType::DISPLACE_SUBDIV_WORLD, Corona::DisplaceSubdivType::DISPLACE_SUBDIV_PROJECTED }; context.settings->set(Corona::PARAM_DISPLACE_SUBDIV_TYPE, subdivTypes[(int)getBoolAttr("displace_useProjectionSize", depFn, true)]); context.settings->set(Corona::PARAM_DISPLACE_MAX_SIZE_SCREEN, getFloatAttr("displace_maxProjectSize", depFn, 2.0f)); context.settings->set(Corona::PARAM_DISPLACE_MAX_SIZE_WORLD, getFloatAttr("displace_maxWorldSize", depFn, 1.0f)); context.settings->set(Corona::PARAM_MAX_RAY_DEPTH, getIntAttr("raycaster_maxDepth", depFn, 25)); context.settings->set(Corona::PARAM_MIN_INSTANCE_SAVING, getIntAttr("instance_minSize", depFn, 50000)); int f = getEnumInt("filtertype", depFn); float fw = getFloatAttr("imagefilter_width", depFn, 1.5f); float fb = getFloatAttr("imagefilter_blurring", depFn, .5f); context.settings->set(Corona::PARAM_IMAGEFILTER, getEnumInt("filtertype", depFn)); context.settings->set(Corona::PARAM_IMAGEFILTER_WIDTH, getFloatAttr("imagefilter_width", depFn, 1.5f)); context.settings->set(Corona::PARAM_IMAGEFILTER_BLURRING, getFloatAttr("imagefilter_blurring", depFn, .5f)); context.settings->set(Corona::PARAM_SHADING_ENABLE, getBoolAttr("doShading", depFn, true)); Corona::GiSolverType solverTypes[] = { Corona::GiSolverType::GISOLVER_NONE, Corona::GiSolverType::GISOLVER_PATHTRACING, Corona::GiSolverType::GISOLVER_HD_CACHE, Corona::GiSolverType::GISOLVER_UHD_CACHE }; context.settings->set(Corona::PARAM_SHADING_PRIMARY_SOLVER, solverTypes[getEnumInt("gi_primarySolver", depFn)]); context.settings->set(Corona::PARAM_SHADING_SECONDARY_SOLVER, solverTypes[getEnumInt("gi_secondarySolver", depFn)]); context.settings->set(Corona::PARAM_GI_TO_AA_RATIO, getIntAttr("pathtracingSamples", depFn, 16)); //context.settings->set(Corona::PARAM_LIGHT_SAMPLES_MULT, getFloatAttr("lights_areaSamplesMult", depFn, 2.0f)); context.settings->set(Corona::PARAM_HDCACHE_SAVE, getBoolAttr("gi_saveSecondary", depFn, false)); context.settings->set(Corona::PARAM_HDCACHE_PRECALC_MODE, getEnumInt("gi_hdCache_precalcMode", depFn)); context.settings->set(Corona::PARAM_HDCACHE_FILE, Corona::String(getStringAttr("gi_secondaryFile", depFn, "").asChar())); context.settings->set(Corona::PARAM_HDCACHE_PRECOMP_DENSITY, getFloatAttr("gi_hdCache_precompMult", depFn, 1.0f)); context.settings->set(Corona::PARAM_HDCACHE_INTERPOLATION_COUNT, getIntAttr("gi_hdCache_interpolationCount", depFn, 3)); context.settings->set(Corona::PARAM_HDCACHE_RECORD_QUALITY, getIntAttr("gi_hdCache_ptSamples", depFn, 256)); context.settings->set(Corona::PARAM_HDCACHE_SMOOTHING, getFloatAttr("gi_hdCache_smoothing", depFn, 2.0f)); context.settings->set(Corona::PARAM_HDCACHE_MAX_RECORDS, getIntAttr("gi_hdCache_maxRecords", depFn, 100000)); context.settings->set(Corona::PARAM_HDCACHE_GLOSS_THRESHOLD, getFloatAttr("gi_hdCache_glossyThreshold", depFn, .9f)); context.settings->set(Corona::PARAM_HDCACHE_WRITABLE_PASSES, getIntAttr("gi_hdCache_writePasses", depFn, 0)); context.settings->set(Corona::PARAM_HDCACHE_DIR_SENSITIVITY, getFloatAttr("gi_hdCache_dirSensitivity", depFn, 2.0f)); context.settings->set(Corona::PARAM_HDCACHE_POS_SENSITIVITY, getFloatAttr("gi_hdCache_posSensitivity", depFn, 20.0f)); context.settings->set(Corona::PARAM_HDCACHE_NORMAL_SENSITIVITY, getFloatAttr("gi_hdCache_normalSensitivity", depFn, 3.0f)); float uhd_precision = getFloatAttr("uhdPrecision", depFn, 1.0f); context.settings->set(Corona::PARAM_UHDCACHE_PRECISION, uhd_precision); int uhd_recordQuality = 512; float uhd_strictness = 0.075f; float uhd_msi = 3.0f; int uhdType = getEnumInt("uhdCacheType", depFn); if (getEnumInt("gi_secondarySolver", depFn) == 4) // uhd cache { // 0 == still, 1 == animation. Only animation needs not default settings. if (uhdType == 1) { context.settings->set(Corona::PARAM_UHDCACHE_MSI, uhd_msi * 3.0f); context.settings->set(Corona::PARAM_UHDCACHE_RECORD_QUALITY, uhd_recordQuality * .5f); context.settings->set(Corona::PARAM_UHDCACHE_STRICTNESS, uhd_strictness * .33f); context.settings->set(Corona::PARAM_UHDCACHE_PRECISION, uhd_precision * .4f); } } float gamma = 2.2f; #if MAYA_API_VERSION > 2015 if (MColorManagementUtilities::isColorManagementEnabled()) gamma = 1.0f; #endif context.settings->set(Corona::PARAM_COLORMAP_GAMMA, gamma); context.settings->set(Corona::PARAM_COLORMAP_HIGHLIGHT_COMPRESSION, getFloatAttr("colorMapping_highlightCompression", depFn, 1.0f)); context.settings->set(Corona::PARAM_COLORMAP_CONTRAST, getFloatAttr("colorMapping_contrast", depFn, 1.0f)); context.settings->set(Corona::PARAM_COLORMAP_COLOR_TEMP, getFloatAttr("colorMapping_colorTemperature", depFn, 6500.0f)); context.settings->set(Corona::PARAM_COLORMAP_SIMPLE_EXPOSURE, getFloatAttr("colorMapping_simpleExposure", depFn, 0.0f)); context.settings->set(Corona::PARAM_COLORMAP_TINT, toCorona(getColorAttr("colorMapping_tint", depFn))); context.settings->set(Corona::PARAM_COLORMAP_USE_PHOTOGRAPHIC, !getBoolAttr("colorMapping_useSimpleExposure", depFn, true)); context.settings->set(Corona::PARAM_COLORMAP_ISO, getFloatAttr("colorMapping_iso", depFn, 100.0)); context.settings->set(Corona::PARAM_COLORMAP_F_STOP, getFloatAttr("colorMapping_fStop", depFn, 5.6)); context.settings->set(Corona::PARAM_COLORMAP_SHUTTER_SPEED, 1.0f / getFloatAttr("colorMapping_shutterSpeed", depFn, 250.0f)); // v2.8 exposure from camera std::shared_ptr<MayaScene> mayaScene = MayaTo::getWorldPtr()->worldScenePtr; if (mayaScene) { for (auto cam : mayaScene->camList) { if (!isCameraRenderable(cam->mobject) && (!(cam->dagPath == mayaScene->uiCamera))) continue; MFnDependencyNode camFn(cam->mobject); if (getBoolAttr("mtco_overrideRenderSettings", camFn, false)) { context.settings->set(Corona::PARAM_COLORMAP_ISO, getFloatAttr("mtco_iso", camFn, 1.0)); context.settings->set(Corona::PARAM_COLORMAP_F_STOP, getFloatAttr("fStop", camFn, 5.6)); context.settings->set(Corona::PARAM_COLORMAP_SHUTTER_SPEED, 1.0f / getFloatAttr("mtco_shutterSpeed", camFn, 250.0f)); } break; } } }
void TheaRenderer::defineEnvironment() { MFnDependencyNode gFn(getRenderGlobalsNode()); std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr; std::shared_ptr<TheaRenderer> renderer = std::static_pointer_cast<TheaRenderer>(MayaTo::getWorldPtr()->worldRendererPtr); if( renderGlobals->exportSceneFile ) { TheaSDK::XML::EnvironmentOptions env; int illumination = getEnumInt("illumination", gFn); switch (illumination) { case 0: break; case 1: // dome light { env.illumination = TheaSDK::DomeIllumination; MColor bg = getColorAttr("backgroundColor", gFn); TheaSDK::Rgb bgColor(bg.r, bg.g, bg.b); env.backgroundColor = bgColor; } break; case 2: // ibl { env.illumination = TheaSDK::IBLIllumination; defineIBLNode(env.illuminationMap, "illuminationMap"); defineIBLNode(env.backgroundMap, "backgroundMap"); defineIBLNode(env.reflectionMap, "reflectionMap"); defineIBLNode(env.refractionMap, "refractionMap"); } break; case 3: // physical sky { env.illumination = TheaSDK::PhysicalSkyIllumination; env.turbidity = getFloatAttr("turbidity", gFn, 2.5f); env.ozone = getFloatAttr("ozone", gFn, 0.35f); env.waterVapor = getFloatAttr("waterVapor", gFn, 2.0f); env.turbidityCoefficient = getFloatAttr("turbidityCoefficient", gFn, .046f); env.wavelengthExponent = getFloatAttr("wavelengthExponent", gFn, 1.3f); env.albedo = getFloatAttr("albedo", gFn, .5f); env.location = getStringAttr("location", gFn, "").asChar(); env.timezone = getIntAttr("timezone", gFn, 0); // from -12 to +12. env.date = getStringAttr("date", gFn, "").asChar(); // format dd/mm/yy. env.localtime = getStringAttr("localtime", gFn, "").asChar(); // format hh/mm/ss. env.latitude = getFloatAttr("latitude", gFn, .0f); env.longitude = getFloatAttr("longitude", gFn, .0f); env.sunDirection = this->getSunDirection(); env.sunPolarAngle = getFloatAttr("sunPolarAngle", gFn, -1.0f); // in degrees. env.sunAzimuth = getFloatAttr("sunAzimuth", gFn, -1.0f); // in degrees. } break; default: break; }; if (illumination > 0) { this->sceneXML.setEnvironmentOptions(env); } }else{ if (TheaSDK::SetRgbParameter(TheaSDK::GetGlobalSettings(),"Background Color",TheaSDK::Rgb(0.1f,0.1f,0.6f))==false) return; if (TheaSDK::SetStringParameter(TheaSDK::GetGlobalSettings(),"Background Type","Background Color")==false) return; if (TheaSDK::SetRealParameter(TheaSDK::GetGlobalSettings(),"./Sun/Polar Angle (deg)",45)==false) return ; if (TheaSDK::SetRealParameter(TheaSDK::GetGlobalSettings(),"./Sun/Azimuth (deg)",45)==false) return; if (TheaSDK::SetStringParameter(TheaSDK::GetGlobalSettings(),"Illumination","Physical Sky")==false) return; if (TheaSDK::SetIntegerParameter(TheaSDK::GetRootObject(),"GenerateSun",2)==false) return; } }
void IndigoRenderer::defineEnvironment() { std::shared_ptr<MayaScene> mayaScene = MayaTo::getWorldPtr()->worldScenePtr; std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr; MFnDependencyNode gFn(getRenderGlobalsNode()); switch (getEnumInt("environmentType", gFn)) { case 0: // off { break; } case 1: // environment light map { MString texName; bool useTexture = false; Indigo::String texturePath = ""; MObject fileTexObj; if( getConnectedFileTexturePath(MString("environmentColor"), MString("indigoGlobals"), texName, fileTexObj) ) { useTexture = true; texturePath = texName.asChar(); } MFnDependencyNode fileTexNode(fileTexObj); MColor bgColor = getColorAttr("environmentColor", gFn); int mapType = getIntAttr("environmentMapType", gFn, 0); Indigo::SceneNodeBackgroundSettingsRef background_settings(new Indigo::SceneNodeBackgroundSettings()); Reference<Indigo::DiffuseMaterial> mat(new Indigo::DiffuseMaterial()); // Albedo should be zero. mat->albedo = Reference<Indigo::WavelengthDependentParam>(new Indigo::ConstantWavelengthDependentParam(Reference<Indigo::Spectrum>(new Indigo::UniformSpectrum(0)))); Indigo::Texture texture; if( useTexture ) { texture.path = texturePath; texture.exponent = 1; // Since we will usually use a HDR image, the exponent (gamma) should be set to one. MColor colorGain(1,1,1); getColor("colorGain", fileTexNode, colorGain); MColor colorOffset(0,0,0); getColor("colorOffset", fileTexNode, colorOffset); double cg = (colorGain.r + colorGain.g + colorGain.b) / 3.0; double co = (colorOffset.r + colorOffset.g + colorOffset.b) / 3.0; texture.a = 0.0; texture.b = cg; texture.c = co; texture.tex_coord_generation = Reference<Indigo::TexCoordGenerator>(new Indigo::SphericalTexCoordGenerator(Reference<Indigo::Rotation>(new Indigo::MatrixRotation()))); if( mapType == 1 ) { texture.tex_coord_generation = Reference<Indigo::TexCoordGenerator>(new Indigo::SphericalEnvTexCoordGenerator(Reference<Indigo::Rotation>(new Indigo::MatrixRotation()))); } mat->emission = Reference<Indigo::WavelengthDependentParam>(new Indigo::TextureWavelengthDependentParam(0)); mat->textures.push_back(texture); }else{ Indigo::RGBSpectrum *iBgColor = new Indigo::RGBSpectrum(Indigo::Vec3d(bgColor.r,bgColor.g,bgColor.b), 2.2); mat->emission = Reference<Indigo::WavelengthDependentParam>(new Indigo::ConstantWavelengthDependentParam(Reference<Indigo::Spectrum>(iBgColor))); } // Base emission is the emitted spectral radiance. No effect here? double multiplier = (double)getFloatAttr("environmentMapMultiplier", gFn, 1.0) * 1000.0; mat->base_emission = Reference<Indigo::WavelengthDependentParam>(new Indigo::ConstantWavelengthDependentParam(Reference<Indigo::Spectrum>(new Indigo::UniformSpectrum(multiplier)))); background_settings->background_material = mat; sceneRootRef->addChildNode(background_settings); break; } case 2: // sun/sky { // first get the globals node and serach for a directional light connection MObjectArray nodeList; getConnectedInNodes(MString("sunLightConnection"), gFn.object(), 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() * renderGlobals->globalConversionMatrix; lightDir.normalize(); Indigo::SceneNodeBackgroundSettingsRef background_settings_node(new Indigo::SceneNodeBackgroundSettings()); Reference<Indigo::SunSkyMaterial> sun_sky_mat(new Indigo::SunSkyMaterial()); MString sky_model; int modelId; getEnum("sky_model", gFn, modelId, sky_model); sun_sky_mat->model = sky_model.asChar(); sun_sky_mat->enable_sky = true; getBool("extra_atmospheric", gFn, sun_sky_mat->extra_atmospheric); sun_sky_mat->name = "sunsky"; getUInt("sky_layer", gFn, sun_sky_mat->sky_layer); getUInt("sun_layer", gFn, sun_sky_mat->sun_layer); getDouble(MString("turbidity"), gFn, sun_sky_mat->turbidity); sun_sky_mat->sundir = Indigo::Vec3d(lightDir.x, lightDir.y, lightDir.z); // Direction to sun. background_settings_node->background_material = sun_sky_mat; sceneRootRef->addChildNode(background_settings_node); } } break; } } }
void TheaRenderer::render() { clearMaterialLists(); MFnDependencyNode depFn(getRenderGlobalsNode()); std::shared_ptr<MayaScene> scene = MayaTo::getWorldPtr()->worldScenePtr; std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr; std::shared_ptr<TheaRenderer> renderer = std::static_pointer_cast<TheaRenderer>(MayaTo::getWorldPtr()->worldRendererPtr); MString fileName = scene->getFileName(); renderGlobals->exportSceneFile = true; // trigger use of XML commands if (renderGlobals->exportSceneFile) this->sceneXML = TheaSDK::XML::Scene(fileName.asChar()); else this->scene = TheaSDK::Scene::New(fileName.asChar()); MString moduleDir = getRendererHome(); MString gpuDriver = moduleDir + "bin/Plugins/Presto/presto-x64.cuda.dll"; MString cpuDriver = moduleDir + "bin/Plugins/Presto/presto-x64.cpu.dll"; bool gpuSuccess = TheaSDK::Kernel::Root().initPrestoCUDADriver(gpuDriver.asChar()); bool cpuSuccess = TheaSDK::Kernel::Root().initPrestoCPUDriver(cpuDriver.asChar()); if( !gpuSuccess ) Logging::error("Unable to load presto gpu driver."); if( !cpuSuccess ) Logging::error("Unable to load presto cpu driver."); if(!isGood ) { EventQueue::Event e; e.type = EventQueue::Event::FRAMEDONE; theRenderEventQueue()->push(e); return; } this->defineSettings(); this->defineCamera(); this->defineGeometry(); this->defineLights(); this->defineEnvironment(); if (renderGlobals->exportSceneFile) { std::string currentFile = MFileIO::currentFile().asChar(); std::vector<std::string> parts; pystring::split(currentFile, parts, "/"); currentFile = pystring::replace(parts.back(), ".ma", ""); currentFile = pystring::replace(currentFile, ".mb", ""); MString scenePath = MString("C:/daten/3dprojects/mayaToThea/data/Thea/") + currentFile.c_str() + ".xml"; //MString scenePath = this->mtth_renderGlobals->basePath + "/Thea/" + currentFile.c_str() + ".xml"; TheaSDK::XML::Importer::Write(this->sceneXML); Logging::debug(MString("Exporting scene to: ") + scenePath); TheaSDK::SaveScene(scenePath.asChar()); } volatile bool isrendering=true; MayaTo::getWorldPtr()->setRenderState(MayaTo::MayaToWorld::WorldRenderState::RSTATERENDERING); size_t framebufferCallbackId = RenderQueueWorker::registerCallback(&framebufferCallback); // don't start asynchronus because we are in a seperate task anyway bool ok = TheaSDK::StartRendering(renderEndCallback, (void *)this, false, false); framebufferCallback(); RenderQueueWorker::unregisterCallback(framebufferCallbackId); renderGlobals->getImageName(); MString filename = renderGlobals->imageOutputFile.asChar(); std::string imgFormatExt = renderGlobals->imageOutputFile.toLowerCase().asChar(); std::vector<std::string> fileParts; pystring::split(imgFormatExt, fileParts, "."); std::string ext = fileParts.back(); Logging::debug(MString("Saving image as ") + filename); TheaSDK::SaveImage(filename.asChar()); EventQueue::Event e; e.type = EventQueue::Event::FRAMEDONE; theRenderEventQueue()->push(e); }