Abc::ICompoundProperty getArbGeomParams(const AbcG::IObject& iObj,
AbcA::TimeSamplingPtr& timeSampling,
int& nSamples)
{
if (AbcG::IXform::matches(iObj.getMetaData())) {
AbcG::IXform obj(iObj, Abc::kWrapExisting);
timeSampling = obj.getSchema().getTimeSampling();
nSamples = (int)obj.getSchema().getNumSamples();
return obj.getSchema().getArbGeomParams();
}
else if (AbcG::IPolyMesh::matches(iObj.getMetaData())) {
AbcG::IPolyMesh obj(iObj, Abc::kWrapExisting);
timeSampling = obj.getSchema().getTimeSampling();
nSamples = (int)obj.getSchema().getNumSamples();
return obj.getSchema().getArbGeomParams();
}
else if (AbcG::ISubD::matches(iObj.getMetaData())) {
AbcG::ISubD obj(iObj, Abc::kWrapExisting);
timeSampling = obj.getSchema().getTimeSampling();
nSamples = (int)obj.getSchema().getNumSamples();
return obj.getSchema().getArbGeomParams();
}
else if (AbcG::ICamera::matches(iObj.getMetaData())) {
AbcG::ICamera obj(iObj, Abc::kWrapExisting);
timeSampling = obj.getSchema().getTimeSampling();
nSamples = (int)obj.getSchema().getNumSamples();
return obj.getSchema().getArbGeomParams();
}
else if (AbcG::IPoints::matches(iObj.getMetaData())) {
AbcG::IPoints obj(iObj, Abc::kWrapExisting);
timeSampling = obj.getSchema().getTimeSampling();
nSamples = (int)obj.getSchema().getNumSamples();
return obj.getSchema().getArbGeomParams();
}
else if (AbcG::ICurves::matches(iObj.getMetaData())) {
AbcG::ICurves obj(iObj, Abc::kWrapExisting);
timeSampling = obj.getSchema().getTimeSampling();
nSamples = (int)obj.getSchema().getNumSamples();
return obj.getSchema().getArbGeomParams();
}
else if (AbcG::ILight::matches(iObj.getMetaData())) {
AbcG::ILight obj(iObj, Abc::kWrapExisting);
timeSampling = obj.getSchema().getTimeSampling();
nSamples = (int)obj.getSchema().getNumSamples();
return obj.getSchema().getArbGeomParams();
}
else if (AbcG::INuPatch::matches(iObj.getMetaData())) {
AbcG::INuPatch obj(iObj, Abc::kWrapExisting);
timeSampling = obj.getSchema().getTimeSampling();
nSamples = (int)obj.getSchema().getNumSamples();
return obj.getSchema().getArbGeomParams();
}
else {
ESS_LOG_WARNING("Could not read ArgGeomParams from " << iObj.getFullName());
return Abc::ICompoundProperty();
}
}
int createAlembicObject(AbcG::IObject &iObj, INode **pMaxNode,
alembic_importoptions &options, std::string &file)
{
AbcA::MetaData mdata = iObj.getMetaData();
int ret = alembic_success;
// if(AbcG::IXform::matches(iObj.getMetaData())) //Transform
//{
// ESS_LOG_INFO( "AlembicImport_XForm: " << objects[j].getFullName() );
// int ret = AlembicImport_PolyMesh(file, iObj, options, pMaxNode);
//}
if (AbcG::IPolyMesh::matches(mdata) ||
AbcG::ISubD::matches(mdata)) { // PolyMesh / SubD
ESS_LOG_INFO("AlembicImport_PolyMesh: " << iObj.getFullName());
ret = AlembicImport_PolyMesh(file, iObj, options, pMaxNode);
}
else if (AbcG::ICamera::matches(mdata)) { // Camera
ESS_LOG_INFO("AlembicImport_Camera: " << iObj.getFullName());
ret = AlembicImport_Camera(file, iObj, options, pMaxNode);
}
else if (AbcG::IPoints::matches(mdata)) { // Points
ESS_LOG_INFO("AlembicImport_Points: " << iObj.getFullName());
ret = AlembicImport_Points(file, iObj, options, pMaxNode);
}
else if (AbcG::ICurves::matches(mdata)) { // Curves
if (options.loadCurvesAsNurbs) {
ESS_LOG_INFO("AlembicImport_Nurbs: " << iObj.getFullName());
ret = AlembicImport_NURBS(file, iObj, options, pMaxNode);
}
else {
ESS_LOG_INFO("AlembicImport_Shape: " << iObj.getFullName());
ret = AlembicImport_Shape(file, iObj, options, pMaxNode);
}
}
else if (AbcG::ILight::matches(mdata)) { // Light
ESS_LOG_INFO("AlembicImport_Light: " << iObj.getFullName());
ret = AlembicImport_Light(file, iObj, options, pMaxNode);
}
else if (AbcM::IMaterial::matches(mdata)) {
ESS_LOG_WARNING(
"Alembic IMaterial not yet supported: " << iObj.getFullName());
}
else { // NURBS
if (options.failOnUnsupported) {
ESS_LOG_ERROR("Alembic data type not supported: " << iObj.getFullName());
return alembic_failure;
}
else {
ESS_LOG_WARNING(
"Alembic data type not supported: " << iObj.getFullName());
}
}
return ret;
}
Abc::ICompoundProperty AbcNodeUtils::getUserProperties(
const AbcG::IObject& iObj)
{
if (AbcG::IXform::matches(iObj.getMetaData())) {
AbcG::IXform obj(iObj, Abc::kWrapExisting);
return obj.getSchema().getUserProperties();
}
else if (AbcG::IPolyMesh::matches(iObj.getMetaData())) {
AbcG::IPolyMesh obj(iObj, Abc::kWrapExisting);
return obj.getSchema().getUserProperties();
}
else if (AbcG::ISubD::matches(iObj.getMetaData())) {
AbcG::ISubD obj(iObj, Abc::kWrapExisting);
return obj.getSchema().getUserProperties();
}
else if (AbcG::ICamera::matches(iObj.getMetaData())) {
AbcG::ICamera obj(iObj, Abc::kWrapExisting);
return obj.getSchema().getUserProperties();
}
else if (AbcG::IPoints::matches(iObj.getMetaData())) {
AbcG::IPoints obj(iObj, Abc::kWrapExisting);
return obj.getSchema().getUserProperties();
}
else if (AbcG::ICurves::matches(iObj.getMetaData())) {
AbcG::ICurves obj(iObj, Abc::kWrapExisting);
return obj.getSchema().getUserProperties();
}
else if (AbcG::ILight::matches(iObj.getMetaData())) {
AbcG::ILight obj(iObj, Abc::kWrapExisting);
return obj.getSchema().getUserProperties();
}
else if (AbcG::INuPatch::matches(iObj.getMetaData())) {
AbcG::INuPatch obj(iObj, Abc::kWrapExisting);
return obj.getSchema().getUserProperties();
}
else {
ESS_LOG_WARNING("Could not read ArgGeomParams from " << iObj.getFullName());
return Abc::ICompoundProperty();
}
}
void AlembicFloatController::GetValueLocalTime(TimeValue t, void* ptr,
Interval& valid,
GetSetMethod method)
{
ESS_CPP_EXCEPTION_REPORTING_START
Interval interval = FOREVER;
MCHAR const* strPath = NULL;
this->pblock->GetValue(AlembicFloatController::ID_PATH, t, strPath, interval);
MCHAR const* strIdentifier = NULL;
this->pblock->GetValue(AlembicFloatController::ID_IDENTIFIER, t,
strIdentifier, interval);
MCHAR const* strCategory = NULL;
this->pblock->GetValue(AlembicFloatController::ID_CATEGORY, t, strCategory,
interval);
MCHAR const* strProperty = NULL;
this->pblock->GetValue(AlembicFloatController::ID_PROPERTY, t, strProperty,
interval);
float fTime;
this->pblock->GetValue(AlembicFloatController::ID_TIME, t, fTime, interval);
BOOL bMuted;
this->pblock->GetValue(AlembicFloatController::ID_MUTED, t, bMuted, interval);
extern bool g_bVerboseLogging;
if (g_bVerboseLogging) {
ESS_LOG_WARNING("Param block at tick " << t << "-----------------------");
ESS_LOG_WARNING("PATH: " << strPath);
ESS_LOG_WARNING("IDENTIFIER: " << strIdentifier);
ESS_LOG_WARNING("PROPERTY: " << strProperty);
ESS_LOG_WARNING("TIME: " << fTime);
ESS_LOG_WARNING("MUTED: " << bMuted);
ESS_LOG_WARNING("Param block end -------------");
}
const float fDefaultVal = -1.0;
std::string szPath = EC_MCHAR_to_UTF8(strPath);
std::string szIdentifier = EC_MCHAR_to_UTF8(strIdentifier);
std::string szProperty = EC_MCHAR_to_UTF8(strProperty);
std::string szCategory = EC_MCHAR_to_UTF8(strCategory);
if (szCategory.empty()) { // default to standard properties for backwards
// compatibility
szCategory = std::string("standardProperties");
}
if (!strProperty || !strPath || !strIdentifier /*|| !strCategory*/) {
return setController("1", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
if (bMuted) {
return setController("2", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
// if( szCategory.size() == 0 ) {
// ESS_LOG_ERROR( "No category specified." );
// return setController("3a", szProperty, valid, interval, method, ptr,
// fDefaultVal);
//}
if (szProperty.size() == 0) {
ESS_LOG_ERROR("No property specified.");
return setController("3b", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
AbcG::IObject iObj = getObjectFromArchive(szPath, szIdentifier);
if (!iObj.valid()) {
return setController("4", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
TimeValue dTicks = GetTimeValueFromSeconds(fTime);
double sampleTime = GetSecondsFromTimeValue(dTicks);
float fSampleVal = fDefaultVal;
if (boost::iequals(szCategory, "standardProperties")) {
if (Alembic::AbcGeom::ICamera::matches(
iObj.getMetaData())) { // standard camera properties
Alembic::AbcGeom::ICamera objCamera =
Alembic::AbcGeom::ICamera(iObj, Alembic::Abc::kWrapExisting);
SampleInfo sampleInfo =
getSampleInfo(sampleTime, objCamera.getSchema().getTimeSampling(),
objCamera.getSchema().getNumSamples());
Alembic::AbcGeom::CameraSample sample;
objCamera.getSchema().get(sample, sampleInfo.floorIndex);
double sampleVal;
if (!getCameraSampleVal(objCamera, sampleInfo, sample, szProperty,
sampleVal)) {
return setController("5", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
// Blend the camera values, if necessary
if (sampleInfo.alpha != 0.0) {
objCamera.getSchema().get(sample, sampleInfo.ceilIndex);
double sampleVal2 = 0.0;
if (getCameraSampleVal(objCamera, sampleInfo, sample, szProperty,
sampleVal2)) {
sampleVal = (1.0 - sampleInfo.alpha) * sampleVal +
sampleInfo.alpha * sampleVal2;
}
}
fSampleVal = (float)sampleVal;
}
else if (Alembic::AbcGeom::ILight::matches(
iObj.getMetaData())) { // ILight material properties
ESS_PROFILE_SCOPE(
"AlembicFloatController::GetValueLocalTime - read ILight shader "
"parameter");
Alembic::AbcGeom::ILight objLight =
Alembic::AbcGeom::ILight(iObj, Alembic::Abc::kWrapExisting);
SampleInfo sampleInfo =
getSampleInfo(sampleTime, objLight.getSchema().getTimeSampling(),
objLight.getSchema().getNumSamples());
AbcM::IMaterialSchema matSchema = getMatSchema(objLight);
std::string strProp = szProperty;
std::vector<std::string> parts;
boost::split(parts, strProp, boost::is_any_of("."));
if (parts.size() == 3) {
const std::string& target = parts[0];
const std::string& type = parts[1];
const std::string& prop = parts[2];
Abc::IFloatProperty fProp = readShaderScalerProp<Abc::IFloatProperty>(
matSchema, target, type, prop);
if (fProp.valid()) {
fProp.get(fSampleVal, sampleInfo.floorIndex);
}
else {
ESS_LOG_WARNING("Float Controller Error: could find shader parameter "
<< strProp);
}
}
else if (parts.size() == 5) {
const std::string& target = parts[0];
const std::string& type = parts[1];
const std::string& prop = parts[2];
const std::string& propInterp = parts[3];
const std::string& propComp = parts[4];
// ESS_LOG_WARNING("propInterp: "<<propInterp);
if (propInterp == "rgb") {
Abc::IC3fProperty fProp = readShaderScalerProp<Abc::IC3fProperty>(
matSchema, target, type, prop);
if (fProp.valid()) {
Abc::C3f v3f;
fProp.get(v3f, sampleInfo.floorIndex);
if (propComp == "x") {
fSampleVal = v3f.x;
}
else if (propComp == "y") {
fSampleVal = v3f.y;
}
else if (propComp == "z") {
fSampleVal = v3f.z;
}
else {
ESS_LOG_WARNING(
"Float Controller Error: invalid component: " << propComp);
}
}
else {
ESS_LOG_WARNING(
"Float Controller Error: could find shader parameter "
<< strProp);
}
}
else {
ESS_LOG_WARNING(
"Float Controller Error: unrecognized parameter interpretation: "
<< propInterp);
}
}
else {
ESS_LOG_WARNING(
"Float Controller Error: could not parse property field: "
<< strProperty);
}
}
}
else if (boost::iequals(szCategory, "userProperties")) {
// AbcA::TimeSamplingPtr timeSampling = obj.getSchema().getTimeSampling();
// int nSamples = (int)obj.getSchema().getNumSamples();
AbcA::TimeSamplingPtr timeSampling;
int nSamples = 0;
Abc::ICompoundProperty propk =
AbcNodeUtils::getUserProperties(iObj, timeSampling, nSamples);
if (propk.valid()) {
SampleInfo sampleInfo = getSampleInfo(sampleTime, timeSampling, nSamples);
std::vector<std::string> parts;
boost::split(parts, szProperty, boost::is_any_of("."));
if (parts.size() == 1) {
Abc::IFloatProperty fProp =
readScalarProperty<Abc::IFloatProperty>(propk, szProperty);
if (fProp.valid()) {
fProp.get(fSampleVal, sampleInfo.floorIndex);
}
else {
Abc::IInt32Property intProp =
readScalarProperty<Abc::IInt32Property>(propk, szProperty);
if (intProp.valid()) {
int intVal;
intProp.get(intVal, sampleInfo.floorIndex);
fSampleVal = (float)intVal;
}
else {
ESS_LOG_WARNING(
"Float Controller Error: could not read user property "
<< szProperty);
}
}
}
else if (parts.size() == 3) {
const std::string& prop = parts[0];
const std::string& propInterp = parts[1];
const std::string& propComp = parts[2];
// ESS_LOG_WARNING("interpretation: "<<propInterp);
if (propInterp == "rgb") {
fSampleVal = readScalarPropertyExt3<Abc::IC3fProperty, Abc::C3f>(
propk, sampleInfo, prop, propComp);
}
else if (propInterp == "vector") {
fSampleVal = readScalarPropertyExt3<Abc::IV3fProperty, Abc::V3f>(
propk, sampleInfo, prop, propComp);
}
else {
ESS_LOG_WARNING(
"Float Controller Error: unrecognized parameter interpretation: "
<< propInterp);
}
}
}
}
// else if( boost::iequals(szCategory, "arbGeomParams") ){
//}
return setController("6", szProperty, valid, interval, method, ptr,
fSampleVal);
ESS_CPP_EXCEPTION_REPORTING_END
}
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;
}