//-*****************************************************************************
void IObjectDrw::draw( const DrawContext &iCtx )
{
if ( !m_object ) { return; }
// Skip objects with "visible" property set to 0
if ( iCtx.getVisibleOnly() ) {
Abc::ICompoundProperty props = m_object.getProperties();
const Abc::PropertyHeader* header = props.getPropertyHeader( "visible" );
if ( header != NULL ) {
Abc::IScalarProperty visible( props, "visible" );
Abc::ISampleSelector iss( m_currentTime );
int8_t val = 1;
visible.get( reinterpret_cast<void*>( &val ), iss );
if ( val == 0 )
return;
}
}
for ( DrawablePtrVec::iterator iter = m_children.begin();
iter != m_children.end(); ++iter )
{
DrawablePtr dptr = (*iter);
if ( dptr )
{
dptr->draw( iCtx );
}
}
}
Abc::FloatArraySamplePtr getKnotVector(AbcG::ICurves& obj)
{
ESS_PROFILE_FUNC();
Abc::ICompoundProperty arbGeom = obj.getSchema().getArbGeomParams();
if (!arbGeom.valid()) {
return Abc::FloatArraySamplePtr();
}
if (arbGeom.getPropertyHeader(".knot_vectors") != NULL) {
Abc::IFloatArrayProperty knotProp =
Abc::IFloatArrayProperty(arbGeom, ".knot_vectors");
if (knotProp.valid() && knotProp.getNumSamples() != 0) {
return knotProp.getValue(0);
}
}
if (arbGeom.getPropertyHeader(".knot_vector") != NULL) {
Abc::IFloatArrayProperty knotProp =
Abc::IFloatArrayProperty(arbGeom, ".knot_vector");
if (knotProp.valid() && knotProp.getNumSamples() != 0) {
return knotProp.getValue(0);
}
}
return Abc::FloatArraySamplePtr();
}
//-*****************************************************************************
void IObjectDrw::draw( const DrawContext &iCtx )
{
if ( !m_object ) { return; }
// Skip objects with "visible" property set to 0
if ( iCtx.visibleOnly() ) {
Abc::ICompoundProperty props = m_object.getProperties();
const Abc::PropertyHeader* header = props.getPropertyHeader( "visible" );
if ( header != NULL ) {
Abc::IScalarProperty visible( props, "visible" );
Abc::ISampleSelector iss( m_currentTime );
int8_t val = 1;
visible.get( reinterpret_cast<void*>( &val ), iss );
if ( val == 0 )
return;
}
}
// GL picking, add to global selection index
int i = 0;
for ( DrawablePtrVec::iterator iter = m_children.begin();
iter != m_children.end(); ++iter, i++ )
{
Abc::IObject iChild = m_object.getChild( i );
int index = pushName( iChild );
DrawablePtr dptr = (*iter);
if ( dptr )
{
dptr->draw( iCtx );
}
if ( index >= 0 )
popName( m_object );
}
}
void setupPropertyModifiers( AbcG::IObject& iObj, INode* pMaxNode, const std::string& file, const std::string& identifier, alembic_importoptions &options, const std::string prefix )
{
Abc::ICompoundProperty userProps = AbcNodeUtils::getUserProperties(iObj);
if(userProps.valid()){
std::vector<AbcProp> propsVec;
readInputProperties(userProps, propsVec);
if(!propsVec.empty())
{
std::sort(propsVec.begin(), propsVec.end(), sortFunc);
std::string name = prefix + " User Properties";
createDisplayModifier(name, name, propsVec, pMaxNode);
addControllersToModifierV2(name, name, propsVec, file, identifier, "userProperties", options, pMaxNode);
}
}
//Abc::ICompoundProperty geomProps = AbcNodeUtils::getArbGeomParams(iObj);
//if(geomProps.valid()){
// std::vector<AbcProp> propsVec;
// readInputProperties(geomProps, propsVec);
// if(!propsVec.empty())
// {
// std::sort(propsVec.begin(), propsVec.end(), sortFunc);
// std::string name = prefix + "ArbGeom Properties";
// createDisplayModifier(name, name, propsVec, pMaxNode);
// //addControllersToModifierV2("ArbGeom Properties", "ArbGeom Properties", propsVec, file, iObjXform.getFullName(), options, pMaxNode);
// }
//}
}
static PyObject * iCompoundProperty_getPropertyNames(PyObject * self, PyObject * args)
{
ALEMBIC_TRY_STATEMENT
Abc::ICompoundProperty *icprop = ((iCompoundProperty*)self)->mBaseCompoundProperty;
const int nb_prop = icprop->getNumProperties();
PyObject *tuple = PyTuple_New(nb_prop);
for (int i = 0; i < nb_prop; ++i)
PyTuple_SetItem(tuple,i,Py_BuildValue("s",icprop->getPropertyHeader(i).getName().c_str()));
return tuple;
ALEMBIC_PYOBJECT_CATCH_STATEMENT
}
AbcM::IMaterialSchema getMatSchema(AbcG::ILight& objLight)
{
Abc::ICompoundProperty props = objLight.getProperties();
for(int i=0; i<props.getNumProperties(); i++){
Abc::PropertyHeader propHeader = props.getPropertyHeader(i);
if(AbcM::IMaterialSchema::matches(propHeader)){
return AbcM::IMaterialSchema(props, propHeader.getName());
}
}
return AbcM::IMaterialSchema();
}
void AbcNodeUtils::printCompoundProperty( Abc::ICompoundProperty prop )
{
if(!prop){
return;
}
for(size_t i=0; i<prop.getNumProperties(); i++){
AbcA::PropertyHeader pheader = prop.getPropertyHeader(i);
AbcA::PropertyType propType = pheader.getPropertyType();
ESS_LOG_WARNING("PropertyType: "<<AbcNodeUtils::getTypeStr(propType));
ESS_LOG_WARNING("PropertyName: "<<pheader.getName()<<", pod: "<<AbcNodeUtils::getPodStr(pheader.getDataType().getPod()) \
<<", extent: "<<(int)pheader.getDataType().getExtent()<<", interpretation: "<<pheader.getMetaData().get("interpretation"));
}
}
Abc::UInt16ArraySamplePtr getCurveOrders(AbcG::ICurves& obj)
{
ESS_PROFILE_FUNC();
Abc::ICompoundProperty arbGeom = obj.getSchema().getArbGeomParams();
if(!arbGeom.valid()){
return Abc::UInt16ArraySamplePtr();
}
if ( arbGeom.getPropertyHeader( ".orders" ) != NULL ){
Abc::IUInt16ArrayProperty orders = Abc::IUInt16ArrayProperty( arbGeom, ".orders" );
if(orders.valid() && orders.getNumSamples() != 0){
return orders.getValue(0);
}
}
return Abc::UInt16ArraySamplePtr();
}
XSI_XformTypes::xte getXformType(AbcG::IXform& obj)
{
Abc::ICompoundProperty arbGeom = obj.getSchema().getArbGeomParams();
if(!arbGeom.valid()){
return XSI_XformTypes::UNKNOWN;
}
if ( arbGeom.getPropertyHeader( ".xsiNodeType" ) != NULL ){
Abc::IUcharProperty types = Abc::IUcharProperty( arbGeom, ".xsiNodeType" );
if(types.valid() && types.getNumSamples() != 0){
return (XSI_XformTypes::xte)types.getValue(0);
}
}
return XSI_XformTypes::UNKNOWN;
}
int AlembicImport_Light(const std::string &path, AbcG::IObject& iObj, alembic_importoptions &options, INode** pMaxNode)
{
//#define OMNI_LIGHT_CLASS_ID 0x1011
//#define SPOT_LIGHT_CLASS_ID 0x1012
//#define DIR_LIGHT_CLASS_ID 0x1013
//#define FSPOT_LIGHT_CLASS_ID 0x1014
//#define TDIR_LIGHT_CLASS_ID 0x1015
//#define OMNI_LIGHT 0 // Omnidirectional
//#define TSPOT_LIGHT 1 // Targeted
//#define DIR_LIGHT 2 // Directional
//#define FSPOT_LIGHT 3 // Free
//#define TDIR_LIGHT 4 // Targeted directional
if(options.attachToExisting){
ESS_LOG_WARNING("Attach to existing for lights is not yet supported. Could not attach "<<iObj.getFullName());
return alembic_success;
}
std::vector<matShader> shaders;
AbcG::ILight objLight = AbcG::ILight(iObj, Alembic::Abc::kWrapExisting);
std::string identifier = objLight.getFullName();
//CompoundPropertyReaderPtr propReader = objLight.getProperties();
Abc::ICompoundProperty props = objLight.getProperties();
InputLightType::enumt lightType = InputLightType::NUM_INPUT_LIGHT_TYPES;
for(int i=0; i<props.getNumProperties(); i++){
Abc::PropertyHeader propHeader = props.getPropertyHeader(i);
if(AbcM::IMaterialSchema::matches(propHeader)){
AbcM::IMaterialSchema matSchema(props, propHeader.getName());
//ESS_LOG_WARNING("MaterialSchema present on light.");
lightType = readShader(matSchema, shaders);
}
//ESS_LOG_WARNING("name: "<<propHeader.getName());
//if( AbcG::ICameraSchema::matches(propHeader) ){
// ESS_LOG_WARNING("Found light camera.");
// //AbcG::ICameraSchema camSchema(props, propHeader.getName());
//}
}
bool bReplaceExisting = false;
int nodeRes = alembic_failure;
if(lightType == InputLightType::AMBIENT_LIGHT){
nodeRes = createNode(iObj, LIGHT_CLASS_ID, Class_ID(OMNI_LIGHT_CLASS_ID, 0), pMaxNode, bReplaceExisting);
//Modifier* pModifier = FindModifier(*pMaxNode, Class_ID(OMNI_LIGHT_CLASS_ID, 0));
//if(pModifier){
// ESS_LOG_WARNING("NumParamBlocks: "<<pModifier->NumParamBlocks());
//}
//printControllers(*pMaxNode);
//pMaxNode>GetParamBlockByID( 0 )->SetValue( GetParamIdByName( pModifier, 0, "muted" ), zero, FALSE );
GET_MAX_INTERFACE()->SelectNode(*pMaxNode);
//set the ambient check box, intensity controller, and light colour controller (not sure how to this in C++)
std::stringstream evalStream;
std::string modkey("");
for(int s=0; s<shaders.size(); s++){
std::string target = shaders[s].target;
std::string type = shaders[s].type;
for(int i=0; i<shaders[s].props.size(); i++){
std::string propName = shaders[s].props[i].name;
std::string& val = shaders[s].props[i].displayVal;
bool& bConstant = shaders[s].props[i].bConstant;
const AbcA::DataType& datatype = shaders[s].props[i].propHeader.getDataType();
const AbcA::MetaData& metadata = shaders[s].props[i].propHeader.getMetaData();
if(datatype.getPod() == AbcA::kFloat32POD){
std::stringstream propStream;
propStream<<target<<"."<<type<<"."<<propName;
if(datatype.getExtent() == 1 && propName.find("intensity") != std::string::npos ){ //intensity property found, so attach controller
addFloatController(evalStream, options, modkey, std::string("multiplier"), path, iObj.getFullName(), propStream.str());
}
else if(datatype.getExtent() == 3 && propName.find("lightcolor") != std::string::npos ){ //color property found, so attach controller
std::stringstream xStream, yStream, zStream;
xStream<<propStream.str()<<"."<<metadata.get("interpretation")<<".x";
yStream<<propStream.str()<<"."<<metadata.get("interpretation")<<".y";
zStream<<propStream.str()<<"."<<metadata.get("interpretation")<<".z";
evalStream<<"$.rgb.controller = Color_RGB()\n";
addFloatController(evalStream, options, modkey, std::string("rgb.controller.r"), path, iObj.getFullName(), xStream.str());
addFloatController(evalStream, options, modkey, std::string("rgb.controller.g"), path, iObj.getFullName(), yStream.str());
addFloatController(evalStream, options, modkey, std::string("rgb.controller.b"), path, iObj.getFullName(), zStream.str());
}
}
else{
}
evalStream<<"\n";
}
}
evalStream<<"$.ambientOnly = true\n";
ExecuteMAXScriptScript( EC_UTF8_to_TCHAR((char*)evalStream.str().c_str()));
}
else{//create a null, if we don't know what type of light this is
nodeRes = createNode(iObj, HELPER_CLASS_ID, Class_ID(DUMMY_CLASS_ID,0), pMaxNode, bReplaceExisting);
}
if(nodeRes == alembic_failure){
return nodeRes;
}
GET_MAX_INTERFACE()->SelectNode(*pMaxNode);
for(int i=0; i<shaders.size(); i++){
std::sort(shaders[i].props.begin(), shaders[i].props.end(), sortFunc);
Modifier* pMod = createDisplayModifier("Shader Properties", shaders[i].name, shaders[i].props);
std::string target = shaders[i].target;
std::string type = shaders[i].type;
addControllersToModifier("Shader Properties", shaders[i].name, shaders[i].props, target, type, path, iObj.getFullName(), options);
}
// ----- TODO: add camera modifier
//createCameraModifier(path, identifier, *pMaxNode);
// ----- TODO: don't attach controllers for constant parameters
//TODO: make the spinners read only
return alembic_success;
}
//TODO: out at maximum one warning per unsupported type
void readInputProperties( Abc::ICompoundProperty prop, std::vector<AbcProp>& props )
{
if(!prop){
return;
}
for(size_t i=0; i<prop.getNumProperties(); i++){
AbcA::PropertyHeader pheader = prop.getPropertyHeader(i);
AbcA::PropertyType propType = pheader.getPropertyType();
//ESS_LOG_WARNING("Property, propName: "<<pheader.getName()<<", pod: "<<getPodStr(pheader.getDataType().getPod()) \
// <<", extent: "<<(int)pheader.getDataType().getExtent()<<", interpretation: "<<pheader.getMetaData().get("interpretation"));
int invalidStrIndex = containsInvalidString(pheader.getName());
if( invalidStrIndex > 0 ){
ESS_LOG_WARNING("Skipping property "<<pheader.getName()<<" because it contains an invalid character: "<<invalidStrTable[invalidStrIndex]);
continue;
}
if( propType == AbcA::kCompoundProperty ){
//printInputProperties(Abc::ICompoundProperty(prop, pheader.getName()));
//ESS_LOG_WARNING("Unsupported compound property: "<<pheader.getName());
}
else if( propType == AbcA::kScalarProperty ){
//ESS_LOG_WARNING("Scaler property: "<<pheader.getName());
//
std::string displayVal;
bool bConstant = true;
int sortId = 0;
int size = 0;
if(Abc::IBoolProperty::matches(pheader)){
//I need to know the name and type only if animated; an appropriate controller will handle reading the data.
//If not animated, the value will set directly on the light and/or display modifier
Abc::IBoolProperty boolProp(prop, pheader.getName());
/*if(boolProp.isConstant()){*/
AbcU::bool_t bVal = false;
boolProp.get(bVal);
if(bVal == true) displayVal = "true";
else displayVal = "false";
//}
//else{
//
//}
}
else if(readPropExt1<Abc::IInt32Property, int>(prop, pheader, displayVal, bConstant));
else if(readPropExt1<Abc::IFloatProperty, float>(prop, pheader, displayVal, bConstant));
else if(readPropExt3<Abc::IC3fProperty, Abc::C3f>(prop, pheader, displayVal, bConstant));
else if(readPropExt3<Abc::IV3fProperty, Abc::V3f>(prop, pheader, displayVal, bConstant));
else if(readPropExt3<Abc::IN3fProperty, Abc::N3f>(prop, pheader, displayVal, bConstant));
else if(Abc::IStringProperty::matches(pheader)){
Abc::IStringProperty stringProp(prop, pheader.getName());
stringProp.get(displayVal);
sortId = 1000000000;
}
else{
// Abc::PropertyHeader propHeader = props.getPropertyHeader(i);
// AbcA::PropertyType propType = propHeader.getPropertyType();
ESS_LOG_WARNING("Unsupported property, propName: "<<pheader.getName()<<", pod: "<<getPodStr(pheader.getDataType().getPod()) \
<<", extent: "<<(int)pheader.getDataType().getExtent()<<", interpretation: "<<pheader.getMetaData().get("interpretation"));
}
props.push_back(AbcProp(pheader.getName(), displayVal, pheader, bConstant, sortId));
}
else if( propType == AbcA::kArrayProperty ){
//ESS_LOG_WARNING("Unsupported array property: "<<pheader.getName());
//it the moment is unlikely we will support array properties in 3DS Max. They won't work so well with our display modifier system.
//ESS_LOG_WARNING("Unsupported array property, propName: "<<pheader.getName()<<", pod: "<<getPodStr(pheader.getDataType().getPod()) \
//<<", extent: "<<(int)pheader.getDataType().getExtent()<<", interpretation: "<<pheader.getMetaData().get("interpretation"));
}
else{
ESS_LOG_WARNING("Unsupported input property: "<<pheader.getName());
}
}
}
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
}