GA_RWHandleV3 SHelper::addFloatVectorDetailAttr(GU_Detail* gdp, const char* name, float* def)
{
GA_RWAttributeRef attr;
if(def) attr = gdp->addFloatTuple(GA_ATTRIB_GLOBAL, name, 3, GA_Defaults(def, 3));
else attr = gdp->addFloatTuple(GA_ATTRIB_GLOBAL, name, 3);
attr.setTypeInfo(GA_TYPE_VECTOR);
return GA_RWHandleV3( attr.getAttribute() );
}
bool SOP_SceneCacheSource::convertObject( const IECore::Object *object, const std::string &name, const SceneInterface *scene, Parameters ¶ms )
{
ToHoudiniGeometryConverterPtr converter = 0;
if ( params.geometryType == Cortex )
{
converter = new ToHoudiniCortexObjectConverter( object );
}
else
{
const VisibleRenderable *renderable = IECore::runTimeCast<const VisibleRenderable>( object );
if ( !renderable )
{
return false;
}
converter = ToHoudiniGeometryConverter::create( renderable );
}
if ( !converter )
{
return false;
}
// we need to set the name regardless of whether
// we're reusing prims or doing the full conversion
// because this parameter can have an affect in
// transferAttribs() as well as convert()
converter->nameParameter()->setTypedValue( name );
// check the primitve range map to see if this shape exists already
std::map<std::string, GA_Range>::iterator rIt = params.namedRanges.find( name );
if ( rIt != params.namedRanges.end() && !rIt->second.isEmpty() )
{
GA_Range primRange = rIt->second;
const Primitive *primitive = IECore::runTimeCast<const Primitive>( object );
if ( primitive && !params.hasAnimatedTopology && params.hasAnimatedPrimVars )
{
// this means constant topology and primitive variables, even though multiple samples were written
if ( params.animatedPrimVars.empty() )
{
return true;
}
GA_Range pointRange( *gdp, primRange, GA_ATTRIB_POINT, GA_Range::primitiveref(), false );
// update the animated primitive variables only
std::string animatedPrimVarStr = "";
for ( std::vector<InternedString>::const_iterator it = params.animatedPrimVars.begin(); it != params.animatedPrimVars.end(); ++it )
{
animatedPrimVarStr += it->string() + " ";
}
converter->attributeFilterParameter()->setTypedValue( animatedPrimVarStr );
try
{
converter->transferAttribs( gdp, pointRange, primRange );
return true;
}
catch ( std::exception &e )
{
addWarning( SOP_MESSAGE, e.what() );
return false;
}
catch ( ... )
{
addWarning( SOP_MESSAGE, "Attribute transfer failed for unknown reasons" );
return false;
}
}
else
{
// topology is changing, so destroy the exisiting primitives
gdp->destroyPrimitives( primRange, true );
}
}
// fallback to full conversion
converter->attributeFilterParameter()->setTypedValue( params.attributeFilter );
try
{
GA_Offset firstNewPrim = gdp->getPrimitiveMap().lastOffset() + 1;
bool status = converter->convert( myGdpHandle );
if ( params.fullPathName != "" )
{
// adds the full path in addition to the relative name
const GA_IndexMap &primMap = gdp->getPrimitiveMap();
GA_Range newPrims( primMap, firstNewPrim, primMap.lastOffset() + 1 );
if ( newPrims.isValid() )
{
std::string fullName;
SceneInterface::Path path;
scene->path( path );
SceneInterface::pathToString( path, fullName );
GA_RWAttributeRef pathAttribRef = ToHoudiniStringVectorAttribConverter::convertString( params.fullPathName, fullName, gdp, newPrims );
status = status && pathAttribRef.isValid();
}
}
return status;
}
catch ( std::exception &e )
{
addWarning( SOP_MESSAGE, e.what() );
return false;
}
catch ( ... )
{
addWarning( SOP_MESSAGE, "Conversion failed for unknown reasons" );
return false;
}
}
void ToHoudiniGeometryConverter::transferAttribValues(
const Primitive *primitive, GU_Detail *geo,
const GA_Range &points, const GA_Range &prims,
PrimitiveVariable::Interpolation vertexInterpolation,
PrimitiveVariable::Interpolation primitiveInterpolation,
PrimitiveVariable::Interpolation pointInterpolation,
PrimitiveVariable::Interpolation detailInterpolation
) const
{
GA_OffsetList offsets;
if ( prims.isValid() )
{
const GA_PrimitiveList &primitives = geo->getPrimitiveList();
for ( GA_Iterator it=prims.begin(); !it.atEnd(); ++it )
{
const GA_Primitive *prim = primitives.get( it.getOffset() );
size_t numPrimVerts = prim->getVertexCount();
for ( size_t v=0; v < numPrimVerts; v++ )
{
if ( prim->getTypeId() == GEO_PRIMPOLY )
{
offsets.append( prim->getVertexOffset( numPrimVerts - 1 - v ) );
}
else
{
offsets.append( prim->getVertexOffset( v ) );
}
}
}
}
GA_Range vertRange( geo->getVertexMap(), offsets );
UT_String filter( attributeFilterParameter()->getTypedValue() );
bool convertStandardAttributes = m_convertStandardAttributesParameter->getTypedValue();
// process all primvars with UV interpretation
for ( const auto &it : primitive->variables)
{
if ( !UT_String( it.first ).multiMatch( filter ) )
{
continue;
}
if (const V2fVectorData *uvData = runTimeCast<const V2fVectorData> ( it.second.data.get() ) )
{
if ( uvData->getInterpretation() != GeometricData::UV )
{
continue;
}
PrimitiveVariable::IndexedView<Imath::V2f> uvIndexedView ( it.second );
// Houdini prefers a V3f uvw rather than V2f uv,
// though they advise setting the 3rd component to 0.
std::vector<Imath::V3f> uvw;
uvw.reserve( uvIndexedView.size() );
for ( size_t i=0; i < uvIndexedView.size(); ++i )
{
uvw.emplace_back( uvIndexedView[i][0], uvIndexedView[i][1], 0 );
}
GA_Range range = vertRange;
if ( it.second.interpolation == pointInterpolation )
{
range = points;
}
V3fVectorData::Ptr uvwData = new V3fVectorData( uvw );
uvwData->setInterpretation( GeometricData::UV );
ToHoudiniAttribConverterPtr converter = ToHoudiniAttribConverter::create( uvwData.get() );
converter->convert( it.first, geo, range );
filter += " ^" + it.first;
}
}
UT_StringMMPattern attribFilter;
attribFilter.compile( filter );
// add the primitive variables to the various GEO_AttribDicts based on interpolation type
for ( PrimitiveVariableMap::const_iterator it=primitive->variables.begin() ; it != primitive->variables.end(); it++ )
{
if( !primitive->isPrimitiveVariableValid( it->second ) )
{
IECore::msg( IECore::MessageHandler::Warning, "ToHoudiniGeometryConverter", "PrimitiveVariable " + it->first + " is invalid. Ignoring." );
continue;
}
UT_String varName( it->first );
if ( !varName.multiMatch( attribFilter ) )
{
continue;
}
PrimitiveVariable primVar = processPrimitiveVariable( primitive, it->second );
DataPtr data = nullptr;
ToHoudiniAttribConverterPtr converter = nullptr;
if( primVar.indices && primVar.data->typeId() == StringVectorDataTypeId )
{
// we want to process the indexed strings rather than the expanded strings
converter = ToHoudiniAttribConverter::create( primVar.data.get() );
if( ToHoudiniStringVectorAttribConverter *stringVectorConverter = IECore::runTimeCast<ToHoudiniStringVectorAttribConverter>( converter.get() ) )
{
stringVectorConverter->indicesParameter()->setValidatedValue( primVar.indices.get() );
}
}
else
{
// all other primitive variables must be expanded
data = primVar.expandedData();
converter = ToHoudiniAttribConverter::create( data.get() );
}
if ( !converter )
{
continue;
}
const std::string name = ( convertStandardAttributes ) ? processPrimitiveVariableName( it->first ) : it->first;
if ( primVar.interpolation == detailInterpolation )
{
// add detail attribs
try
{
converter->convert( name, geo );
}
catch ( std::exception &e )
{
throw IECore::Exception( "PrimitiveVariable \"" + it->first + "\" could not be converted as a Detail Attrib: " + e.what() );
}
}
else if ( primVar.interpolation == pointInterpolation )
{
#if UT_MAJOR_VERSION_INT < 15
// add point attribs
if ( name == "P" )
{
// special case for P
transferP( runTimeCast<const V3fVectorData>( primVar.data.get() ), geo, points );
}
else
#endif
{
try
{
GA_RWAttributeRef attrRef = converter->convert( name, geo, points );
// mark rest as non-transforming so it doesn't get manipulated once inside Houdini
if ( name == "rest" || name == "Pref" )
{
#if UT_MAJOR_VERSION_INT >= 15
attrRef.setTypeInfo( GA_TYPE_VOID );
#else
attrRef.getAttribute()->setNonTransforming( true );
#endif
}
}
catch ( std::exception &e )
{
throw IECore::Exception( "PrimitiveVariable \"" + it->first + "\" could not be converted as a Point Attrib: " + e.what() );
}
}
}
else if ( primVar.interpolation == primitiveInterpolation )
{
// add primitive attribs
try
{
converter->convert( name, geo, prims );
}
catch ( std::exception &e )
{
throw IECore::Exception( "PrimitiveVariable \"" + it->first + "\" could not be converted as a Primitive Attrib: " + e.what() );
}
}
else if ( primVar.interpolation == vertexInterpolation )
{
// add vertex attribs
try
{
converter->convert( name, geo, vertRange );
}
catch ( std::exception &e )
{
throw IECore::Exception( "PrimitiveVariable \"" + it->first + "\" could not be converted as a Vertex Attrib: " + e.what() );
}
}
}
// backwards compatibility with older data
const StringData *nameData = primitive->blindData()->member<StringData>( "name" );
if ( nameData && prims.isValid() )
{
ToHoudiniStringVectorAttribConverter::convertString( "name", nameData->readable(), geo, prims );
}
}
void ToHoudiniGeometryConverter::transferAttribValues(
const Primitive *primitive, GU_Detail *geo,
const GA_Range &points, const GA_Range &prims,
PrimitiveVariable::Interpolation vertexInterpolation,
PrimitiveVariable::Interpolation primitiveInterpolation,
PrimitiveVariable::Interpolation pointInterpolation,
PrimitiveVariable::Interpolation detailInterpolation
) const
{
GA_OffsetList offsets;
if ( prims.isValid() )
{
const GA_PrimitiveList &primitives = geo->getPrimitiveList();
for ( GA_Iterator it=prims.begin(); !it.atEnd(); ++it )
{
const GA_Primitive *prim = primitives.get( it.getOffset() );
size_t numPrimVerts = prim->getVertexCount();
for ( size_t v=0; v < numPrimVerts; v++ )
{
if ( prim->getTypeId() == GEO_PRIMPOLY )
{
offsets.append( prim->getVertexOffset( numPrimVerts - 1 - v ) );
}
else
{
offsets.append( prim->getVertexOffset( v ) );
}
}
}
}
GA_Range vertRange( geo->getVertexMap(), offsets );
UT_String filter( attributeFilterParameter()->getTypedValue() );
// match all the string variables to each associated indices variable
/// \todo: replace all this logic with IECore::IndexedData once it exists...
PrimitiveVariableMap stringsToIndices;
for ( PrimitiveVariableMap::const_iterator it=primitive->variables.begin() ; it != primitive->variables.end(); it++ )
{
if ( !primitive->isPrimitiveVariableValid( it->second ) )
{
IECore::msg( IECore::MessageHandler::Warning, "ToHoudiniGeometryConverter", "PrimitiveVariable " + it->first + " is invalid. Ignoring." );
filter += UT_String( " ^" + it->first );
continue;
}
ToHoudiniAttribConverterPtr converter = ToHoudiniAttribConverter::create( it->second.data.get() );
if ( !converter )
{
continue;
}
if ( it->second.data->isInstanceOf( StringVectorDataTypeId ) )
{
std::string indicesVariableName = it->first + "Indices";
PrimitiveVariableMap::const_iterator indices = primitive->variables.find( indicesVariableName );
if ( indices != primitive->variables.end() && indices->second.data->isInstanceOf( IntVectorDataTypeId ) && primitive->isPrimitiveVariableValid( indices->second ) )
{
stringsToIndices[it->first] = indices->second;
filter += UT_String( " ^" + indicesVariableName );
}
}
}
bool convertStandardAttributes = m_convertStandardAttributesParameter->getTypedValue();
if ( convertStandardAttributes && UT_String( "s" ).multiMatch( filter ) && UT_String( "t" ).multiMatch( filter ) )
{
// convert s and t to uv
PrimitiveVariableMap::const_iterator sPrimVar = primitive->variables.find( "s" );
PrimitiveVariableMap::const_iterator tPrimVar = primitive->variables.find( "t" );
if ( sPrimVar != primitive->variables.end() && tPrimVar != primitive->variables.end() )
{
if ( sPrimVar->second.interpolation == tPrimVar->second.interpolation )
{
const FloatVectorData *sData = runTimeCast<const FloatVectorData>( sPrimVar->second.data.get() );
const FloatVectorData *tData = runTimeCast<const FloatVectorData>( tPrimVar->second.data.get() );
if ( sData && tData )
{
const std::vector<float> &s = sData->readable();
const std::vector<float> &t = tData->readable();
std::vector<Imath::V3f> uvw;
uvw.reserve( s.size() );
for ( size_t i=0; i < s.size(); ++i )
{
uvw.push_back( Imath::V3f( s[i], 1 - t[i], 0 ) );
}
GA_Range range = vertRange;
if ( sPrimVar->second.interpolation == pointInterpolation )
{
range = points;
}
ToHoudiniAttribConverterPtr converter = ToHoudiniAttribConverter::create( new V3fVectorData( uvw ) );
converter->convert( "uv", geo, range );
filter += " ^s ^t";
}
}
}
}
UT_StringMMPattern attribFilter;
attribFilter.compile( filter );
// add the primitive variables to the various GEO_AttribDicts based on interpolation type
for ( PrimitiveVariableMap::const_iterator it=primitive->variables.begin() ; it != primitive->variables.end(); it++ )
{
UT_String varName( it->first );
if ( !varName.multiMatch( attribFilter ) )
{
continue;
}
PrimitiveVariable primVar = processPrimitiveVariable( primitive, it->second );
ToHoudiniAttribConverterPtr converter = ToHoudiniAttribConverter::create( primVar.data.get() );
if ( !converter )
{
continue;
}
PrimitiveVariable::Interpolation interpolation = primVar.interpolation;
if ( converter->isInstanceOf( (IECore::TypeId)ToHoudiniStringVectorAttribConverterTypeId ) )
{
PrimitiveVariableMap::const_iterator indices = stringsToIndices.find( it->first );
if ( indices != stringsToIndices.end() )
{
ToHoudiniStringVectorAttribConverter *stringVectorConverter = IECore::runTimeCast<ToHoudiniStringVectorAttribConverter>( converter.get() );
PrimitiveVariable indicesPrimVar = processPrimitiveVariable( primitive, indices->second );
stringVectorConverter->indicesParameter()->setValidatedValue( indicesPrimVar.data );
interpolation = indices->second.interpolation;
}
}
const std::string name = ( convertStandardAttributes ) ? processPrimitiveVariableName( it->first ) : it->first;
if ( interpolation == detailInterpolation )
{
// add detail attribs
try
{
converter->convert( name, geo );
}
catch ( std::exception &e )
{
throw IECore::Exception( "PrimitiveVariable \"" + it->first + "\" could not be converted as a Detail Attrib: " + e.what() );
}
}
else if ( interpolation == pointInterpolation )
{
// add point attribs
if ( name == "P" )
{
// special case for P
transferP( runTimeCast<const V3fVectorData>( primVar.data.get() ), geo, points );
}
else
{
try
{
GA_RWAttributeRef attrRef = converter->convert( name, geo, points );
// mark rest as non-transforming so it doesn't get manipulated once inside Houdini
if ( name == "rest" || name == "Pref" )
{
attrRef.getAttribute()->setNonTransforming( true );
}
}
catch ( std::exception &e )
{
throw IECore::Exception( "PrimitiveVariable \"" + it->first + "\" could not be converted as a Point Attrib: " + e.what() );
}
}
}
else if ( interpolation == primitiveInterpolation )
{
// add primitive attribs
try
{
converter->convert( name, geo, prims );
}
catch ( std::exception &e )
{
throw IECore::Exception( "PrimitiveVariable \"" + it->first + "\" could not be converted as a Primitive Attrib: " + e.what() );
}
}
else if ( interpolation == vertexInterpolation )
{
// add vertex attribs
try
{
converter->convert( name, geo, vertRange );
}
catch ( std::exception &e )
{
throw IECore::Exception( "PrimitiveVariable \"" + it->first + "\" could not be converted as a Vertex Attrib: " + e.what() );
}
}
}
// backwards compatibility with older data
const StringData *nameData = primitive->blindData()->member<StringData>( "name" );
if ( nameData && prims.isValid() )
{
ToHoudiniStringVectorAttribConverter::convertString( "name", nameData->readable(), geo, prims );
}
}
/// Cook the SOP! This method does all the work
OP_ERROR SOP_OpHolder::cookMySop( OP_Context &context )
{
IECore::MessageHandler::Scope handlerScope( getMessageHandler() );
// some defaults and useful variables
Imath::Box3f bbox( Imath::V3f(-1,-1,-1), Imath::V3f(1,1,1) );
float now = context.getTime();
// force eval of our nodes parameters with our hidden parameter expression
evalInt( "__evaluateParameters", 0, now );
// get our op
IECore::OpPtr op = IECore::runTimeCast<IECore::Op>( getParameterised() );
// check for a valid parameterised on this SOP
if ( !op )
{
UT_String msg( "Op Holder has no parameterised class to operate on!" );
addError( SOP_MESSAGE, msg );
return error();
}
if( lockInputs(context)>=UT_ERROR_ABORT )
{
return error();
}
// start our work
UT_Interrupt *boss = UTgetInterrupt();
boss->opStart("Building OpHolder Geometry...");
gdp->clearAndDestroy();
setParameterisedValues( now );
try
{
// make our Cortex op do it's thing...
op->operate();
// pass ourselves onto the GR_Cortex render hook
IECoreHoudini::NodePassData data( this, IECoreHoudini::NodePassData::CORTEX_OPHOLDER );
GA_RWAttributeRef attrRef = gdp->createAttribute( GA_ATTRIB_DETAIL, GA_SCOPE_PRIVATE, "IECoreHoudiniNodePassData", NULL, NULL, "blinddata" );
GA_Attribute *attr = attrRef.getAttribute();
const GA_AIFBlindData *blindData = attr->getAIFBlindData();
blindData->setDataSize( attr, sizeof(IECoreHoudini::NodePassData), &data );
// if our result is a visible renderable then set our bounds on our output gdp
const IECore::Object *result = op->resultParameter()->getValue();
IECore::ConstVisibleRenderablePtr renderable = IECore::runTimeCast<const IECore::VisibleRenderable>( result );
if ( renderable )
{
Imath::Box3f bbox = renderable->bound();
gdp->cube( bbox.min.x, bbox.max.x, bbox.min.y, bbox.max.y, bbox.min.z, bbox.max.z, 0, 0, 0, 1, 1 );
}
}
catch( boost::python::error_already_set )
{
addError( SOP_MESSAGE, "Error raised during Python evaluation!" );
IECorePython::ScopedGILLock lock;
PyErr_Print();
}
catch( const IECore::Exception &e )
{
addError( SOP_MESSAGE, e.what() );
}
catch( const std::exception &e )
{
addError( SOP_MESSAGE, e.what() );
}
catch( ... )
{
addError( SOP_MESSAGE, "Caught unknown exception!" );
}
// tidy up & go home!
boss->opEnd();
unlockInputs();
return error();
}
