void FromHoudiniGroupConverter::doUnnamedConversion( const GU_Detail *geo, Group *result, const CompoundObject *operands, const std::string &name ) const
{
GU_Detail newGeo( (GU_Detail*)geo );
GA_PrimitiveGroup *newGroup = static_cast<GA_PrimitiveGroup*>( newGeo.createInternalElementGroup( GA_ATTRIB_PRIMITIVE, "FromHoudiniGroupConverter__doUnnamedConversion" ) );
newGroup->toggleRange( newGeo.getPrimitiveRange() );
VisibleRenderablePtr renderable = 0;
doGroupConversion( &newGeo, newGroup, renderable, operands );
if ( renderable )
{
if ( Group *group = IECore::runTimeCast<Group>( renderable ) )
{
const Group::ChildContainer &children = group->children();
for ( Group::ChildContainer::const_iterator it = children.begin(); it != children.end(); ++it )
{
if ( name != "" )
{
(*it)->blindData()->member<StringData>( "name", false, true )->writable() = name;
}
result->addChild( *it );
}
}
else
{
if ( name != "" )
{
renderable->blindData()->member<StringData>( "name", false, true )->writable() = name;
}
result->addChild( renderable );
}
}
}
ObjectPtr FromHoudiniGroupConverter::doConversion( ConstCompoundObjectPtr operands ) const
{
GU_DetailHandleAutoReadLock readHandle( handle() );
const GU_Detail *geo = readHandle.getGdp();
if ( !geo )
{
return 0;
}
size_t numResultPrims = 0;
size_t numOrigPrims = geo->getNumPrimitives();
GroupPtr result = new Group();
if ( operands->member<const IntData>( "groupingMode" )->readable() == NameAttribute )
{
GA_ROAttributeRef attributeRef = geo->findPrimitiveAttribute( "name" );
if ( attributeRef.isInvalid() || !attributeRef.isString() )
{
GU_Detail ungroupedGeo( (GU_Detail*)geo );
GA_PrimitiveGroup *ungrouped = static_cast<GA_PrimitiveGroup*>( ungroupedGeo.createInternalElementGroup( GA_ATTRIB_PRIMITIVE, "FromHoudiniGroupConverter__ungroupedPrimitives" ) );
ungrouped->toggleRange( ungroupedGeo.getPrimitiveRange() );
VisibleRenderablePtr renderable = 0;
doGroupConversion( &ungroupedGeo, ungrouped, renderable, operands );
if ( renderable )
{
Group *group = runTimeCast<Group>( renderable );
if ( group )
{
const Group::ChildContainer &children = group->children();
for ( Group::ChildContainer::const_iterator it = children.begin(); it != children.end(); ++it )
{
result->addChild( *it );
}
}
else
{
result->addChild( renderable );
}
}
return result;
}
GU_Detail groupGeo( (GU_Detail*)geo );
AttributePrimIdGroupMap groupMap;
regroup( &groupGeo, groupMap, attributeRef );
for ( AttributePrimIdGroupMapIterator it=groupMap.begin(); it != groupMap.end(); ++it )
{
convertAndAddPrimitive( &groupGeo, it->second, result, operands, it->first.first );
}
}
else
{
for ( GA_GroupTable::iterator<GA_ElementGroup> it=geo->primitiveGroups().beginTraverse(); !it.atEnd(); ++it )
{
GA_PrimitiveGroup *group = static_cast<GA_PrimitiveGroup*>( it.group() );
if ( group->getInternal() || group->isEmpty() )
{
continue;
}
VisibleRenderablePtr renderable = 0;
numResultPrims += doGroupConversion( geo, group, renderable, operands );
if( !renderable )
{
continue;
}
renderable->blindData()->member<StringData>( "name", false, true )->writable() = group->getName().toStdString();
result->addChild( renderable );
}
if ( numOrigPrims == numResultPrims )
{
return result;
}
GU_Detail ungroupedGeo( (GU_Detail*)geo );
GA_PrimitiveGroup *ungrouped = static_cast<GA_PrimitiveGroup*>( ungroupedGeo.createInternalElementGroup( GA_ATTRIB_PRIMITIVE, "FromHoudiniGroupConverter__ungroupedPrimitives" ) );
for ( GA_GroupTable::iterator<GA_ElementGroup> it=geo->primitiveGroups().beginTraverse(); !it.atEnd(); ++it )
{
*ungrouped |= *static_cast<GA_PrimitiveGroup*>( it.group() );
}
ungrouped->toggleRange( ungroupedGeo.getPrimitiveRange() );
if ( ungrouped->isEmpty() )
{
return result;
}
VisibleRenderablePtr renderable = 0;
doGroupConversion( &ungroupedGeo, ungrouped, renderable, operands );
if ( renderable )
{
result->addChild( renderable );
}
}
return result;
}
ObjectPtr FromHoudiniGroupConverter::doConversion( ConstCompoundObjectPtr operands ) const
{
GroupPtr result = new Group();
if ( operands->member<const IntData>( "groupingMode" )->readable() == NameAttribute )
{
DetailSplitterPtr splitter = new DetailSplitter( handle() );
std::vector<std::string> children;
splitter->values( children );
if ( children.empty() )
{
doUnnamedConversion( GU_DetailHandleAutoReadLock( handle() ).getGdp(), result, operands );
return result;
}
for ( std::vector<std::string>::iterator it = children.begin(); it != children.end(); ++it )
{
const std::string &name = *it;
GU_DetailHandle childHandle = splitter->split( name );
if ( childHandle.isNull() )
{
continue;
}
GU_DetailHandleAutoReadLock readHandle( childHandle );
const GU_Detail *childGeo = readHandle.getGdp();
ObjectPtr child = doDetailConversion( childGeo, operands );
if ( !child )
{
// this happens when mismatched primitives share the same name
doUnnamedConversion( childGeo, result, operands, name );
}
else if ( VisibleRenderablePtr renderable = IECore::runTimeCast<VisibleRenderable>( child ) )
{
if ( name != "" )
{
renderable->blindData()->member<StringData>( "name", false, true )->writable() = name;
}
result->addChild( renderable );
}
}
}
else
{
GU_DetailHandleAutoReadLock readHandle( handle() );
const GU_Detail *geo = readHandle.getGdp();
if ( !geo )
{
return 0;
}
size_t numResultPrims = 0;
size_t numOrigPrims = geo->getNumPrimitives();
for ( GA_GroupTable::iterator<GA_ElementGroup> it=geo->primitiveGroups().beginTraverse(); !it.atEnd(); ++it )
{
GA_PrimitiveGroup *group = static_cast<GA_PrimitiveGroup*>( it.group() );
if ( group->getInternal() || group->isEmpty() )
{
continue;
}
VisibleRenderablePtr renderable = 0;
numResultPrims += doGroupConversion( geo, group, renderable, operands );
if( !renderable )
{
continue;
}
renderable->blindData()->member<StringData>( "name", false, true )->writable() = group->getName().toStdString();
result->addChild( renderable );
}
if ( numOrigPrims == numResultPrims )
{
return result;
}
GU_Detail ungroupedGeo( (GU_Detail*)geo );
GA_PrimitiveGroup *ungrouped = static_cast<GA_PrimitiveGroup*>( ungroupedGeo.createInternalElementGroup( GA_ATTRIB_PRIMITIVE, "FromHoudiniGroupConverter__ungroupedPrimitives" ) );
for ( GA_GroupTable::iterator<GA_ElementGroup> it=geo->primitiveGroups().beginTraverse(); !it.atEnd(); ++it )
{
*ungrouped |= *static_cast<GA_PrimitiveGroup*>( it.group() );
}
ungrouped->toggleRange( ungroupedGeo.getPrimitiveRange() );
if ( ungrouped->isEmpty() )
{
return result;
}
VisibleRenderablePtr renderable = 0;
doGroupConversion( &ungroupedGeo, ungrouped, renderable, operands );
if ( renderable )
{
result->addChild( renderable );
}
}
return result;
}
void IECoreMantra::ProceduralPrimitive::addVisibleRenderable( VisibleRenderablePtr renderable )
{
ToHoudiniGeometryConverterPtr converter = ToHoudiniGeometryConverter::create( renderable.get() );
if( !converter )
{
msg( Msg::Warning, "ProceduralPrimitive::addVisibleRenderable", "converter could not be found" );
return;
}
GU_Detail *gdp = allocateGeometry();
GU_DetailHandle handle;
handle.allocateAndSet( (GU_Detail*)gdp, false );
bool converted = converter->convert( handle );
if ( !converted )
{
msg( Msg::Warning, "ProceduralPrimitive::addVisibleRenderable", "converter failed" );
return;
}
/// \todo ToHoudiniGeometryConverter does not create a Houdini style uv attribute.
/// We make one from s and t. This code should probably live in a converter or in an Op that
/// remaps IECore conventions to common Houdini ones.
MeshPrimitivePtr mesh = runTimeCast<MeshPrimitive> (renderable);
if ( mesh )
{
gdp->addTextureAttribute( GA_ATTRIB_VERTEX );
GEO_AttributeHandle auv = gdp->getAttribute( GA_ATTRIB_VERTEX, "uv" );
GEO_AttributeHandle as = gdp->getAttribute( GA_ATTRIB_VERTEX, "s" );
GEO_AttributeHandle at = gdp->getAttribute( GA_ATTRIB_VERTEX, "t" );
if ( auv.isAttributeValid() && as.isAttributeValid() && at.isAttributeValid() )
{
GA_GBPrimitiveIterator it( *gdp );
GA_Primitive *p = it.getPrimitive();
while ( p )
{
for (int i = 0; i < p->getVertexCount(); ++i)
{
GA_Offset v = p->getVertexOffset(i);
as.setVertex(v);
at.setVertex(v);
auv.setVertex(v);
auv.setF( as.getF(0), 0 );
auv.setF( ((at.getF(0) * -1.0f) + 1.0f), 1 ); // wat, t arrives upside down for some reason.
auv.setF( 0.0f, 2 );
}
++it;
p = it.getPrimitive();
}
}
}
if ( m_renderer->m_motionType == RendererImplementation::Geometry )
{
msg(Msg::Debug, "IECoreMantra::ProceduralPrimitive::addVisibleRenderable", "MotionBlur:Geometry" );
if ( !m_renderer->m_motionTimes.empty() )
{
if ( (size_t)m_renderer->m_motionSize == m_renderer->m_motionTimes.size() )
{
openGeometryObject();
}
addGeometry(gdp, m_renderer->m_motionTimes.front());
m_renderer->m_motionTimes.pop_front();
if ( m_renderer->m_motionTimes.empty() )
{
applySettings();
closeObject();
}
}
}
else if ( m_renderer->m_motionType == RendererImplementation::ConcatTransform ||
m_renderer->m_motionType == RendererImplementation::SetTransform )
{
// It isn't clear that this will give correct results.
// ConcatTransform may need to interpolate transform snapshots.
msg(Msg::Debug, "IECoreMantra::ProceduralPrimitive::addVisibleRenderable", "MotionBlur:Transform" );
openGeometryObject();
addGeometry(gdp, 0.0f);
while ( !m_renderer->m_motionTimes.empty() )
{
setPreTransform( convert< UT_Matrix4T<float> >(m_renderer->m_motionTransforms.front()),
m_renderer->m_motionTimes.front() );
m_renderer->m_motionTimes.pop_front();
m_renderer->m_motionTransforms.pop_front();
}
applySettings();
closeObject();
m_renderer->m_motionType = RendererImplementation::Unknown;
}
else if ( m_renderer->m_motionType == RendererImplementation::Velocity )
{
msg(Msg::Debug, "IECoreMantra::ProceduralPrimitive::addVisibleRenderable", "MotionBlur:Velocity" );
import("global:fps", &m_fps, 1);
import("camera:shutter", m_cameraShutter, 2);
m_preBlur = -m_cameraShutter[0] / m_fps;
m_postBlur = -m_cameraShutter[1] / m_fps;
openGeometryObject();
addGeometry(gdp, 0.0f);
addVelocityBlurGeometry(gdp, m_preBlur, m_postBlur);
applySettings();
closeObject();
m_renderer->m_motionType = RendererImplementation::Unknown;
}
else
{
msg(Msg::Debug, "IECoreMantra::ProceduralPrimitive::addVisibleRenderable", "MotionBlur:None" );
openGeometryObject();
addGeometry( gdp, 0.0f );
setPreTransform( convert< UT_Matrix4T<float> >(m_renderer->m_transformStack.top()), 0.0f);
applySettings();
closeObject();
}
}
