void SkeletonExporter::export_camera(INode *node)
{
Control *c;
int size_key;
float camera_znear, camera_zfar;
CameraState cs;
// Interval valid = FOREVER;
ObjectState os;
CameraObject *cam;
GenCamera *gencam;
float roll0;
Matrix3 mat;
Point3 row;
os = node->EvalWorldState(0);
cam = (CameraObject *)os.obj;
gencam = (GenCamera *)os.obj;
if (gencam->Type() != TARGETED_CAMERA)
{
fprintf(fTXT, "Only targeted camera are supported!\n\n");
return;
}
fprintf(fTXT, "Targeted camera found\n");
write_chunk_header(fA3D, TARGETED_CAMERA_ID, node->GetName(), 40);
if (makeRAY) write_chunk_header(fRAY, TARGETED_CAMERA_ID, node->GetName(), 40);
INode* target = node->GetTarget();
fprintf(fTXT, "Name : %s\n", node->GetName());
cam->EvalCameraState(0, FOREVER, &cs);
// ------------------ salviamo znear e zfar ----------------------
camera_znear=2;
camera_zfar=2000;
if (cs.manualClip)
{
camera_znear=cs.hither;
camera_zfar=cs.yon;
}
fprintf(fTXT, "Znear = %f \n", camera_znear);
fwrite(&camera_znear, sizeof(float), 1, fA3D);
if (makeRAY) fwrite(&camera_znear, sizeof(float), 1, fRAY);
fprintf(fTXT, "Zfar = %f \n", camera_zfar);
fwrite(&camera_zfar, sizeof(float), 1, fA3D);
if (makeRAY) fwrite(&camera_zfar, sizeof(float), 1, fRAY);
// ----------------- salviamo l'angolo di FOV --------------------
fprintf(fTXT, "FOV (rad) = %f \n", cs.fov);
fwrite(&cs.fov, sizeof(float), 1, fA3D);
if (makeRAY) fwrite(&cs.fov, sizeof(float), 1, fRAY);
// ------------------ salviamo l'angolo di roll ------------------
c=node->GetTMController()->GetRollController();
c->GetValue(0, &roll0, FOREVER);
fprintf(fTXT, "Roll (rad) = %f \n", roll0);
fwrite(&roll0, sizeof(float), 1, fA3D);
if (makeRAY) fwrite(&roll0, sizeof(float), 1, fRAY);
// salviamo la posizione nel mondo
mat = node->GetNodeTM(0);
row = mat.GetRow(3);
fprintf(fTXT, "Camera world position : x=%f, y=%f, z=%f\n", row.x, row.y, row.z);
write_point3(&row, fA3D);
if (makeRAY) write_point3(&row, fRAY);
// --------- salviamo la posizione del target nel mondo ----------
if (target)
{
mat = target->GetNodeTM(0);
row = mat.GetRow(3);
fprintf(fTXT, "Target world position : x=%f, y=%f, z=%f\n", row.x, row.y, row.z);
write_point3(&row, fA3D);
if (makeRAY) write_point3(&row, fRAY);
}
// esportiamo l'animazione della posizione della camera
// se ci sono un numero di key > 0
c=node->GetTMController()->GetPositionController();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=36;
else
if (IsBezierControl(c)) size_key=40;
else size_key=16;
fprintf(fTXT, "Camera position track present.");
write_chunk_header(fA3D, POSITION_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_point3_track(c, 1, fA3D);
if (makeRAY) write_chunk_header(fRAY, POSITION_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
if (makeRAY) export_point3_track(c, 1, fRAY);
}
// ----- esportiamo l'animazione della posizione del target ------
if (target)
{
c=target->GetTMController()->GetPositionController();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=36;
else
if (IsBezierControl(c)) size_key=40;
else size_key=16;
fprintf(fTXT, "Target position track present.");
write_chunk_header(fA3D, CAMERA_TARGET_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_point3_track(c, 1, fA3D);
if (makeRAY) write_chunk_header(fRAY, CAMERA_TARGET_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
if (makeRAY) export_point3_track(c, 1, fRAY);
}
}
// --------------- esportiamo le tracce di FOV -------------------
c=gencam->GetFOVControl();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=28;
else
if (IsBezierControl(c)) size_key=16;
else size_key=8;
fprintf(fTXT, "Camera FOV track present.");
write_chunk_header(fA3D, CAMERA_FOV_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_float_track(c, 1, fA3D); // radianti
if (makeRAY) write_chunk_header(fRAY, CAMERA_FOV_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
if (makeRAY) export_float_track(c, 1, fRAY); // radianti
}
// --------------- esportiamo le tracce di roll ------------------
c=node->GetTMController()->GetRollController();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=28;
else
if (IsBezierControl(c)) size_key=16;
else size_key=8;
fprintf(fTXT, "Camera roll track present.");
write_chunk_header(fA3D, CAMERA_ROLL_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_float_track(c, 1, fA3D); // radianti
if (makeRAY) write_chunk_header(fRAY, CAMERA_ROLL_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
if (makeRAY) export_float_track(c, 1, fRAY); // radianti
}
fprintf(fTXT, "\n\n--------------------------------------------------\n");
}
//------------------------------
GenCamera* CameraImporter::createCamera( const COLLADAFW::Camera* camera )
{
// TODO TARGETED_CAMERA
GenCamera* maxCamera = getMaxImportInterface()->CreateCameraObject( FREE_CAMERA );
float targetDistance = 100; // we don't have a target, therefore we need to set anything
maxCamera->SetTDist(0, targetDistance);
if (camera->getCameraType() == COLLADAFW::Camera::PERSPECTIVE)
{
// Perspective camera
maxCamera->SetOrtho(FALSE);
switch ( camera->getDescriptionType() )
{
case COLLADAFW::Camera::SINGLE_X:
case COLLADAFW::Camera::X_AND_Y:
case COLLADAFW::Camera::ASPECTRATIO_AND_X:
maxCamera->SetFOVType(0);
maxCamera->SetFOV(0, COLLADABU::Math::Utils::degToRadF( (float)camera->getXFov()));
break;
case COLLADAFW::Camera::SINGLE_Y:
case COLLADAFW::Camera::ASPECTRATIO_AND_Y:
{
float aspectRatio = getMaxInterface()->GetRendImageAspect();
maxCamera->SetFOVType(1);
float yfov = COLLADABU::Math::Utils::degToRadF( (float)camera->getYFov());
float xfov = 2 * atan( aspectRatio * tan(yfov/2));
maxCamera->SetFOV(0, xfov);
break;
}
}
}
else
{
// Orthographic camera
maxCamera->SetOrtho(TRUE);
// Consider only the correct magnification and the target distance,
// which is kept constant, to calculate the FOV.
switch ( camera->getDescriptionType() )
{
case COLLADAFW::Camera::SINGLE_X:
case COLLADAFW::Camera::X_AND_Y:
case COLLADAFW::Camera::ASPECTRATIO_AND_X:
{
maxCamera->SetFOVType(0);
float fov = 2 * (float)atan( camera->getXMag()/targetDistance );
maxCamera->SetFOV(0, fov);
break;
}
case COLLADAFW::Camera::SINGLE_Y:
case COLLADAFW::Camera::ASPECTRATIO_AND_Y:
{
float aspectRatio = getMaxInterface()->GetRendImageAspect();
maxCamera->SetFOVType(1);
float yfov = 2 * (float)atan( camera->getYMag()/targetDistance );
float xfov = 2 * atan( aspectRatio * tan(yfov/2));
maxCamera->SetFOV(0, xfov );
break;
}
}
}
// Common camera parameters: nearZ, farZ
// The "Far Clip " animatable parameter intentionally has an extra space in the definition.
maxCamera->SetClipDist(0, CAM_HITHER_CLIP, (float)camera->getNearClippingPlane());
maxCamera->SetClipDist(0, CAM_YON_CLIP, (float)camera->getFarClippingPlane());
maxCamera->SetManualClip(TRUE);
maxCamera->Enable(TRUE);
return maxCamera;
}
int AlembicImport_Camera(const std::string& path, AbcG::IObject& iObj,
alembic_importoptions& options, INode** pMaxNode)
{
const std::string& identifier = iObj.getFullName();
if (!AbcG::ICamera::matches(iObj.getMetaData())) {
return alembic_failure;
}
AbcG::ICamera objCamera = AbcG::ICamera(iObj, Abc::kWrapExisting);
if (!objCamera.valid()) {
return alembic_failure;
}
bool isConstant = objCamera.getSchema().isConstant();
TimeValue zero(0);
INode* pNode = *pMaxNode;
CameraObject* pCameraObj = NULL;
if (!pNode) {
// Create the camera object and place it in the scene
GenCamera* pGenCameraObj =
GET_MAX_INTERFACE()->CreateCameraObject(FREE_CAMERA);
if (pGenCameraObj == NULL) {
return alembic_failure;
}
pGenCameraObj->Enable(TRUE);
pGenCameraObj->SetConeState(TRUE);
pGenCameraObj->SetManualClip(TRUE);
IMultiPassCameraEffect* pCameraEffect =
pGenCameraObj->GetIMultiPassCameraEffect();
const int TARGET_DISTANCE = 0;
pCameraEffect->GetParamBlockByID(0)->SetValue(TARGET_DISTANCE, zero, FALSE);
pCameraObj = pGenCameraObj;
Abc::IObject parent = iObj.getParent();
std::string name = removeXfoSuffix(parent.getName().c_str());
pNode = GET_MAX_INTERFACE()->CreateObjectNode(
pGenCameraObj, EC_UTF8_to_TCHAR(name.c_str()));
if (pNode == NULL) {
return alembic_failure;
}
*pMaxNode = pNode;
}
else {
Object* obj = pNode->EvalWorldState(zero).obj;
if (obj->CanConvertToType(Class_ID(SIMPLE_CAM_CLASS_ID, 0))) {
pCameraObj = reinterpret_cast<CameraObject*>(
obj->ConvertToType(zero, Class_ID(SIMPLE_CAM_CLASS_ID, 0)));
}
else if (obj->CanConvertToType(Class_ID(LOOKAT_CAM_CLASS_ID, 0))) {
pCameraObj = reinterpret_cast<CameraObject*>(
obj->ConvertToType(zero, Class_ID(LOOKAT_CAM_CLASS_ID, 0)));
}
else {
return alembic_failure;
}
}
// Fill in the mesh
// alembic_fillcamera_options dataFillOptions;
// dataFillOptions.pIObj = &iObj;
// dataFillOptions.pCameraObj = pCameraObj;
// dataFillOptions.dTicks = GET_MAX_INTERFACE()->GetTime();
// AlembicImport_FillInCamera(dataFillOptions);
// printAnimatables(pCameraObj);
Interval interval = FOREVER;
AlembicFloatController* pControl = NULL;
{
std::string prop("horizontalFOV");
if (options.attachToExisting) {
pControl = getController(pCameraObj, identifier, prop, 0, 0);
}
if (pControl) {
pControl->GetParamBlockByID(0)->SetValue(
GetParamIdByName(pControl, 0, "path"), zero,
EC_UTF8_to_TCHAR(path.c_str()));
}
else if (assignController(createFloatController(path, identifier, prop),
pCameraObj, 0, 0) &&
!isConstant) {
std::stringstream controllerName;
controllerName << GET_MAXSCRIPT_NODE(pNode);
controllerName << "mynode2113.FOV.controller.time";
AlembicImport_ConnectTimeControl(controllerName.str().c_str(), options);
}
}
{
std::string prop("FocusDistance");
if (options.attachToExisting) {
pControl = getController(pCameraObj, identifier, prop, 1, 0, 1);
}
if (pControl) {
pControl->GetParamBlockByID(0)->SetValue(
GetParamIdByName(pControl, 0, "path"), zero,
EC_UTF8_to_TCHAR(path.c_str()));
}
else if (assignController(createFloatController(path, identifier, prop),
pCameraObj, 1, 0, 1) &&
!isConstant) {
std::stringstream controllerName;
controllerName << GET_MAXSCRIPT_NODE(pNode);
controllerName
<< "mynode2113.MultiPass_Effect.focalDepth.controller.time";
AlembicImport_ConnectTimeControl(controllerName.str().c_str(), options);
}
}
{
std::string prop("NearClippingPlane");
if (options.attachToExisting) {
pControl = getController(pCameraObj, identifier, prop, 0, 2);
}
if (pControl) {
pControl->GetParamBlockByID(0)->SetValue(
GetParamIdByName(pControl, 0, "path"), zero,
EC_UTF8_to_TCHAR(path.c_str()));
}
else if (assignController(createFloatController(path, identifier, prop),
pCameraObj, 0, 2) &&
!isConstant) {
std::stringstream controllerName;
controllerName << GET_MAXSCRIPT_NODE(pNode);
controllerName << "mynode2113.nearclip.controller.time";
AlembicImport_ConnectTimeControl(controllerName.str().c_str(), options);
}
}
{
std::string prop("FarClippingPlane");
if (options.attachToExisting) {
pControl = getController(pCameraObj, identifier, prop, 0, 3);
}
if (pControl) {
pControl->GetParamBlockByID(0)->SetValue(
GetParamIdByName(pControl, 0, "path"), zero,
EC_UTF8_to_TCHAR(path.c_str()));
}
else if (assignController(createFloatController(path, identifier, prop),
pCameraObj, 0, 3) &&
!isConstant) {
std::stringstream controllerName;
controllerName << GET_MAXSCRIPT_NODE(pNode);
controllerName << "mynode2113.farclip.controller.time";
AlembicImport_ConnectTimeControl(controllerName.str().c_str(), options);
}
}
// if(assignControllerToLevel1SubAnim(createFloatController(path, identifier,
// std::string("FocusDistance")), pCameraObj, 0, 1) && !isConstant){
// AlembicImport_ConnectTimeControl( "$.targetDistance.controller.time",
// options );
//}
createCameraModifier(path, identifier, pNode);
// Add the new inode to our current scene list
SceneEntry* pEntry = options.sceneEnumProc.Append(
pNode, pCameraObj, OBTYPE_CAMERA, &std::string(iObj.getFullName()));
options.currentSceneList.Append(pEntry);
// Set the visibility controller
AlembicImport_SetupVisControl(path, identifier, iObj, pNode, options);
importMetadata(pNode, iObj);
return 0;
}
