SkyMap::SkyMap(MObject sObject)
{
MFnDependencyNode depFn(sObject);
this->params = new Corona::SkyParams;
params->multiplier = getFloatAttr("pSkyMultiplier", depFn, 1.0);
int skyModel = getEnumInt("pSkyModel", depFn);
if (skyModel == 0)
params->mode = Corona::SkyModelType::MODEL_PREETHAM;
if (skyModel == 1)
params->mode = Corona::SkyModelType::MODEL_RAWAFAKE;
if (skyModel == 2)
params->mode = Corona::SkyModelType::MODEL_HOSEK;
params->groundColor = toCorona(getColorAttr("pSkyGroundColor", depFn));
params->horizonBlur = getFloatAttr("pSkyHorizBlur", depFn, .1f);
params->skyAffectGround = getBoolAttr("pSkyAffectGround", depFn, true);
params->preetham.turbidity = getFloatAttr("pSkyPreethamTurb", depFn, 2.5f);
params->rawafake.horizon = toCorona(getColorAttr("pSkyHorizon", depFn));
params->rawafake.horizon = toCorona(getColorAttr("pSkyZenith", depFn));
params->rawafake.sunBleed = getFloatAttr("pSkySunBleed", depFn, 1.0f);
params->rawafake.sunFalloff = getFloatAttr("pSkySunFalloff", depFn, 3.0f);
params->rawafake.sunGlow = getFloatAttr("pSkySunGlow", depFn, 1.0f);
params->rawafake.sunSideGlow = getFloatAttr("pSkySunSideGlow", depFn, .2f);
this->initSky();
};
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 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));
}
}
}
}
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);
}
}
}
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;
}
}
}
