void IndigoRenderer::defineCamera()
{
std::shared_ptr<MayaScene> mayaScene = MayaTo::getWorldPtr()->worldScenePtr;
std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr;
for (auto mobj : mayaScene->camList)
{
std::shared_ptr<mtin_MayaObject> icam(std::static_pointer_cast<mtin_MayaObject>(mobj));
MFnCamera camFn(icam->dagPath);
float lensRadius = 0.01;
getFloat(MString("mtin_lensRadius"), camFn, lensRadius);
bool autoFocus = false;
getBool(MString("mtin_autoFocus"), camFn, autoFocus);
MVector camUp = camFn.upDirection(MSpace::kWorld);
MVector camView = camFn.viewDirection(MSpace::kWorld);
MPoint camPos = camFn.eyePoint(MSpace::kWorld);
MMatrix m = icam->transformMatrices[0];
MPoint pos, rot, scale;
getMatrixComponents(m, pos, rot, scale);
camPos *= renderGlobals->globalConversionMatrix;
camUp *= renderGlobals->globalConversionMatrix;
camView *= renderGlobals->globalConversionMatrix;
camUp.normalize();
camView.normalize();
double focusDistance = camFn.focusDistance();
double horizFilmAperture = camFn.horizontalFilmAperture();
double focalLen = camFn.focalLength();
logger.debug(MString("Using camera: ") + icam->fullName);
Indigo::SceneNodeCameraRef cam(new Indigo::SceneNodeCamera());
if( renderGlobals->doDof )
cam->lens_radius = lensRadius;
else
cam->lens_radius = lensRadius / 10000.0;
//apertureRadius = $iFocalLength / ($FStop * 2.0);
float exposureDuration = 0.333f;
getFloat("mtin_exposureDuration", camFn, exposureDuration);
cam->exposure_duration = exposureDuration;
cam->focus_distance = focusDistance * scale.x; // scale by global matrix scale
cam->lens_sensor_dist = focalLen/1000.0;
cam->autofocus = autoFocus;
//cam->lens_shift_right_distance = 0;
//cam->lens_shift_up_distance = 0;
cam->sensor_width = (horizFilmAperture * 2.54 * 10.0) / 1000.0;
cam->camera_type = Indigo::SceneNodeCamera::CameraType_ThinLensPerspective;
cam->forwards = Indigo::Vec3d(camView.x, camView.y, camView.z);
cam->up = Indigo::Vec3d(camUp.x, camUp.y, camUp.z);
cam->setPos(Indigo::Vec3d(camPos.x, camPos.y, camPos.z));
int appShape = 0;
getEnum(MString("mtin_apertureShape"), camFn, appShape);
if( appShape == 0) // circle
cam->aperture_shape = new Indigo::ApertureCircular();
if( appShape == 1) // generated
{
int numBlades = 5;
float startAngle = 0.0f;
float offset = 0.0f;
float radius = 0.0f;
getInt("mtin_numBlades", camFn, numBlades);
getFloat("mtin_startAngle", camFn, startAngle);
getFloat("mtin_bladeOffset", camFn, offset);
getFloat("mtin_bladeCurvatureRadius", camFn, radius);
cam->aperture_shape = new Indigo::ApertureGenerated(numBlades, offset, radius, startAngle);
}
if( appShape == 2) // image
{
MString fileName;
getString(MString("mtin_appFile"), camFn, fileName);
if( fileName.length() > 4)
cam->aperture_shape = new Indigo::ApertureImage(fileName.asChar());
}
sceneRootRef->addChildNode(cam);
}
}
void CoronaRenderer::defineCamera()
{
MPoint rot, pos, scale;
for(int objId = 0; objId < this->mtco_scene->camList.size(); objId++)
{
mtco_MayaObject *cam = (mtco_MayaObject *)this->mtco_scene->camList[objId];
if( !this->mtco_scene->isCameraRenderable(cam->mobject) && (!(cam->dagPath == this->mtco_scene->uiCamera)))
{
continue;
}
logger.debug(MString("using camera ") + cam->shortName);
MFnCamera camera(cam->mobject);
MPoint pos, rot, scale;
MMatrix camMatrix = cam->transformMatrices[0] * this->mtco_renderGlobals->globalConversionMatrix;
getMatrixComponents(camMatrix, pos, rot, scale);
Corona::Pos cpos(pos.x, pos.y, pos.z);
float focusDistance = 0.0;
float fStop = 0.0;
float focalLength = 35.0f;
bool dof;
float horizontalFilmAperture, verticalFilmAperture;
float coi = 100.0f;
getFloat(MString("horizontalFilmAperture"), camera, horizontalFilmAperture);
getFloat(MString("verticalFilmAperture"), camera, verticalFilmAperture);
getFloat(MString("focalLength"), camera, focalLength);
getBool(MString("depthOfField"), camera, dof);
getFloat(MString("focusDistance"), camera, focusDistance);
getFloat(MString("fStop"), camera, fStop);
getFloat(MString("centerOfInterest"), camera, coi);
focusDistance *= this->mtco_renderGlobals->scaleFactor;
MPoint coiBase(0,0,-coi);
MPoint coiTransform = coiBase * camMatrix;
//logger.debug(MString("Center of interest: ") + coi + " transformed " + coiTransform.x + " " + coiTransform.y + " " + coiTransform.z);
Corona::Pos center(coiTransform.x, coiTransform.y, coiTransform.z);
float fov = 2.0 * atan((horizontalFilmAperture * 0.5f) / (focalLength * 0.03937));
float fovDeg = fov * 57.29578;
Corona::AnimatedFloat fieldOfView(fov);
//logger.debug(MString("fov ") + fov + " deg: " + fovDeg);
//Corona::AnimatedFloat fieldOfView(Corona::DEG_TO_RAD(45.f));
Corona::CameraData cameraData;
//cameraData.type
cameraData.createPerspective(Corona::AnimatedPos(cpos), Corona::AnimatedPos(center), Corona::AnimatedDir(Corona::Dir::UNIT_Z), fieldOfView);
Corona::AnimatedFloat focalDist(focusDistance);
cameraData.perspective.focalDist = focalDist;
cameraData.perspective.fStop = fStop;
cameraData.perspective.filmWidth = this->mtco_renderGlobals->toMillimeters(horizontalFilmAperture * 2.54f * 10.0f); //film width in mm
if( dof && this->mtco_renderGlobals->doDof)
cameraData.perspective.useDof = true;
if (getBoolAttr("mtco_useBokeh", camera, false))
{
cameraData.perspective.bokeh.use = true;
cameraData.perspective.bokeh.blades = getIntAttr("mtco_blades", camera, 6);
cameraData.perspective.bokeh.bladesRotation = getIntAttr("mtco_bladeRotation", camera, 0.0);
MPlug bokehBitMapPlug = camera.findPlug("mtco_bokehBitmap");
if (!bokehBitMapPlug.isNull())
{
if (bokehBitMapPlug.isConnected())
{
MObject bitmapNode = getConnectedInNode(bokehBitMapPlug);
if (bitmapNode.hasFn(MFn::kFileTexture))
{
MFnDependencyNode bitMapFn(bitmapNode);
MPlug texNamePlug = bitMapFn.findPlug("fileTextureName");
if (!texNamePlug.isNull())
{
MString fileName = texNamePlug.asString();
logger.debug(MString("Found bokeh bitmap file: ") + fileName);
Corona::Bitmap<Corona::Rgb> bokehBitmap;
Corona::loadImage(fileName.asChar(), bokehBitmap);
cameraData.perspective.bokeh.customShape = bokehBitmap;
}
}
}
}
}
this->context.scene->getCamera() = cameraData;
}
}
