void ObjMesh::Init() { ReadFromFile(filePath.c_str(), scale_factor); ComputeNormal(); ApplyTransformation(); ComputeAABB(); }
void ProgressBar::Draw(Renderer & renderer) { ApplyTransformation(renderer); renderer.SetColor(m_frameColor); renderer.DrawShape(m_frameShape); renderer.SetColor(m_innerColor); renderer.DrawShape(m_innerShape); }
double ComputeRMSD(int nCoords, const Vector * const *masterCoords, const Vector * const *dependentCoords, const Matrix *transformDependentToMaster) { Vector x; double rmsd = 0.0; int n = 0; for (int c=0; c<nCoords; ++c) { if (!dependentCoords[c] || !masterCoords[c]) continue; x = *(dependentCoords[c]); if (transformDependentToMaster) ApplyTransformation(&x, *transformDependentToMaster); rmsd += (*(masterCoords[c]) - x).lengthSquared(); ++n; } if (n == 0) { WARNINGMSG("ComputeRMSD() - received no non-NULL coordinates"); return 0.0; } rmsd = sqrt(rmsd / n); return rmsd; }
AtNode * ProcessPointsBase( IPoints & prim, ProcArgs & args, SampleTimeSet & sampleTimes, std::vector<AtPoint> & vidxs, std::vector<float> & radius, MatrixSampleMap * xformSamples ) { if ( !prim.valid() ) { return NULL; } Alembic::AbcGeom::IPointsSchema &ps = prim.getSchema(); TimeSamplingPtr ts = ps.getTimeSampling(); sampleTimes.insert( ts->getFloorIndex(args.frame / args.fps, ps.getNumSamples()).second ); std::string name = args.nameprefix + prim.getFullName(); AtNode * instanceNode = NULL; std::string cacheId; SampleTimeSet singleSampleTimes; singleSampleTimes.insert( ts->getFloorIndex(args.frame / args.fps, ps.getNumSamples()).second ); ICompoundProperty arbGeomParams = ps.getArbGeomParams(); ISampleSelector frameSelector( *singleSampleTimes.begin() ); std::vector<std::string> tags; //get tags if ( arbGeomParams != NULL && arbGeomParams.valid() ) { if (arbGeomParams.getPropertyHeader("mtoa_constant_tags") != NULL) { const PropertyHeader * tagsHeader = arbGeomParams.getPropertyHeader("mtoa_constant_tags"); if (IStringGeomParam::matches( *tagsHeader )) { IStringGeomParam param( arbGeomParams, "mtoa_constant_tags" ); if ( param.valid() ) { IStringGeomParam::prop_type::sample_ptr_type valueSample = param.getExpandedValue( frameSelector ).getVals(); if ( param.getScope() == kConstantScope || param.getScope() == kUnknownScope) { Json::Value jtags; Json::Reader reader; if(reader.parse(valueSample->get()[0], jtags)) for( Json::ValueIterator itr = jtags.begin() ; itr != jtags.end() ; itr++ ) { tags.push_back(jtags[itr.key().asUInt()].asString()); } } } } } } if ( args.makeInstance ) { std::ostringstream buffer; AbcA::ArraySampleKey sampleKey; for ( SampleTimeSet::iterator I = sampleTimes.begin(); I != sampleTimes.end(); ++I ) { ISampleSelector sampleSelector( *I ); ps.getPositionsProperty().getKey(sampleKey, sampleSelector); buffer << GetRelativeSampleTime( args, (*I) ) << ":"; sampleKey.digest.print(buffer); buffer << ":"; } cacheId = buffer.str(); instanceNode = AiNode( "ginstance" ); AiNodeSetStr( instanceNode, "name", name.c_str() ); args.createdNodes.push_back(instanceNode); if ( args.proceduralNode ) { AiNodeSetByte( instanceNode, "visibility", AiNodeGetByte( args.proceduralNode, "visibility" ) ); } else { AiNodeSetByte( instanceNode, "visibility", AI_RAY_ALL ); } ApplyTransformation( instanceNode, xformSamples, args ); NodeCache::iterator I = g_meshCache.find(cacheId); // parameters overrides if(args.linkOverride) ApplyOverrides(name, instanceNode, tags, args); // shader assignation if (nodeHasParameter( instanceNode, "shader" ) ) { if(args.linkShader) { ApplyShaders(name, instanceNode, tags, args); } else { AtArray* shaders = AiNodeGetArray(args.proceduralNode, "shader"); if (shaders->nelements != 0) AiNodeSetArray(instanceNode, "shader", AiArrayCopy(shaders)); } } if ( I != g_meshCache.end() ) { AiNodeSetPtr(instanceNode, "node", (*I).second ); return NULL; } } bool isFirstSample = true; float radiusPoint = 0.1f; if (AiNodeLookUpUserParameter(args.proceduralNode, "radiusPoint") !=NULL ) radiusPoint = AiNodeGetFlt(args.proceduralNode, "radiusPoint"); bool useVelocities = false; if ((sampleTimes.size() == 1) && (args.shutterOpen != args.shutterClose)) { // no sample, and motion blur needed, let's try to get velocities. if(ps.getVelocitiesProperty().valid()) useVelocities = true; } for ( SampleTimeSet::iterator I = sampleTimes.begin(); I != sampleTimes.end(); ++I, isFirstSample = false) { ISampleSelector sampleSelector( *I ); Alembic::AbcGeom::IPointsSchema::Sample sample = ps.getValue( sampleSelector ); Alembic::Abc::P3fArraySamplePtr v3ptr = sample.getPositions(); size_t pSize = sample.getPositions()->size(); if(useVelocities && isFirstSample) { float scaleVelocity = 1.0f; if (AiNodeLookUpUserParameter(args.proceduralNode, "scaleVelocity") !=NULL ) scaleVelocity = AiNodeGetFlt(args.proceduralNode, "scaleVelocity"); vidxs.resize(pSize*2); Alembic::Abc::V3fArraySamplePtr velptr = sample.getVelocities(); float timeoffset = ((args.frame / args.fps) - ts->getFloorIndex((*I), ps.getNumSamples()).second) * args.fps; for ( size_t pId = 0; pId < pSize; ++pId ) { Alembic::Abc::V3f posAtOpen = ((*v3ptr)[pId] + (*velptr)[pId] * scaleVelocity *-timeoffset); AtPoint pos1; pos1.x = posAtOpen.x; pos1.y = posAtOpen.y; pos1.z = posAtOpen.z; vidxs[pId]= pos1; Alembic::Abc::V3f posAtEnd = ((*v3ptr)[pId] + (*velptr)[pId]* scaleVelocity *(1.0f-timeoffset)); AtPoint pos2; pos2.x = posAtEnd.x; pos2.y = posAtEnd.y; pos2.z = posAtEnd.z; vidxs[pId+pSize]= pos2; radius.push_back(radiusPoint); } } else // not motion blur or correctly sampled particles { for ( size_t pId = 0; pId < pSize; ++pId ) { AtPoint pos; pos.x = (*v3ptr)[pId].x; pos.y = (*v3ptr)[pId].y; pos.z = (*v3ptr)[pId].z; vidxs.push_back(pos); radius.push_back(radiusPoint); } } } AtNode* pointsNode = AiNode( "points" ); if (!pointsNode) { AiMsgError("Failed to make points node for %s", prim.getFullName().c_str()); return NULL; } args.createdNodes.push_back(pointsNode); if ( instanceNode != NULL) { AiNodeSetStr( pointsNode, "name", (name + ":src").c_str() ); } else { AiNodeSetStr( pointsNode, "name", name.c_str() ); } if(!useVelocities) { AiNodeSetArray(pointsNode, "points", AiArrayConvert( vidxs.size() / sampleTimes.size(), sampleTimes.size(), AI_TYPE_POINT, (void*)(&(vidxs[0])) )); AiNodeSetArray(pointsNode, "radius", AiArrayConvert( vidxs.size() / sampleTimes.size(), sampleTimes.size(), AI_TYPE_FLOAT, (void*)(&(radius[0])) )); if ( sampleTimes.size() > 1 ) { std::vector<float> relativeSampleTimes; relativeSampleTimes.reserve( sampleTimes.size() ); for (SampleTimeSet::const_iterator I = sampleTimes.begin(); I != sampleTimes.end(); ++I ) { chrono_t sampleTime = GetRelativeSampleTime( args, (*I) ); relativeSampleTimes.push_back(sampleTime); } AiNodeSetArray( pointsNode, "deform_time_samples", AiArrayConvert(relativeSampleTimes.size(), 1, AI_TYPE_FLOAT, &relativeSampleTimes[0])); } } else { AiNodeSetArray(pointsNode, "points", AiArrayConvert( vidxs.size() / 2, 2, AI_TYPE_POINT, (void*)(&(vidxs[0])) )); AiNodeSetArray(pointsNode, "radius", AiArrayConvert( vidxs.size() /2 / sampleTimes.size(), sampleTimes.size(), AI_TYPE_FLOAT, (void*)(&(radius[0])) )); AiNodeSetArray( pointsNode, "deform_time_samples", AiArray(2, 1, AI_TYPE_FLOAT, 0.f, 1.f)); } AddArbitraryGeomParams( arbGeomParams, frameSelector, pointsNode ); if ( instanceNode == NULL ) { if ( xformSamples ) { ApplyTransformation( pointsNode, xformSamples, args ); } return pointsNode; } else { AiNodeSetByte( pointsNode, "visibility", 0 ); AiNodeSetInt( pointsNode, "mode", 1 ); AiNodeSetPtr(instanceNode, "node", pointsNode ); g_meshCache[cacheId] = pointsNode; return pointsNode; } }
AtNode * ProcessPolyMeshBase( primT & prim, ProcArgs & args, SampleTimeSet & sampleTimes, std::vector<AtUInt32> & vidxs, int subdiv_iterations, MatrixSampleMap * xformSamples, const std::string & facesetName = "" ) { if ( !prim.valid() ) { return NULL; } typename primT::schema_type &ps = prim.getSchema(); TimeSamplingPtr ts = ps.getTimeSampling(); if ( ps.getTopologyVariance() != kHeterogenousTopology ) { GetRelevantSampleTimes( args, ts, ps.getNumSamples(), sampleTimes ); } else { sampleTimes.insert( args.frame / args.fps ); } std::string name = args.nameprefix + prim.getFullName(); AtNode * instanceNode = NULL; std::string cacheId; if ( args.makeInstance ) { std::ostringstream buffer; AbcA::ArraySampleKey sampleKey; for ( SampleTimeSet::iterator I = sampleTimes.begin(); I != sampleTimes.end(); ++I ) { ISampleSelector sampleSelector( *I ); ps.getPositionsProperty().getKey(sampleKey, sampleSelector); buffer << GetRelativeSampleTime( args, (*I) ) << ":"; sampleKey.digest.print(buffer); buffer << ":"; } buffer << "@" << subdiv_iterations; buffer << "@" << facesetName; cacheId = buffer.str(); instanceNode = AiNode( "ginstance" ); AiNodeSetStr( instanceNode, "name", name.c_str() ); args.createdNodes.push_back(instanceNode); if ( args.proceduralNode ) { AiNodeSetInt( instanceNode, "visibility", AiNodeGetInt( args.proceduralNode, "visibility" ) ); } else { AiNodeSetInt( instanceNode, "visibility", AI_RAY_ALL ); } ApplyTransformation( instanceNode, xformSamples, args ); NodeCache::iterator I = g_meshCache.find(cacheId); if ( I != g_meshCache.end() ) { AiNodeSetPtr(instanceNode, "node", (*I).second ); return NULL; } } SampleTimeSet singleSampleTimes; singleSampleTimes.insert( args.frame / args.fps ); std::vector<AtByte> nsides; std::vector<float> vlist; std::vector<float> uvlist; std::vector<AtUInt32> uvidxs; // POTENTIAL OPTIMIZATIONS LEFT TO THE READER // 1) vlist needn't be copied if it's a single sample bool isFirstSample = true; for ( SampleTimeSet::iterator I = sampleTimes.begin(); I != sampleTimes.end(); ++I, isFirstSample = false) { ISampleSelector sampleSelector( *I ); typename primT::schema_type::Sample sample = ps.getValue( sampleSelector ); if ( isFirstSample ) { size_t numPolys = sample.getFaceCounts()->size(); nsides.reserve( sample.getFaceCounts()->size() ); for ( size_t i = 0; i < numPolys; ++i ) { int32_t n = sample.getFaceCounts()->get()[i]; if ( n > 255 ) { // TODO, warning about unsupported face return NULL; } nsides.push_back( (AtByte) n ); } size_t vidxSize = sample.getFaceIndices()->size(); vidxs.reserve( vidxSize ); vidxs.insert( vidxs.end(), sample.getFaceIndices()->get(), sample.getFaceIndices()->get() + vidxSize ); } vlist.reserve( vlist.size() + sample.getPositions()->size() * 3); vlist.insert( vlist.end(), (const float32_t*) sample.getPositions()->get(), ((const float32_t*) sample.getPositions()->get()) + sample.getPositions()->size() * 3 ); } ProcessIndexedBuiltinParam( ps.getUVsParam(), singleSampleTimes, uvlist, uvidxs, 2); AtNode* meshNode = AiNode( "polymesh" ); if (!meshNode) { AiMsgError("Failed to make polymesh node for %s", prim.getFullName().c_str()); return NULL; } args.createdNodes.push_back(meshNode); if ( instanceNode != NULL) { AiNodeSetStr( meshNode, "name", (name + ":src").c_str() ); } else { AiNodeSetStr( meshNode, "name", name.c_str() ); } AiNodeSetArray(meshNode, "vidxs", ArrayConvert(vidxs.size(), 1, AI_TYPE_UINT, (void*)&vidxs[0])); AiNodeSetArray(meshNode, "nsides", ArrayConvert(nsides.size(), 1, AI_TYPE_BYTE, &(nsides[0]))); AiNodeSetArray(meshNode, "vlist", ArrayConvert( vlist.size() / sampleTimes.size(), sampleTimes.size(), AI_TYPE_FLOAT, (void*)(&(vlist[0])))); if ( !uvlist.empty() ) { //TODO, option to disable v flipping for (size_t i = 1, e = uvlist.size(); i < e; i += 2) { uvlist[i] = 1.0 - uvlist[i]; } AiNodeSetArray(meshNode, "uvlist", ArrayConvert( uvlist.size(), 1, AI_TYPE_FLOAT, (void*)(&(uvlist[0])))); if ( !uvidxs.empty() ) { AiNodeSetArray(meshNode, "uvidxs", ArrayConvert(uvidxs.size(), 1, AI_TYPE_UINT, &(uvidxs[0]))); } else { AiNodeSetArray(meshNode, "uvidxs", ArrayConvert(vidxs.size(), 1, AI_TYPE_UINT, &(vidxs[0]))); } } if ( sampleTimes.size() > 1 ) { std::vector<float> relativeSampleTimes; relativeSampleTimes.reserve( sampleTimes.size() ); for (SampleTimeSet::const_iterator I = sampleTimes.begin(); I != sampleTimes.end(); ++I ) { relativeSampleTimes.push_back( GetRelativeSampleTime( args, (*I) ) ); } AiNodeSetArray( meshNode, "deform_time_samples", ArrayConvert(relativeSampleTimes.size(), 1, AI_TYPE_FLOAT, &relativeSampleTimes[0])); } // faceset visibility array if ( !facesetName.empty() ) { if ( ps.hasFaceSet( facesetName ) ) { ISampleSelector frameSelector( *singleSampleTimes.begin() ); IFaceSet faceSet = ps.getFaceSet( facesetName ); IFaceSetSchema::Sample faceSetSample = faceSet.getSchema().getValue( frameSelector ); std::set<int> facesToKeep; facesToKeep.insert( faceSetSample.getFaces()->get(), faceSetSample.getFaces()->get() + faceSetSample.getFaces()->size() ); bool *faceVisArray = new bool(nsides.size()); for ( int i = 0; i < (int) nsides.size(); ++i ) { faceVisArray[i] = facesToKeep.find( i ) != facesToKeep.end(); } if ( AiNodeDeclare( meshNode, "face_visibility", "uniform BOOL" ) ) { AiNodeSetArray( meshNode, "face_visibility", ArrayConvert( nsides.size(), 1, AI_TYPE_BOOLEAN, faceVisArray ) ); } delete[] faceVisArray; } } { ICompoundProperty arbGeomParams = ps.getArbGeomParams(); ISampleSelector frameSelector( *singleSampleTimes.begin() ); AddArbitraryGeomParams( arbGeomParams, frameSelector, meshNode ); } if ( instanceNode == NULL ) { if ( xformSamples ) { ApplyTransformation( meshNode, xformSamples, args ); } return meshNode; } else { AiNodeSetInt( meshNode, "visibility", 0 ); AiNodeSetPtr(instanceNode, "node", meshNode ); g_meshCache[cacheId] = meshNode; return meshNode; } }
void AbstractNode::RenderReflection(glm::mat4 model, const glm::mat4& view, const glm::mat4& projection, Environment* environnement, const glm::vec4& clipPlane, glm::mat4 shadowModel) { ApplyTransformation(model); ApplyTransformation(shadowModel); model_->RenderReflection(model, view, projection, environnement, clipPlane,shadowModel); }
void AbstractNode::RenderShadowMap(glm::mat4 model, const glm::mat4& view, const glm::mat4& projection) { ApplyTransformation(model); model_->RenderShadowMap(model, view, projection); }
void AbstractNode::RenderFirstPass(glm::mat4 model, const glm::mat4& view, const glm::mat4& projection, glm::vec4& clipPlane) { ApplyTransformation(model); model_->RenderFirstPass(model, view, projection, clipPlane); }