bool ToHoudiniPolygonsConverter::doConversion( const VisibleRenderable *renderable, GU_Detail *geo ) const
{
const MeshPrimitive *mesh = static_cast<const MeshPrimitive *>( renderable );
if ( !mesh )
{
return false;
}
GA_Range newPoints = appendPoints( geo, mesh->variableSize( PrimitiveVariable::Vertex ) );
if ( !newPoints.isValid() || newPoints.empty() )
{
return false;
}
GA_OffsetList pointOffsets;
pointOffsets.reserve( newPoints.getEntries() );
for ( GA_Iterator it=newPoints.begin(); !it.atEnd(); ++it )
{
pointOffsets.append( it.getOffset() );
}
const std::vector<int> &vertexIds = mesh->vertexIds()->readable();
const std::vector<int> &verticesPerFace = mesh->verticesPerFace()->readable();
GA_OffsetList offsets;
offsets.reserve( verticesPerFace.size() );
size_t vertCount = 0;
size_t numPrims = geo->getNumPrimitives();
for ( size_t f=0; f < verticesPerFace.size(); f++ )
{
GU_PrimPoly *poly = GU_PrimPoly::build( geo, 0, GU_POLY_CLOSED, 0 );
offsets.append( geo->primitiveOffset( numPrims + f ) );
for ( size_t v=0; v < (size_t)verticesPerFace[f]; v++ )
{
poly->appendVertex( pointOffsets.get( vertexIds[ vertCount + verticesPerFace[f] - 1 - v ] ) );
}
vertCount += verticesPerFace[f];
}
GA_Range newPrims( geo->getPrimitiveMap(), offsets );
transferAttribs( geo, newPoints, newPrims );
// add the interpolation type
if ( newPrims.isValid() )
{
std::string interpolation = ( mesh->interpolation() == "catmullClark" ) ? "subdiv" : "poly";
StringVectorDataPtr interpolationVectorData = new StringVectorData();
interpolationVectorData->writable().push_back( interpolation );
std::vector<int> indexValues( newPrims.getEntries(), 0 );
IntVectorDataPtr indexData = new IntVectorData( indexValues );
ToHoudiniStringVectorAttribConverterPtr converter = new ToHoudiniStringVectorAttribConverter( interpolationVectorData );
converter->indicesParameter()->setValidatedValue( indexData );
converter->convert( "ieMeshInterpolation", geo, newPrims );
}
return true;
}
bool ToHoudiniPointsConverter::doConversion( const VisibleRenderable *renderable, GU_Detail *geo ) const
{
const PointsPrimitive *points = static_cast<const PointsPrimitive *>( renderable );
if ( !points )
{
return false;
}
const IECore::V3fVectorData *positions = points->variableData<V3fVectorData>( "P" );
if ( !positions )
{
// accept "position" so we can convert the results of the PDCParticleReader without having to rename things
/// \todo: Consider making the ParticleReader create a P if it doesn't exist for Cortex 6.
positions = points->variableData<V3fVectorData>( "position" );
}
GA_Range newPoints = appendPoints( geo, points->getNumPoints() );
if ( !newPoints.isValid() || newPoints.empty() )
{
return false;
}
transferAttribs( geo, newPoints, GA_Range() );
return true;
}
void ToHoudiniCortexObjectConverter::transferAttribs( GU_Detail *geo, const GA_Range &points, const GA_Range &prims ) const
{
GA_Primitive *hPrim = geo->getPrimitiveList().get( prims.begin().getOffset() );
if ( hPrim->getTypeId() != GU_CortexPrimitive::typeId() )
{
return;
}
const Primitive *input = IECore::runTimeCast<const Primitive>( srcParameter()->getValue() );
Primitive *output = IECore::runTimeCast<Primitive>( ((GU_CortexPrimitive *)hPrim)->getObject() );
if ( !input || !output )
{
return;
}
const char *filter = attributeFilterParameter()->getTypedValue().c_str();
for ( PrimitiveVariableMap::const_iterator it = input->variables.begin() ; it != input->variables.end(); ++it )
{
if ( !UT_String( it->first ).multiMatch( filter ) )
{
continue;
}
if ( output->isPrimitiveVariableValid( it->second ) )
{
output->variables[it->first] = it->second;
}
}
if ( UT_String( "P" ).multiMatch( filter ) )
{
geo->setPos3( points.begin().getOffset(), IECore::convert<UT_Vector3>( input->bound().center() ) );
}
}
bool SOP_SceneCacheSource::convertObject( IECore::Object *object, const std::string &name, const std::string &attributeFilter, bool hasAnimatedTopology, bool hasAnimatedPrimVars, const std::vector<InternedString> &animatedPrimVars )
{
VisibleRenderable *renderable = IECore::runTimeCast<VisibleRenderable>( object );
if ( !renderable )
{
return false;
}
ToHoudiniGeometryConverterPtr converter = ToHoudiniGeometryConverter::create( renderable );
if ( !converter )
{
return false;
}
// attempt to optimize the conversion by re-using animated primitive variables
const Primitive *primitive = IECore::runTimeCast<Primitive>( renderable );
GA_ROAttributeRef nameAttrRef = gdp->findStringTuple( GA_ATTRIB_PRIMITIVE, "name" );
GA_Range primRange = gdp->getRangeByValue( nameAttrRef, name.c_str() );
if ( primitive && !hasAnimatedTopology && hasAnimatedPrimVars )
{
if ( nameAttrRef.isValid() && !primRange.isEmpty() )
{
// this means constant topology and primitive variables, even though multiple samples were written
if ( animatedPrimVars.empty() )
{
return true;
}
GA_Range pointRange( *gdp, primRange, GA_ATTRIB_POINT, GA_Range::primitiveref(), false );
std::string animatedPrimVarStr = "";
for ( std::vector<InternedString>::const_iterator it = animatedPrimVars.begin(); it != animatedPrimVars.end(); ++it )
{
animatedPrimVarStr += it->string() + " ";
}
converter->attributeFilterParameter()->setTypedValue( animatedPrimVarStr );
converter->transferAttribs( gdp, pointRange, primRange );
return true;
}
}
else
{
gdp->destroyPrimitives( primRange, true );
}
// fallback to full conversion
converter->attributeFilterParameter()->setTypedValue( attributeFilter );
if ( converter->convert( myGdpHandle ) )
{
return true;
}
return false;
}
bool ToHoudiniPolygonsConverter::doConversion( const VisibleRenderable *renderable, GU_Detail *geo ) const
{
const MeshPrimitive *mesh = static_cast<const MeshPrimitive *>( renderable );
if ( !mesh )
{
return false;
}
GA_Range newPoints = appendPoints( geo, mesh->variableSize( PrimitiveVariable::Vertex ) );
if ( !newPoints.isValid() || newPoints.empty() )
{
return false;
}
GA_OffsetList pointOffsets;
pointOffsets.reserve( newPoints.getEntries() );
for ( GA_Iterator it=newPoints.begin(); !it.atEnd(); ++it )
{
pointOffsets.append( it.getOffset() );
}
const std::vector<int> &vertexIds = mesh->vertexIds()->readable();
const std::vector<int> &verticesPerFace = mesh->verticesPerFace()->readable();
GA_OffsetList offsets;
offsets.reserve( verticesPerFace.size() );
size_t vertCount = 0;
size_t numPrims = geo->getNumPrimitives();
for ( size_t f=0; f < verticesPerFace.size(); f++ )
{
GU_PrimPoly *poly = GU_PrimPoly::build( geo, 0, GU_POLY_CLOSED, 0 );
offsets.append( geo->primitiveOffset( numPrims + f ) );
for ( size_t v=0; v < (size_t)verticesPerFace[f]; v++ )
{
poly->appendVertex( pointOffsets.get( vertexIds[ vertCount + verticesPerFace[f] - 1 - v ] ) );
}
vertCount += verticesPerFace[f];
}
GA_Range newPrims( geo->getPrimitiveMap(), offsets );
transferAttribs( geo, newPoints, newPrims );
return true;
}
void ToHoudiniGeometryConverter::setName( GU_Detail *geo, const GA_Range &prims ) const
{
// add the name attribute based on the parameter
const std::string &name = nameParameter()->getTypedValue();
if ( name != "" && prims.isValid() )
{
ToHoudiniStringVectorAttribConverter::convertString( "name", name, geo, prims );
}
}
void SOP_SceneCacheSource::holdObject( IECore::Object *object, const std::string &name, bool hasAnimatedTopology, bool hasAnimatedPrimVars, const std::vector<InternedString> &animatedPrimVars )
{
// attempt to optimize the conversion by re-using animated primitive variables
const Primitive *primitive = IECore::runTimeCast<Primitive>( object );
GA_ROAttributeRef nameAttrRef = gdp->findStringTuple( GA_ATTRIB_PRIMITIVE, "name" );
GA_Range primRange = gdp->getRangeByValue( nameAttrRef, name.c_str() );
if ( primitive && !hasAnimatedTopology && hasAnimatedPrimVars && nameAttrRef.isValid() && !primRange.isEmpty() )
{
// this means constant topology and primitive variables, even though multiple samples were written
if ( animatedPrimVars.empty() )
{
return;
}
GA_Primitive *hPrim = gdp->getPrimitiveList().get( primRange.begin().getOffset() );
if ( hPrim->getTypeId() == GU_CortexPrimitive::typeId() )
{
/// \todo: can we just update the prim vars?
((GU_CortexPrimitive *)hPrim)->setObject( primitive );
GA_Range pointRange( *gdp, primRange, GA_ATTRIB_POINT, GA_Range::primitiveref(), false );
gdp->setPos3( pointRange.begin().getOffset(), IECore::convert<UT_Vector3>( primitive->bound().center() ) );
return;
}
}
else
{
gdp->destroyPrimitives( primRange, true );
}
size_t numPrims = gdp->getNumPrimitives();
GU_CortexPrimitive::build( gdp, object );
GA_Offset primOffset = gdp->primitiveOffset( numPrims );
GA_OffsetList offsets;
offsets.append( primOffset );
GA_Range newPrims( gdp->getPrimitiveMap(), offsets );
ToHoudiniStringVectorAttribConverter::convertString( "name", name, gdp, newPrims );
}
void ToHoudiniGeometryConverter::transferP( const IECore::V3fVectorData *positions, GU_Detail *geo, const GA_Range &points ) const
{
if ( !positions )
{
return;
}
const std::vector<Imath::V3f> &pos = positions->readable();
size_t i = 0;
for ( GA_Iterator it=points.begin(); !it.atEnd(); ++it, ++i )
{
geo->setPos3( it.getOffset(), IECore::convert<UT_Vector3>( pos[i] ) );
}
}
OP_ERROR SOP_SceneCacheSource::cookMySop( OP_Context &context )
{
// make sure the state is valid
if ( boost::indeterminate( m_static ) )
{
sceneChanged();
}
flags().setTimeDep( bool( !m_static ) );
std::string file;
if ( !ensureFile( file ) )
{
addError( SOP_ATTRIBUTE_INVALID, ( file + " is not a valid .scc" ).c_str() );
gdp->clearAndDestroy();
return error();
}
std::string path = getPath();
Space space = getSpace();
GeometryType geometryType = (GeometryType)this->evalInt( pGeometryType.getToken(), 0, 0 );
UT_String tagFilterStr;
getTagFilter( tagFilterStr );
UT_StringMMPattern tagFilter;
tagFilter.compile( tagFilterStr );
UT_String shapeFilterStr;
getShapeFilter( shapeFilterStr );
UT_StringMMPattern shapeFilter;
shapeFilter.compile( shapeFilterStr );
UT_String p( "P" );
UT_String attributeFilter;
getAttributeFilter( attributeFilter );
if ( !p.match( attributeFilter ) )
{
attributeFilter += " P";
}
UT_String attributeCopy;
getAttributeCopy( attributeCopy );
UT_String fullPathName;
getFullPathName( fullPathName );
ConstSceneInterfacePtr scene = this->scene( file, path );
if ( !scene )
{
addError( SOP_ATTRIBUTE_INVALID, ( path + " is not a valid location in " + file ).c_str() );
gdp->clearAndDestroy();
return error();
}
MurmurHash hash;
hash.append( file );
hash.append( path );
hash.append( space );
hash.append( tagFilterStr );
hash.append( shapeFilterStr );
hash.append( attributeFilter );
hash.append( attributeCopy );
hash.append( fullPathName );
hash.append( geometryType );
hash.append( getObjectOnly() );
if ( !m_loaded || m_hash != hash )
{
gdp->clearAndDestroy();
}
double readTime = time( context );
Imath::M44d transform = ( space == World ) ? worldTransform( file, path, readTime ) : Imath::M44d();
SceneInterface::Path rootPath;
scene->path( rootPath );
UT_Interrupt *progress = UTgetInterrupt();
if ( !progress->opStart( ( "Cooking objects for " + getPath() ).c_str() ) )
{
addError( SOP_ATTRIBUTE_INVALID, "Cooking interrupted before it started" );
gdp->clearAndDestroy();
return error();
}
Parameters params;
UT_String attribFilter;
getAttributeFilter( attribFilter );
params.attributeFilter = attribFilter.toStdString();
params.attributeCopy = attributeCopy.toStdString();
params.fullPathName = fullPathName.toStdString();
params.geometryType = getGeometryType();
getShapeFilter( params.shapeFilter );
getTagFilter( params.tagFilter );
// Building a map from shape name to primitive range, which will be used during
// convertObject() to do a lazy update of animated primvars where possible, and
// to destroy changing topology shapes when necessary.
GA_ROAttributeRef nameAttrRef = gdp->findStringTuple( GA_ATTRIB_PRIMITIVE, "name" );
if ( nameAttrRef.isValid() )
{
const GA_Attribute *attr = nameAttrRef.getAttribute();
const GA_AIFSharedStringTuple *tuple = attr->getAIFSharedStringTuple();
std::map<std::string, GA_OffsetList> offsets;
GA_Range primRange = gdp->getPrimitiveRange();
for ( GA_Iterator it = primRange.begin(); !it.atEnd(); ++it )
{
std::string current = "";
if ( const char *value = tuple->getString( attr, it.getOffset() ) )
{
current = value;
}
std::map<std::string, GA_OffsetList>::iterator oIt = offsets.find( current );
if ( oIt == offsets.end() )
{
oIt = offsets.insert( std::pair<std::string, GA_OffsetList>( current, GA_OffsetList() ) ).first;
}
oIt->second.append( it.getOffset() );
}
for ( std::map<std::string, GA_OffsetList>::iterator oIt = offsets.begin(); oIt != offsets.end(); ++oIt )
{
params.namedRanges[oIt->first] = GA_Range( gdp->getPrimitiveMap(), oIt->second );
}
}
loadObjects( scene.get(), transform, readTime, space, params, rootPath.size() );
if ( progress->opInterrupt( 100 ) )
{
addError( SOP_ATTRIBUTE_INVALID, "Cooking interrupted" );
gdp->clearAndDestroy();
m_loaded = false;
m_hash = MurmurHash();
}
else
{
m_loaded = true;
m_hash = hash;
}
progress->opEnd();
return error();
}
bool ToHoudiniCurvesConverter::doConversion( const VisibleRenderable *renderable, GU_Detail *geo ) const
{
const CurvesPrimitive *curves = static_cast<const CurvesPrimitive *>( renderable );
if ( !curves )
{
return false;
}
bool periodic = curves->periodic();
bool duplicatedEnds = !periodic && ( curves->basis() == CubicBasisf::bSpline() );
size_t numPoints = curves->variableSize( PrimitiveVariable::Vertex );
if ( duplicatedEnds )
{
numPoints -= 4 * curves->numCurves();
}
GA_Range newPoints = appendPoints( geo, numPoints );
if ( !newPoints.isValid() || newPoints.empty() )
{
return false;
}
GA_OffsetList pointOffsets;
pointOffsets.reserve( newPoints.getEntries() );
for ( GA_Iterator it=newPoints.begin(); !it.atEnd(); ++it )
{
pointOffsets.append( it.getOffset() );
}
const std::vector<int> &verticesPerCurve = curves->verticesPerCurve()->readable();
int order = ( curves->basis() == CubicBasisf::bSpline() ) ? 4 : 2;
bool interpEnds = !(periodic && ( curves->basis() == CubicBasisf::bSpline() ));
GA_OffsetList offsets;
offsets.reserve( verticesPerCurve.size() );
size_t vertCount = 0;
size_t numPrims = geo->getNumPrimitives();
for ( size_t c=0; c < verticesPerCurve.size(); c++ )
{
size_t numVerts = duplicatedEnds ? verticesPerCurve[c] - 4 : verticesPerCurve[c];
GU_PrimNURBCurve *curve = GU_PrimNURBCurve::build( geo, numVerts, order, periodic, interpEnds, false );
if ( !curve )
{
return false;
}
offsets.append( geo->primitiveOffset( numPrims + c ) );
for ( size_t v=0; v < numVerts; v++ )
{
curve->setVertexPoint( v, pointOffsets.get( vertCount + v ) );
}
vertCount += numVerts;
}
GA_Range newPrims( geo->getPrimitiveMap(), offsets );
transferAttribs( geo, newPoints, newPrims );
return true;
}
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 );
}
}
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 );
}
}
OP_ERROR SOP_InterpolatedCacheReader::cookMySop( OP_Context &context )
{
flags().setTimeDep( true );
if ( lockInputs( context ) >= UT_ERROR_ABORT )
{
return error();
}
gdp->stashAll();
float time = context.getTime();
float frame = context.getFloatFrame();
UT_String paramVal;
evalString( paramVal, "cacheSequence", 0, time );
std::string cacheFileName = paramVal.toStdString();
evalString( paramVal, "objectFixes", 0, time );
std::string objectPrefix = paramVal.toStdString();
evalString( paramVal, "objectFixes", 1, time );
std::string objectSuffix = paramVal.toStdString();
evalString( paramVal, "attributeFixes", 0, time );
std::string attributePrefix = paramVal.toStdString();
evalString( paramVal, "attributeFixes", 1, time );
std::string attributeSuffix = paramVal.toStdString();
evalString( paramVal, "transformAttribute", 0, time );
std::string transformAttribute = paramVal.toStdString();
int samplesPerFrame = evalInt( "samplesPerFrame", 0, time );
InterpolatedCache::Interpolation interpolation = (InterpolatedCache::Interpolation)evalInt( "interpolation", 0, time );
GroupingMode groupingMode = (GroupingMode)evalInt( "groupingMode", 0, time );
// create the InterpolatedCache
if ( cacheFileName.compare( m_cacheFileName ) != 0 || samplesPerFrame != m_samplesPerFrame || interpolation != m_interpolation )
{
try
{
float fps = OPgetDirector()->getChannelManager()->getSamplesPerSec();
OversamplesCalculator calc( fps, samplesPerFrame );
m_cache = new InterpolatedCache( cacheFileName, interpolation, calc );
}
catch ( IECore::InvalidArgumentException e )
{
addWarning( SOP_ATTRIBUTE_INVALID, e.what() );
unlockInputs();
return error();
}
m_cacheFileName = cacheFileName;
m_samplesPerFrame = samplesPerFrame;
m_interpolation = interpolation;
}
if ( !m_cache )
{
addWarning( SOP_MESSAGE, "SOP_InterpolatedCacheReader: Cache Sequence not found" );
unlockInputs();
return error();
}
std::vector<InterpolatedCache::ObjectHandle> objects;
std::vector<InterpolatedCache::AttributeHandle> attrs;
try
{
m_cache->objects( frame, objects );
}
catch ( IECore::Exception e )
{
addWarning( SOP_ATTRIBUTE_INVALID, e.what() );
unlockInputs();
return error();
}
duplicatePointSource( 0, context );
GA_ElementGroupTable *groups = 0;
if ( groupingMode == PointGroup )
{
groups = &gdp->pointGroups();
}
else if ( groupingMode == PrimitiveGroup )
{
groups = &gdp->primitiveGroups();
}
for ( GA_GroupTable::iterator<GA_ElementGroup> it=groups->beginTraverse(); !it.atEnd(); ++it )
{
GA_ElementGroup *group = it.group();
if ( group->getInternal() || group->isEmpty() )
{
continue;
}
// match GA_ElementGroup name to InterpolatedCache::ObjectHandle
std::string searchName = objectPrefix + group->getName().toStdString() + objectSuffix;
std::vector<InterpolatedCache::ObjectHandle>::iterator oIt = find( objects.begin(), objects.end(), searchName );
if ( oIt == objects.end() )
{
continue;
}
CompoundObjectPtr attributes = 0;
try
{
m_cache->attributes( frame, *oIt, attrs );
attributes = m_cache->read( frame, *oIt );
}
catch ( IECore::Exception e )
{
addError( SOP_ATTRIBUTE_INVALID, e.what() );
unlockInputs();
return error();
}
const CompoundObject::ObjectMap &attributeMap = attributes->members();
GA_Range pointRange;
GA_Range primRange;
GA_Range vertexRange;
if ( groupingMode == PointGroup )
{
pointRange = gdp->getPointRange( (GA_PointGroup*)it.group() );
}
else if ( groupingMode == PrimitiveGroup )
{
primRange = gdp->getPrimitiveRange( (GA_PrimitiveGroup*)it.group() );
const GA_PrimitiveList &primitives = gdp->getPrimitiveList();
GA_OffsetList pointOffsets;
GA_OffsetList vertOffsets;
for ( GA_Iterator it=primRange.begin(); !it.atEnd(); ++it )
{
const GA_Primitive *prim = primitives.get( it.getOffset() );
GA_Range primPointRange = prim->getPointRange();
for ( GA_Iterator pIt=primPointRange.begin(); !pIt.atEnd(); ++pIt )
{
pointOffsets.append( pIt.getOffset() );
}
size_t numPrimVerts = prim->getVertexCount();
for ( size_t v=0; v < numPrimVerts; v++ )
{
if ( prim->getTypeId() == GEO_PRIMPOLY )
{
vertOffsets.append( prim->getVertexOffset( numPrimVerts - 1 - v ) );
}
else
{
vertOffsets.append( prim->getVertexOffset( v ) );
}
}
}
pointOffsets.sortAndRemoveDuplicates();
pointRange = GA_Range( gdp->getPointMap(), pointOffsets );
vertexRange = GA_Range( gdp->getVertexMap(), vertOffsets );
}
// transfer the InterpolatedCache::Attributes onto the GA_ElementGroup
for ( CompoundObject::ObjectMap::const_iterator aIt=attributeMap.begin(); aIt != attributeMap.end(); aIt++ )
{
Data *data = IECore::runTimeCast<Data>( aIt->second );
if ( !data )
{
continue;
}
ToHoudiniAttribConverterPtr converter = ToHoudiniAttribConverter::create( data );
if ( !converter )
{
continue;
}
// strip the prefix/suffix from the GA_Attribute name
std::string attrName = aIt->first.value();
size_t prefixLength = attributePrefix.length();
if ( prefixLength && ( search( attrName.begin(), attrName.begin()+prefixLength, attributePrefix.begin(), attributePrefix.end() ) == attrName.begin() ) )
{
attrName.erase( attrName.begin(), attrName.begin() + prefixLength );
}
size_t suffixLength = attributeSuffix.length();
if ( suffixLength && ( search( attrName.end() - suffixLength, attrName.end(), attributeSuffix.begin(), attributeSuffix.end() ) == ( attrName.end() - suffixLength ) ) )
{
attrName.erase( attrName.end() - suffixLength, attrName.end() );
}
if ( attrName == "P" )
{
const V3fVectorData *positions = IECore::runTimeCast<const V3fVectorData>( data );
if ( !positions )
{
continue;
}
size_t index = 0;
size_t entries = pointRange.getEntries();
const std::vector<Imath::V3f> &pos = positions->readable();
// Attempting to account for the vertex difference between an IECore::CurvesPrimitive and Houdini curves.
// As Houdini implicitly triples the endpoints of a curve, a cache generated from a single CurvesPrimitive
// will have exactly four extra vertices. In this case, we adjust the cache by ignoring the first two and
// last two V3fs. In all other cases, we report a warning and don't apply the cache to these points.
if ( pos.size() - 4 == entries )
{
index = 2;
}
else if ( pos.size() != entries )
{
addWarning( SOP_ATTRIBUTE_INVALID, ( boost::format( "Geometry/Cache mismatch: %s contains %d points, while cache expects %d values for P." ) % group->getName().toStdString() % entries % pos.size() ).str().c_str() );
continue;
}
/// \todo: try multi-threading this with a GA_SplittableRange
for ( GA_Iterator it=pointRange.begin(); !it.atEnd(); ++it, ++index )
{
gdp->setPos3( it.getOffset(), IECore::convert<UT_Vector3>( pos[index] ) );
}
}
else if ( groupingMode == PrimitiveGroup )
{
GA_Range currentRange;
unsigned size = despatchTypedData<TypedDataSize, TypeTraits::IsVectorTypedData, DespatchTypedDataIgnoreError>( data );
// check for existing attributes
if ( gdp->findPrimitiveAttribute( attrName.c_str() ).isValid() && size == primRange.getEntries() )
{
currentRange = primRange;
}
else if ( gdp->findPointAttribute( attrName.c_str() ).isValid() && size == pointRange.getEntries() )
{
currentRange = pointRange;
}
else if ( gdp->findVertexAttribute( attrName.c_str() ).isValid() && size == vertexRange.getEntries() )
{
currentRange = vertexRange;
}
// fall back to Cortex standard inferred order
else if ( size == primRange.getEntries() )
{
currentRange = primRange;
}
else if ( size == pointRange.getEntries() )
{
currentRange = pointRange;
}
else if ( size == vertexRange.getEntries() )
{
currentRange = vertexRange;
}
else
{
addWarning( SOP_ATTRIBUTE_INVALID, ( boost::format( "Geometry/Cache mismatch: %s: cache expects %d values for %s." ) % group->getName().toStdString() % size % attrName ).str().c_str() );
continue;
}
converter->convert( attrName, gdp, currentRange );
}
else
{
converter->convert( attrName, gdp, pointRange );
}
}
// if transformAttribute is specified, use to to transform the points
if ( transformAttribute != "" )
{
const TransformationMatrixdData *transform = attributes->member<TransformationMatrixdData>( transformAttribute );
if ( transform )
{
UT_Matrix4 matrix( IECore::convert<UT_Matrix4T<double> >( transform->readable().transform() ) );
gdp->transformGroup( matrix, *group );
}
else
{
const TransformationMatrixfData *transform = attributes->member<TransformationMatrixfData>( transformAttribute );
if ( transform )
{
UT_Matrix4 matrix = IECore::convert<UT_Matrix4>( transform->readable().transform() );
gdp->transformGroup( matrix, *group );
}
}
}
}
unlockInputs();
return error();
}
void
GusdRefiner::refineDetail(
const GU_ConstDetailHandle& detail,
const GT_RefineParms& refineParms )
{
m_refineParms = refineParms;
GU_DetailHandleAutoReadLock detailLock( detail );
GA_ROHandleS partitionAttr;
if( !m_pathAttrName.empty() ) {
partitionAttr =
detailLock->findStringTuple(
GA_ATTRIB_PRIMITIVE,
m_pathAttrName.c_str() );
}
std::vector<GA_Range> partitions;
GA_Range primRange = detailLock->getPrimitiveRange();
if(!partitionAttr.isValid() || primRange.getEntries() == 0) {
partitions.push_back(primRange);
}
else {
typedef UT_Map<GA_StringIndexType, GA_OffsetList> PrimPartitionMap;
PrimPartitionMap partitionMap;
for(GA_Iterator offsetIt(primRange); !offsetIt.atEnd(); ++offsetIt) {
GA_StringIndexType idx = partitionAttr.getIndex(offsetIt.getOffset());
partitionMap[idx].append(offsetIt.getOffset());
}
partitions.reserve(partitionMap.size());
for(PrimPartitionMap::const_iterator mapIt=partitionMap.begin();
mapIt != partitionMap.end(); ++mapIt) {
partitions.push_back(GA_Range(detailLock->getPrimitiveMap(),
mapIt->second));
}
}
// Refine each geometry partition to prims that can be written to USD.
// The results are accumulated in buffer in the refiner.
for(vector<GA_Range>::const_iterator rangeIt=partitions.begin();
rangeIt != partitions.end(); ++rangeIt) {
const GA_Range& range = *rangeIt;
// Before we refine we need to decide if we want to coalesce packed
// fragments. We will coalesce unless we are writing transform
// overlays and the fragment has a name.
GU_DetailHandleAutoReadLock detailLock( detail );
bool overlayTransforms = false;
GA_AttributeOwner order[] = { GA_ATTRIB_PRIMITIVE, GA_ATTRIB_DETAIL };
const GA_Attribute *overTransformsAttr =
detailLock->findAttribute( GUSD_OVERTRANSFORMS_ATTR, order, 2 );
if( overTransformsAttr ) {
GA_ROHandleI h( overTransformsAttr );
if( overTransformsAttr->getOwner() == GA_ATTRIB_DETAIL ) {
overlayTransforms = h.get( GA_Offset(0) );
}
else {
// assume all prims in the range have the same usdovertransforms
// attribute value
overlayTransforms = h.get( range.begin().getOffset() );
}
}
if( overlayTransforms ) {
// prims must be named to overlay transforms
const GA_Attribute *primPathAttr =
detailLock->findPrimitiveAttribute( GUSD_PRIMPATH_ATTR );
if( !primPathAttr ) {
overlayTransforms = false;
}
}
GT_RefineParms newRefineParms( refineParms );
newRefineParms.setCoalesceFragments( m_refinePackedPrims && !overlayTransforms );
GT_PrimitiveHandle detailPrim
= GT_GEODetail::makeDetail( detail, &range);
if(detailPrim) {
detailPrim->refine(*this, &newRefineParms );
}
}
}
