ReturnType operator()( const T *data ) { PrimitiveVariableMap::iterator it = m_mesh->variables.find( m_name ); if ( it == m_mesh->variables.end() && !m_remove ) { typename T::Ptr data2 = 0; std::map<ConstDataPtr, DataPtr>::iterator dataIt = m_visitedData.find( data ); if ( dataIt != m_visitedData.end() ) { data2 = runTimeCast<T>( dataIt->second ); } if ( !data2 ) { typedef typename T::ValueType::value_type ValueType; ValueType defaultValue = DefaultValue<ValueType>()(); size_t size = m_mesh->variableSize( m_interpolation ) - data->readable().size(); data2 = new T(); data2->writable().insert( data2->writable().end(), size, defaultValue ); data2->writable().insert( data2->writable().end(), data->readable().begin(), data->readable().end() ); } m_mesh->variables[m_name] = PrimitiveVariable( m_interpolation, data2 ); m_visitedData[data] = data2; } }
FromHoudiniCurvesConverter::DuplicateEnds::ReturnType FromHoudiniCurvesConverter::DuplicateEnds::operator()( typename T::Ptr data ) const { assert( data ); typedef typename T::ValueType::value_type ValueType; std::vector<ValueType> newValues; const std::vector<ValueType> &origValues = data->readable(); size_t index = 0; for ( size_t i=0; i < m_vertsPerCurve.size(); i++ ) { for ( size_t j=0; j < (size_t)m_vertsPerCurve[i]; j++, index++ ) { newValues.push_back( origValues[index] ); if ( j == 0 || j == (size_t)m_vertsPerCurve[i]-1 ) { newValues.push_back( origValues[index] ); newValues.push_back( origValues[index] ); } } } data->writable().swap( newValues ); }
ReturnType operator()( T * data ) { typedef typename T::ValueType VecContainer; typedef typename VecContainer::value_type Vec; const VecContainer &points = data->readable(); unsigned numElements = points.size(); typename T::Ptr vD = new T(); vTangentsData = vD; VecContainer &vTangents = vD->writable(); vTangents.resize( numElements ); PrimitiveEvaluator::ResultPtr result = m_evaluator->createResult(); unsigned pIndex = 0; for( size_t curveIndex = 0; curveIndex < m_vertsPerCurve.size() ; curveIndex++ ) { float v; float vStep = 1.0f / m_vertsPerCurve[curveIndex]; for( int i = 0; i < m_vertsPerCurve[curveIndex]; i++ ) { v = min( 1.0f, i * vStep ); m_evaluator->pointAtV( curveIndex, v, result ); vTangents[ pIndex + i ] = result->vTangent().normalized(); } pIndex += m_vertsPerCurve[curveIndex]; } }
typename T::Ptr vectorDataFromTypeDesc( TypeDesc type, void *&basePointer ) { typename T::Ptr result = new T(); result->writable().resize( type.arraylen, typename T::ValueType::value_type( 0 ) ); basePointer = result->baseWritable(); return result; }
ToHoudiniCurvesConverter::RemoveDuplicateEnds::ReturnType ToHoudiniCurvesConverter::RemoveDuplicateEnds::operator()( typename T::ConstPtr data ) const { assert( data ); typedef typename T::ValueType::value_type ValueType; const std::vector<ValueType> &origValues = data->readable(); typename T::Ptr result = new T(); std::vector<ValueType> &newValues = result->writable(); size_t index = 0; for ( size_t i=0; i < m_vertsPerCurve.size(); i++ ) { for ( size_t j=0; j < (size_t)m_vertsPerCurve[i]; j++, index++ ) { if ( j > 1 && j < (size_t)m_vertsPerCurve[i]-2 ) { newValues.push_back( origValues[index] ); } } } return result; }
static DataPtr evaluatePrimitiveVariable( std::vector<GxSurfacePoint> &points, const std::string &primVarName ) { typename T::Ptr result = new T; result->writable().resize( points.size() ); if( points.size() ) { GxEvaluateSurface( points.size(), &(points[0]), primVarName.c_str(), result->baseSize() / points.size(), result->baseWritable() ); } return result; }
DataPtr operator() ( T * data ) const { assert( data ); typedef typename T::ValueType::value_type Value; const unsigned vPoints = m_resolution.y; const unsigned uPoints = m_resolution.x; typename T::Ptr newData = new T(); newData->writable().reserve( ( vPoints + 2 ) * uPoints ); for ( unsigned int v = 0; v < vPoints; v++ ) { size_t iSeg; float fSeg; if ( v == vPoints - 1 ) { iSeg = m_curves->numSegments( m_curveIndex ) - 1; fSeg = 0.9999f; } else { float curveParam = float(v) / ( vPoints - 1 ); fSeg = curveParam * m_curves->numSegments( m_curveIndex ); iSeg = (size_t)floor( fSeg ); fSeg = fSeg - iSeg; } const int num = v == 0 || v == vPoints - 1 ? 2 : 1; const size_t i0 = iSeg; const size_t i1 = std::min( iSeg + 1, m_curves->variableSize( PrimitiveVariable::Varying, m_curveIndex ) ); for ( int x = 0; x < num; x++) { for ( unsigned u = 0; u < uPoints ; u ++) { Value value; LinearInterpolator<Value>()( data->readable()[ m_varyingOffset + i0 ], data->readable()[ m_varyingOffset + i1], fSeg, value ); newData->writable().push_back( value ); } } } return newData; }
IECore::DataPtr operator()( typename T::Ptr inData ) { assert( inData ); const typename T::Ptr outData = new T(); outData->writable().resize( m_vertIds->readable().size() ); typename T::ValueType::iterator outIt = outData->writable().begin(); for ( typename T::ValueType::size_type i = 0; i < m_vertIds->readable().size(); i++ ) { *outIt++ = inData->readable()[ m_vertIds->readable()[ i ] ]; } return outData; }
DataPtr operator() ( typename T::Ptr data ) const { assert( data ); typedef typename T::ValueType::value_type Value; const unsigned vPoints = m_resolution.y; const unsigned uPoints = m_resolution.x; typename T::Ptr newData = new T(); newData->writable().reserve( ( vPoints ) * uPoints ); for ( unsigned int v = 0; v < vPoints; v++ ) { int iSeg; float fSeg; if ( v == vPoints - 1 ) { iSeg = m_curves->numSegments( m_curveIndex ) - 1; fSeg = 0.9999f; } else { float curveParam = float(v) / ( vPoints - 1 ); fSeg = curveParam * m_curves->numSegments( m_curveIndex ); iSeg = (int)floor( fSeg ); fSeg = fSeg - iSeg; } for ( unsigned u = 0; u < uPoints ; u ++) { Value value; LinearInterpolator<Value>()( data->readable()[ m_varyingOffset + iSeg ], data->readable()[ m_varyingOffset + iSeg + 1], fSeg, value ); newData->writable().push_back( value ); } } return newData; }
IECore::DataPtr operator()( const T *inData ) { const typename T::Ptr outData = new T(); typename T::ValueType &out = outData->writable(); out.resize( m_numVertices ); size_t inIndex = 0; size_t outIndex = 0; const typename T::ValueType &in = inData->readable(); for( vector<int>::const_iterator it = m_vertsPerCurve.begin(), eIt = m_vertsPerCurve.end(); it != eIt; it++ ) { for( int i=0; i<*it; i++ ) { out[outIndex++] = in[inIndex]; } inIndex += m_step; } return outData; }
IECore::ObjectPtr FromMayaArrayDataConverter<F,T>::doConversion( const MObject &object, IECore::ConstCompoundObjectPtr operands ) const { typename MArrayTraits<F>::DataFn fnArrayData( object ); if( !fnArrayData.hasObj( object ) ) { return 0; } F array = fnArrayData.array(); typename T::Ptr resultData = new T; typename T::ValueType &resultArray = resultData->writable(); resultArray.resize( array.length() ); for( unsigned int i=0; i<resultArray.size(); i++ ) { resultArray[i] = IECore::convert<typename T::ValueType::value_type, typename MArrayTraits<F>::ValueType>( array[i] ); } return resultData; }
Analysis::Result::Ptr DetectIn(LookaheadPluginsStorage<T>& container, DataLocation::Ptr input, const Module::DetectCallback& callback) const { const bool firstScan = 0 == Offset; const std::size_t maxSize = input->GetData()->Size(); for (typename T::Iterator::Ptr iter = container.Enumerate(); iter->IsValid(); iter->Next()) { Time::Timer timer; const typename T::Ptr plugin = iter->Get(); const Analysis::Result::Ptr result = plugin->Detect(Params, input, callback); const String id = plugin->GetDescription()->Id(); if (const std::size_t usedSize = result->GetMatchedDataSize()) { Statistic::Self().AddAimed(*plugin, timer); Dbg("Detected %1% in %2% bytes at %3%.", id, usedSize, input->GetPath()->AsString()); return result; } else { if (!firstScan) { Statistic::Self().AddMissed(*plugin, timer); timer = Time::Timer(); } const std::size_t lookahead = result->GetLookaheadOffset(); container.SetPluginLookahead(*plugin, id, lookahead); if (lookahead == maxSize) { Statistic::Self().AddAimed(*plugin, timer); } else { Statistic::Self().AddScanned(*plugin, timer); } } } const std::size_t minLookahead = container.GetMinimalPluginLookahead(); return Analysis::CreateUnmatchedResult(minLookahead); }
ReturnType operator()( typename T::Ptr data ) { typedef typename T::ValueType Container; typedef typename Container::value_type V; Container &output = data->writable(); V2i paddedSize = m_size + V2i( 2 ); V *op = &(output[0]); const char *ip = &(m_input[0]) + paddedSize.x + 1; for( int y=0; y<m_size.y; y++ ) { for( int x=0; x<m_size.x; x++ ) { *op++ = *ip++; } ip +=2; // skip padding on right and left of next row } }
object operator()( typename T::Ptr data ) { return object( data->readable() ); }
typename T::Ptr geometricVectorDataFromTypeDesc( TypeDesc type, void *&basePointer ) { typename T::Ptr result = vectorDataFromTypeDesc<T>( type, basePointer ); result->setInterpretation( geometricInterpretationFromVecSemantics( (TypeDesc::VECSEMANTICS)type.vecsemantics ) ); return result; }
static typename T::Ptr hexToDecVector( const char *s ) { typename T::Ptr result = new T; IECore::hexToDec<typename T::ValueType::value_type>( s, s + strlen( s ), std::back_insert_iterator<typename T::ValueType>( result->writable() ) ); return result; }
DataPtr operator() ( typename T::Ptr data ) const { assert( data ); return new TypedData< typename T::ValueType::value_type >( data->readable()[ m_curveIndex ] ); }
ReturnType operator()( T * data ) { typedef typename T::ValueType VecContainer; typedef typename VecContainer::value_type Vec; const VecContainer &points = data->readable(); // the uvIndices array is indexed as with any other facevarying data. the values in the // array specify the connectivity of the uvs - where two facevertices have the same index // they are known to be sharing a uv. for each one of these unique indices we compute // the tangents and normal, by accumulating all the tangents and normals for the faces // that reference them. we then take this data and shuffle it back into facevarying // primvars for the mesh. int numUniqueTangents = 1 + *max_element( m_uvIds.begin(), m_uvIds.end() ); VecContainer uTangents( numUniqueTangents, Vec( 0 ) ); VecContainer vTangents( numUniqueTangents, Vec( 0 ) ); VecContainer normals( numUniqueTangents, Vec( 0 ) ); for( size_t faceIndex = 0; faceIndex < m_vertsPerFace.size() ; faceIndex++ ) { assert( m_vertsPerFace[faceIndex] == 3 ); // indices into the facevarying data for this face size_t fvi0 = faceIndex * 3; size_t fvi1 = fvi0 + 1; size_t fvi2 = fvi1 + 1; assert( fvi2 < m_vertIds.size() ); assert( fvi2 < m_u.size() ); assert( fvi2 < m_v.size() ); // positions for each vertex of this face const Vec &p0 = points[ m_vertIds[ fvi0 ] ]; const Vec &p1 = points[ m_vertIds[ fvi1 ] ]; const Vec &p2 = points[ m_vertIds[ fvi2 ] ]; // uv coordinates for each vertex of this face const Imath::V2f uv0( m_u[ fvi0 ], m_v[ fvi0 ] ); const Imath::V2f uv1( m_u[ fvi1 ], m_v[ fvi1 ] ); const Imath::V2f uv2( m_u[ fvi2 ], m_v[ fvi2 ] ); // compute tangents and normal for this face const Vec e0 = p1 - p0; const Vec e1 = p2 - p0; const Imath::V2f e0uv = uv1 - uv0; const Imath::V2f e1uv = uv2 - uv0; Vec tangent = ( e0 * -e1uv.y + e1 * e0uv.y ).normalized(); Vec bitangent = ( e0 * -e1uv.x + e1 * e0uv.x ).normalized(); Vec normal = (p2-p1).cross(p0-p1); normal.normalize(); // and accumlate them into the computation so far uTangents[ m_uvIds[fvi0] ] += tangent; uTangents[ m_uvIds[fvi1] ] += tangent; uTangents[ m_uvIds[fvi2] ] += tangent; vTangents[ m_uvIds[fvi0] ] += bitangent; vTangents[ m_uvIds[fvi1] ] += bitangent; vTangents[ m_uvIds[fvi2] ] += bitangent; normals[ m_uvIds[fvi0] ] += normal; normals[ m_uvIds[fvi1] ] += normal; normals[ m_uvIds[fvi2] ] += normal; } // normalize and orthogonalize everything for( size_t i = 0; i < uTangents.size(); i++ ) { normals[i].normalize(); uTangents[i].normalize(); vTangents[i].normalize(); // Make uTangent/vTangent orthogonal to normal uTangents[i] -= normals[i] * uTangents[i].dot( normals[i] ); vTangents[i] -= normals[i] * vTangents[i].dot( normals[i] ); uTangents[i].normalize(); vTangents[i].normalize(); if ( m_orthoTangents ) { vTangents[i] -= uTangents[i] * vTangents[i].dot( uTangents[i] ); vTangents[i].normalize(); } // make things less sinister if( uTangents[i].cross( vTangents[i] ).dot( normals[i] ) < 0.0f ) { uTangents[i] *= -1.0f; } } // convert the tangents back to facevarying data and add that to the mesh typename T::Ptr fvUD = new T(); typename T::Ptr fvVD = new T(); fvUTangentsData = fvUD; fvVTangentsData = fvVD; VecContainer &fvUTangents = fvUD->writable(); VecContainer &fvVTangents = fvVD->writable(); fvUTangents.resize( m_uvIds.size() ); fvVTangents.resize( m_uvIds.size() ); for( unsigned i=0; i<m_uvIds.size(); i++ ) { fvUTangents[i] = uTangents[m_uvIds[i]]; fvVTangents[i] = vTangents[m_uvIds[i]]; } }