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.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 );
}
}
}
//-*****************************************************************************
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 );
}
}
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());
}
}
}