/* ****************************************************************************** * Function Name : instanceCube() * * Description : * * Input Arguments : GU_Detail *inst_gdp, GU_Detail *mb_gdp * * Return Value : int * ***************************************************************************** */ int VRAY_clusterThis::instanceCube(GU_Detail * inst_gdp, GU_Detail * mb_gdp) { #ifdef DEBUG std::cout << "VRAY_clusterThis::instanceCube()" << std::endl; #endif GEO_Primitive * myCube; GEO_Point * ppt; UT_Matrix4 xform(1.0); // UT_XformOrder xformOrder(UT_XformOrder::TRS, UT_XformOrder::XYZ); UT_Matrix3 rot_xform(1.0); // UT_Vector3 myDir = myPointAttributes.N; UT_Vector3 myUp = UT_Vector3(0,1,0); rot_xform.orient(myPointAttributes.N, myUp); xform = rot_xform; myCube = (GEO_Primitive *) inst_gdp->cube( myPointAttributes.myNewPos[0] - ((mySize[0] * myPointAttributes.pscale) / 2), myPointAttributes.myNewPos[0] + ((mySize[0] * myPointAttributes.pscale) / 2), myPointAttributes.myNewPos[1] - ((mySize[1] * myPointAttributes.pscale) / 2), myPointAttributes.myNewPos[1] + ((mySize[1] * myPointAttributes.pscale) / 2), myPointAttributes.myNewPos[2] - ((mySize[2] * myPointAttributes.pscale) / 2), myPointAttributes.myNewPos[2] + ((mySize[2] * myPointAttributes.pscale) / 2)); for(int i=0; i < myCube->getVertexCount(); i++) { ppt = myCube->getVertexElement(i).getPt(); UT_Vector4 P = ppt->getPos(); P *= xform; ppt->setPos(P); } VRAY_clusterThis::setInstanceAttributes(myCube); if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) { myCube = (GEO_Primitive *) mb_gdp->cube(myPointAttributes.myMBPos[0] - ((mySize[0] * myPointAttributes.pscale) / 2), myPointAttributes.myMBPos[0] + ((mySize[0] * myPointAttributes.pscale) / 2), myPointAttributes.myMBPos[1] - ((mySize[1] * myPointAttributes.pscale) / 2), myPointAttributes.myMBPos[1] + ((mySize[1] * myPointAttributes.pscale) / 2), myPointAttributes.myMBPos[2] - ((mySize[2] * myPointAttributes.pscale) / 2), myPointAttributes.myMBPos[2] + ((mySize[2] * myPointAttributes.pscale) / 2)); for(int i=0; i < myCube->getVertexCount(); i++) { ppt = myCube->getVertexElement(i).getPt(); UT_Vector4 P = ppt->getPos(); P *= xform; ppt->setPos(P); } VRAY_clusterThis::setInstanceAttributes(myCube); } if(myCVEX_Exec) VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname, CLUSTER_CVEX_POINT); if(myCVEX_Exec_prim) VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM); return 0; }
/* ****************************************************************************** * Function Name : instanceFile() * * Description : Instance the geometry from a BGEO file * * Input Arguments : GU_Detail *file_gdp, GU_Detail *inst_gdp, GU_Detail *mb_gdp * * Return Value : int * ***************************************************************************** */ int VRAY_clusterThis::instanceFile(GU_Detail * file_gdp, GU_Detail * inst_gdp, GU_Detail * mb_gdp) { #ifdef DEBUG std::cout << "VRAY_clusterThis::instanceFile()" << std::endl; cout << "VRAY_clusterThis::instanceFile() myPointAttributes.geo_fname: " << myPointAttributes.geo_fname << endl; #endif #define USE_POINT_FNAME 1 GU_Detail null_gdp; UT_Matrix4 xform(1.0); UT_Matrix3 rot_xform(1.0); // UT_XformOrder xformOrder(UT_XformOrder::SRT, UT_XformOrder::XYZ); #ifdef USE_POINT_FNAME GU_Detail * file_geo_gdp; file_geo_gdp = VRAY_Procedural::allocateGeometry(); if(!file_geo_gdp->load((const char *)myPointAttributes.geo_fname).success()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::instanceFile() Failed to load geometry file ", 1); GU_Detail temp_gdp(file_geo_gdp); #else GU_Detail temp_gdp(file_gdp); #endif UT_Vector3 myDir = myPointAttributes.N; UT_Vector3 myUp = UT_Vector3(0, 1, 0); // Transform the geo to the new position rot_xform.orient(myDir, myUp); xform = rot_xform; xform.scale(mySize[0] * myPointAttributes.pscale, mySize[1] * myPointAttributes.pscale, mySize[2] * myPointAttributes.pscale); // xform.rotate(myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], xformOrder); xform.translate(myPointAttributes.myNewPos[0], myPointAttributes.myNewPos[1], myPointAttributes.myNewPos[2]); // xform.xform(xformOrder, myPointAttributes.myNewPos[0], myPointAttributes.myNewPos[1], myPointAttributes.myNewPos[2], // myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], // mySize[0], mySize[1], mySize[2]); temp_gdp.transform(xform); // GU_Detail theFileGDP(theFiles[myPointAttributes.lod][myPointAttributes.anim_frame]); addFileAttributeRefs(&temp_gdp); setFileAttributes(&temp_gdp); // Run CVEX function on this instance if(myCVEX_Exec) VRAY_clusterThis::runCVEX(&temp_gdp, &null_gdp, myCVEXFname, CLUSTER_CVEX_POINT); if(myCVEX_Exec_prim) VRAY_clusterThis::runCVEX(&temp_gdp, &null_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM); inst_gdp->merge(temp_gdp); if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) { #ifdef USE_POINT_FNAME GU_Detail temp_gdp(file_geo_gdp); #else GU_Detail temp_gdp(file_gdp); #endif xform.identity(); rot_xform.identity(); rot_xform.orient(myDir, myUp); xform = rot_xform; xform.scale(mySize[0] * myPointAttributes.pscale, mySize[1] * myPointAttributes.pscale, mySize[2] * myPointAttributes.pscale); // xform.rotate(myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], xformOrder); xform.translate(myPointAttributes.myMBPos[0], myPointAttributes.myMBPos[1], myPointAttributes.myMBPos[2]); // xform.xform(xformOrder, myPointAttributes.myMBPos[0], myPointAttributes.myMBPos[1], myPointAttributes.myMBPos[2], // myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], // mySize[0], mySize[1], mySize[2]); // Run CVEX function on this instance if(myCVEX_Exec) VRAY_clusterThis::runCVEX(&temp_gdp, &null_gdp, myCVEXFname, CLUSTER_CVEX_POINT); if(myCVEX_Exec_prim) VRAY_clusterThis::runCVEX(&temp_gdp, &null_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM); temp_gdp.transform(xform); mb_gdp->merge(temp_gdp); } #ifdef USE_POINT_FNAME VRAY_Procedural::freeGeometry(file_geo_gdp); #endif return 0; }
/* ****************************************************************************** * Function Name : ReadRFSDCreateAnimGeo() * * * Input Arguments : OP_Context &context * * Return Value : int * ***************************************************************************** */ inline int SOP_RF_Import::ReadRFSDCreateAnimGeo(UT_Interrupt * boss) { UT_XformOrder xformOrder(UT_XformOrder::SRT); UT_Matrix4 work_matrix; GEO_Point * ppt; try { // For each object in the SD file, read it's frame header and geometry for(int cur_object = 0; cur_object < myRFSDFile->myRF_SD_Header.num_objects; cur_object++) { // read the object's frame header data if(myRFSDFile->readSDObjFrameHdr()) throw SOP_RF_Import_Exception(canNotReadSDObjectFrameHeader, exceptionError); #ifdef DEBUG std::cout << "obj_name_len: " << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_name_len << std::endl; std::cout << "Object Name: " << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_name << std::endl; std::cout << "Object Transform:" << std::endl; for(int i = 0; i < 12; i++) std::cout << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_world_xform[i] << "\t"; std::cout << std::endl; std::cout << "Translation Vector: " << std::endl; for(int i = 0; i < 3; i++) std::cout << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_trans_vec[i] << "\t"; std::cout << std::endl; std::cout << "Rotation Vector: " << std::endl; for(int i = 0; i < 3; i++) std::cout << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_rot_vec[i] << "\t"; std::cout << std::endl; std::cout << "Scale Vector: " << std::endl; for(int i = 0; i < 3; i++) std::cout << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_scale_vec[i] << "\t"; std::cout << std::endl; std::cout << "Pivot Position: " << std::endl; for(int i = 0; i < 3; i++) std::cout << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_pivot_pos[i] << "\t"; std::cout << std::endl << std::endl; std::cout << "CG Position: " << std::endl; for(int i = 0; i < 3; i++) std::cout << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_pos[i] << "\t"; std::cout << std::endl; std::cout << "CG Velocity: " << std::endl; for(int i = 0; i < 3; i++) std::cout << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_vel[i] << "\t"; std::cout << std::endl; std::cout << "CG Rotation: " << std::endl; for(int i = 0; i < 3; i++) std::cout << myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_rot[i] << "\t"; std::cout << std::endl << std::endl; #endif if(myGUIState.t_sd_cg) { work_matrix.identity(); work_matrix.xform(xformOrder, myRFSDFile->myRF_SD_Obj_Frame_Header.obj_trans_vec[0], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_trans_vec[1], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_trans_vec[2], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_rot_vec[0], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_rot_vec[1], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_rot_vec[2], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_scale_vec[0], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_scale_vec[1], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_scale_vec[2], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_pivot_pos[0], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_pivot_pos[1], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_pivot_pos[2]); // Transform the geometry gdp->transformPoints(work_matrix, (const GA_PointGroup *)objPrimitiveGrpList[cur_object]); } if(myGUIState.t_sd_cg_xform) { work_matrix.identity(); work_matrix.xform(xformOrder, myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_pos[0], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_pos[1], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_pos[2], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_rot[0], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_rot[1], myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_rot[2]); // Transform the geometry gdp->transformPoints(work_matrix, (const GA_PointGroup *)objPrimitiveGrpList[cur_object]); } #ifdef DEBUG std::cout << "Current primitive group: " << objPrimitiveGrpList[cur_object]->getName() << std::endl; #endif GA_RWAttributeRef attrRef; GA_RWHandleI attrIntHandle; GA_RWHandleF attrFloatHandle; GA_RWHandleV3 attrVector3Handle; // If the user wants the CG data, add it to the geo detail if(myGUIState.t_sd_cg) { if(myAttributeRefs.sd_CG_pos.isValid()) { attrVector3Handle.bind(myAttributeRefs.sd_CG_pos.getAttribute()); attrVector3Handle.set(0, UT_Vector3(myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_pos)); } if(myAttributeRefs.sd_CG_vel.isValid()) { attrVector3Handle.bind(myAttributeRefs.sd_CG_vel.getAttribute()); attrVector3Handle.set(0, UT_Vector3(myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_vel)); } if(myAttributeRefs.sd_CG_rot.isValid()) { attrVector3Handle.bind(myAttributeRefs.sd_CG_rot.getAttribute()); attrVector3Handle.set(0, UT_Vector3(myRFSDFile->myRF_SD_Obj_Frame_Header.obj_CG_rot)); } } // If vertex mode, update coordinates if(myRFSDFile->myRF_SD_Obj_Header.obj_mode) { for(int cur_point = 0; cur_point < myRFSDFile->obj_detail[cur_object].num_points; cur_point++) { #ifdef DEBUG std::cout << "vertex number: " << cur_point + 1 << " of " << myRFSDFile->myRF_SD_Obj_Header.num_vertices << " vertices " << std::endl; #endif if(myRFSDFile->readSDFaceCoord()) throw SOP_RF_Import_Exception(canNotReadSDAnimFaceData, exceptionError); #ifdef DEBUG std::cout << "Vertex Coordinates: " << std::endl; std::cout << myRFSDFile->myRF_SD_Face_Data.vertex[0] << "\t"; std::cout << myRFSDFile->myRF_SD_Face_Data.vertex[1] << "\t"; std::cout << myRFSDFile->myRF_SD_Face_Data.vertex[2] << std::endl; #endif // update points if(boss->opInterrupt()) throw SOP_RF_Import_Exception(theSDAnimGeoCreationInterrupt, exceptionWarning); myCurrPoint = cur_point; // Get the current point to either update position ppt = gdp->points().entry(cur_point); if(ppt == NULL) throw SOP_RF_Import_Exception(theSDAnimGeoCreationPointNULL, exceptionError); #ifdef DEBUG std::cout << "cur_object: " << cur_object << std::endl; #endif gdp->points()[cur_point]->setPos((float)myRFSDFile->myRF_SD_Face_Data.vertex[0], (float)myRFSDFile->myRF_SD_Face_Data.vertex[1], (float)myRFSDFile->myRF_SD_Face_Data.vertex[2], 1.0); #ifdef DEBUG std::cout << "position assigned" << std::endl; #endif } // for(int cur_point=0; ... } // if(myRFSDFile->myRF_SD_Obj_Header.obj_mode) } // if vertex mode } catch(SOP_RF_Import_Exception e) { e.what(); if(e.getSeverity() == exceptionWarning) addWarning(SOP_MESSAGE, errorMsgs[e.getErrorCode()]); else if(e.getSeverity() == exceptionError) addError(SOP_MESSAGE, errorMsgs[e.getErrorCode()]); if(myRFSDFile->SDifstream.is_open()) { myRFSDFile->closeSDFile(RF_FILE_READ); } return 1; } return 0; }
/* ****************************************************************************** * Function Name : instanceFile() * * Description : Instance the geometry from a BGEO file * * Input Arguments : GU_Detail *file_gdp, GU_Detail *inst_gdp, GU_Detail *mb_gdp * * Return Value : int * ***************************************************************************** */ int VRAY_clusterThis::instanceFile(GU_Detail * file_gdp, GU_Detail * inst_gdp, GU_Detail * mb_gdp) { #ifdef DEBUG std::cout << "VRAY_clusterThis::instanceFile()" << std::endl; #endif GU_Detail temp_gdp(file_gdp), null_gdp; UT_Matrix4 xform(1.0); UT_Matrix3 rot_xform(1.0); // UT_XformOrder xformOrder(UT_XformOrder::SRT, UT_XformOrder::XYZ); UT_Vector3 myDir = myPointAttributes.N; // myDir.normalize(); UT_Vector3 myUp = UT_Vector3(0,1,0); // Transform the geo to the new position rot_xform.orient(myDir, myUp); xform = rot_xform; xform.scale(mySize[0] * myPointAttributes.pscale, mySize[1] * myPointAttributes.pscale, mySize[2] * myPointAttributes.pscale); // xform.rotate(myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], xformOrder); xform.translate(myPointAttributes.myNewPos[0], myPointAttributes.myNewPos[1], myPointAttributes.myNewPos[2]); // xform.xform(xformOrder, myPointAttributes.myNewPos[0], myPointAttributes.myNewPos[1], myPointAttributes.myNewPos[2], // myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], // mySize[0], mySize[1], mySize[2]); temp_gdp.transform(xform); // GU_Detail theFileGDP(theFiles[myPointAttributes.lod][myPointAttributes.anim_frame]); addFileAttributeOffsets(&temp_gdp); setFileAttributes(&temp_gdp); // Run CVEX function on this instance if(myCVEX_Exec) VRAY_clusterThis::runCVEX(&temp_gdp, &null_gdp, myCVEXFname, CLUSTER_CVEX_POINT); if(myCVEX_Exec_prim) VRAY_clusterThis::runCVEX(&temp_gdp, &null_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM); inst_gdp->merge(temp_gdp); if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) { GU_Detail temp_gdp(file_gdp); xform.identity(); rot_xform.identity(); rot_xform.orient(myDir, myUp); xform = rot_xform; xform.scale(mySize[0] * myPointAttributes.pscale, mySize[1] * myPointAttributes.pscale, mySize[2] * myPointAttributes.pscale); // xform.rotate(myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], xformOrder); xform.translate(myPointAttributes.myMBPos[0], myPointAttributes.myMBPos[1], myPointAttributes.myMBPos[2]); // xform.xform(xformOrder, myPointAttributes.myMBPos[0], myPointAttributes.myMBPos[1], myPointAttributes.myMBPos[2], // myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], // mySize[0], mySize[1], mySize[2]); // Run CVEX function on this instance if(myCVEX_Exec) VRAY_clusterThis::runCVEX(&temp_gdp, &null_gdp, myCVEXFname, CLUSTER_CVEX_POINT); if(myCVEX_Exec_prim) VRAY_clusterThis::runCVEX(&temp_gdp, &null_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM); temp_gdp.transform(xform); mb_gdp->merge(temp_gdp); } return 0; }
/* ****************************************************************************** * Function Name : instanceGrid() * * Description : * * Input Arguments : GU_Detail *inst_gdp, GU_Detail *mb_gdp * * Return Value : int * ***************************************************************************** */ int VRAY_clusterThis::instanceGrid(GU_Detail * inst_gdp, GU_Detail * mb_gdp) { #ifdef DEBUG std::cout << "VRAY_clusterThis::instanceGrid()" << std::endl; #endif GEO_Primitive * myGrid; GU_GridParms grid_parms; GEO_Point * ppt; UT_Matrix4 xform(1.0); // UT_XformOrder xformOrder(UT_XformOrder::TRS, UT_XformOrder::XYZ); UT_Matrix3 rot_xform(1.0); // UT_Vector3 myDir = myPointAttributes.N; UT_Vector3 myUp = UT_Vector3(0,1,0); rot_xform.orient(myPointAttributes.N, myUp); xform = rot_xform; grid_parms.rows = 2; grid_parms.cols = 2; grid_parms.xsize = mySize[0] * myPointAttributes.pscale; grid_parms.ysize = mySize[1] * myPointAttributes.pscale; grid_parms.xcenter = myPointAttributes.myNewPos[0]; grid_parms.ycenter = myPointAttributes.myNewPos[1]; grid_parms.zcenter = myPointAttributes.myNewPos[2]; grid_parms.plane = GU_PLANE_XY; myGrid = inst_gdp->buildGrid(grid_parms, GU_GRID_POLY); for(int i=0; i < myGrid->getVertexCount(); i++) { ppt = myGrid->getVertexElement(i).getPt(); UT_Vector4 P = ppt->getPos(); P *= xform; ppt->setPos(P); } VRAY_clusterThis::setInstanceAttributes(myGrid); if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) { grid_parms.xcenter = myPointAttributes.myMBPos[0]; grid_parms.ycenter = myPointAttributes.myMBPos[1]; grid_parms.zcenter = myPointAttributes.myMBPos[2]; myGrid = mb_gdp->buildGrid(grid_parms, GU_GRID_POLY); for(int i=0; i < myGrid->getVertexCount(); i++) { ppt = myGrid->getVertexElement(i).getPt(); UT_Vector4 P = ppt->getPos(); P *= xform; ppt->setPos(P); } VRAY_clusterThis::setInstanceAttributes(myGrid); } if(myCVEX_Exec) VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname, CLUSTER_CVEX_POINT); if(myCVEX_Exec_prim) VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM); return 0; }
UT_Vector3 getScale(const GEO_Point &pt) const { return myScale.isValid() ? pt.getValue<UT_Vector3>(myScale) : UT_Vector3(1, 1, 1); }
UT_Vector3 getRotation(const GEO_Point &pt) const { return myRot.isValid() ? M_PI / 180 * pt.getValue<UT_Vector3>(myRot) : UT_Vector3(0, 0, 0); }
UT_Vector3 getPosition(const GEO_Point &pt) const { return myPos.isValid() ? pt.getValue<UT_Vector3>(myPos) : UT_Vector3(0, 0, 0); }
/* ****************************************************************************** * Function Name : render() * * Description : Render VRAY_clusterThis object * * Input Arguments : None * * Return Value : None * ***************************************************************************** */ void VRAY_clusterThis::render() { GU_Detail * gdp, *inst_gdp, *mb_gdp, *file_gdp; GEO_Point * ppt; // GEO_AttributeHandle attrHandleVelocity, attrHandleForce, attrHandleVorticity, attrHandleNormal, attrHandleNumNeighbors, // attrHandleTextureUV, attrHandleMass, attrHandleAge, attrHandleTemperature, attrHandleID, // attrHandleDensity, attrHandleViscosity, attrHandlePressure, attrHandlePscale; long int point_num = 0; static bool rendered = false; if(myVerbose > CLUSTER_MSG_QUIET) { std::cout << "VRAY_clusterThis::render() - Version: " << DCA_VERSION << std::endl; std::cout << "VRAY_clusterThis::render() - Built for Houdini Version: " << UT_MAJOR_VERSION << "." << UT_MINOR_VERSION << "." << UT_BUILD_VERSION_INT << std::endl; std::cout << "VRAY_clusterThis::render() - Instancing ..." << endl; } try { // cout << "VM_GEO_clusterThis OTL version: " << myOTLVersion << endl; // if(myOTLVersion != DCA_VERSION) { // cout << "VM_GEO_clusterThis OTL is wrong version: " << myOTLVersion << ", should be version: " << DCA_VERSION << ", please install correct version." << endl; // throw VRAY_clusterThis_Exception ( "VRAY_clusterThis::render() VM_GEO_clusterThis OTL is wrong version!", 1 ); // } if(!rendered || !myUseTempFile) { void * handle = VRAY_Procedural::queryObject(0); gdp = VRAY_Procedural::allocateGeometry(); if(myUseGeoFile) { // If the file failed to load, throw an exception if(!(gdp->load((const char *)mySrcGeoFname).success())) throw VRAY_clusterThis_Exception("VRAY_clusterThis::render() - Failed to read source geometry file ", 1); if(myVerbose > CLUSTER_MSG_INFO) cout << "VRAY_clusterThis::render() - Successfully loaded source geo file: " << mySrcGeoFname << endl; } else { gdp->copy(*VRAY_Procedural::queryGeometry(handle, 0)); if(myVerbose > CLUSTER_MSG_INFO) cout << "VRAY_clusterThis::render() - Copied incoming geometry" << endl; } gdp->getBBox(&myBox); // std::cout << "VRAY_clusterThis::render() - gdp->getBBox(&myBox): " << myBox << std::endl; VRAY_Procedural::querySurfaceShader(handle, myMaterial); myMaterial.harden(); // myPointAttributes.material = myMaterial; // const char ** getSParm (int token) const // cout << "VRAY_clusterThis::render() getSParm: " << *getSParm (0) << endl; #ifdef DEBUG cout << "VRAY_clusterThis::render() myMaterial: " << myMaterial << endl; #endif myLOD = getLevelOfDetail(myBox); if(myVerbose > CLUSTER_MSG_INFO) cout << "VRAY_clusterThis::render() myLOD: " << myLOD << endl; // Get the number if points of the incoming geometery, calculate an interval for reporting the status of the instancing to the user long int num_points = (long int) gdp->points().entries(); long int stat_interval = (long int)(num_points * 0.10) + 1; if(myVerbose > CLUSTER_MSG_QUIET) cout << "VRAY_clusterThis::render() Number of points of incoming geometry: " << num_points << endl; myObjectName = VRAY_Procedural::queryObjectName(handle); // cout << "VRAY_clusterThis::render() Object Name: " << myObjectName << endl; // cout << "VRAY_clusterThis::render() Root Name: " << queryRootName() << endl; // DEBUG stuff ... // changeSetting("object:geo_velocityblur", "on"); UT_String str; int vblur = 0; import("object:velocityblur", &vblur, 0); if(vblur) { str = 0; import("velocity", str); if(str.isstring()) { // const char * name; // name = queryObjectName(handle); VRAYwarning("%s[%s] cannot get %s", VRAY_Procedural::getClassName(), (const char *)myObjectName, " motion blur attr"); } } myXformInverse = queryTransform(handle, 0); myXformInverse.invert(); #ifdef DEBUG cout << "Geometry Samples: " << queryGeometrySamples(handle) << endl; // cout << "scale: " << getFParm ( "scale" ) << endl; #endif // Dump the user parameters to the console if(myVerbose == CLUSTER_MSG_DEBUG) VRAY_clusterThis::dumpParameters(); switch(myMethod) { case CLUSTER_INSTANCE_NOW: inst_gdp = VRAY_Procedural::allocateGeometry(); if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) mb_gdp = VRAY_Procedural::allocateGeometry(); if(myVerbose > CLUSTER_MSG_QUIET) cout << "VRAY_clusterThis::render() - Using \"instance all the geometry at once\" method" << endl; break; case CLUSTER_INSTANCE_DEFERRED: if(myVerbose > CLUSTER_MSG_QUIET) cout << "VRAY_clusterThis::render() - Using \"addProcedural()\" method" << endl; break; } rendered = true; // Get the point's attribute offsets VRAY_clusterThis::getAttributeOffsets(gdp); // Check for required attributes VRAY_clusterThis::checkRequiredAttributes(); // Check for weight attribute if the user wants metaballs if((myPrimType == CLUSTER_PRIM_METABALL) && (myPointAttrOffsets.weight.isInvalid())) { cout << "Incoming points must have weight attribute if instancing metaballs! Throwing exception ..." << endl; throw VRAY_clusterThis_Exception("VRAY_clusterThis::render() Incoming points must have weight attribute if instancing metaballs!", 1); } if(myPrimType == CLUSTER_FILE) { file_gdp = VRAY_Procedural::allocateGeometry(); int file_load_stat = VRAY_clusterThis::preLoadGeoFile(file_gdp); if(!file_load_stat) { // myFileGDP = file_gdp; if(myVerbose > CLUSTER_MSG_INFO) cout << "VRAY_clusterThis::render() Successfully loaded geometry file: " << myGeoFile << endl; } else { throw VRAY_clusterThis_Exception("VRAY_clusterThis::render() Failed to load geometry file ", 1); } } // init some vars ... myPointAttributes.Cd = (UT_Vector3(1, 1, 1)); myPointAttributes.v = (UT_Vector3(0, 0, 0)); myPointAttributes.N = (UT_Vector3(0, 1, 0)); myPointAttributes.Alpha = 1.0; myPointAttributes.pscale = 1.0; myPointAttributes.id = 0; myNoise.initialize(myNoiseSeed, myNoiseType); // Create the attribute "offsets" for the geometry to be instanced VRAY_clusterThis::createAttributeOffsets(inst_gdp, mb_gdp); //changeSetting("surface", "constant Cd ( 1 0 0 )", "object"); fpreal theta = (2.0 * M_PI) / myNumCopies; myInstanceNum = 0; if(myCVEX_Exec_pre) { if(myVerbose > CLUSTER_MSG_INFO) cout << "VRAY_clusterThis::render() Executing Pre Process CVEX code" << endl; VRAY_clusterThis::runCVEX(gdp, gdp, myCVEXFname_pre, CLUSTER_CVEX_POINT); } /// For each point of the incoming geometry GA_FOR_ALL_GPOINTS(gdp, ppt) { myPointAttributes.myPos = ppt->getPos(); // get the point's attributes VRAY_clusterThis::getAttributes(ppt, gdp); #ifdef DEBUG cout << "VRAY_clusterThis::render() " << "theta: " << theta << endl; #endif uint seed = 37; fpreal dice; bool skip = false; if((myPrimType != CLUSTER_PRIM_CURVE) || ((myMethod == CLUSTER_INSTANCE_DEFERRED && (myPrimType == CLUSTER_PRIM_CURVE)))) { // For each point, make a number of copies of and recurse a number of times for each copy ... for(int copyNum = 0; copyNum < myNumCopies; copyNum++) { for(int recursionNum = 0; recursionNum < myRecursion; recursionNum++) { // generate random number to determine to instance or not dice = SYSfastRandom(seed); (dice > myBirthProb)?skip = true:skip = false; // cout << dice << " " << skip << endl; seed = uint(dice * 100); // Calculate the position for the next instanced object ... VRAY_clusterThis::calculateNewPosition(theta, copyNum, recursionNum); if(!skip) { // Instance an object ... switch(myMethod) { // For the "create all geometry at once" method, instance the object now ... case CLUSTER_INSTANCE_NOW: // Create a primitive based upon user's selection // TODO: can later be driven by a point attribute switch(myPrimType) { case CLUSTER_POINT: VRAY_clusterThis::instancePoint(inst_gdp, mb_gdp); break; case CLUSTER_PRIM_SPHERE: VRAY_clusterThis::instanceSphere(inst_gdp, mb_gdp); break; case CLUSTER_PRIM_CUBE: VRAY_clusterThis::instanceCube(inst_gdp, mb_gdp); break; case CLUSTER_PRIM_GRID: VRAY_clusterThis::instanceGrid(inst_gdp, mb_gdp); break; case CLUSTER_PRIM_TUBE: VRAY_clusterThis::instanceTube(inst_gdp, mb_gdp); break; case CLUSTER_PRIM_CIRCLE: VRAY_clusterThis::instanceCircle(inst_gdp, mb_gdp); break; case CLUSTER_PRIM_METABALL: VRAY_clusterThis::instanceMetaball(inst_gdp, mb_gdp); break; case CLUSTER_FILE: VRAY_clusterThis::instanceFile(file_gdp, inst_gdp, mb_gdp); break; // In case a instance type comes through that's not "legal", throw exception default: throw VRAY_clusterThis_Exception("VRAY_clusterThis::render() Illegal instance type, exiting ...", 1); break; } break; // For the "deferred instance" method, add the procedural now ... case CLUSTER_INSTANCE_DEFERRED: VRAY_Procedural::openProceduralObject(); VRAY_clusterThisChild * child = new VRAY_clusterThisChild::VRAY_clusterThisChild(this); VRAY_Procedural::addProcedural(child); VRAY_Procedural::changeSetting("object:geo_velocityblur", "on"); VRAY_Procedural::closeObject(); //changeSetting("surface", "constant Cd ( 1 0 0 )", "object"); // changeSetting("object:geo_velocityblur", "on"); break; } myInstanceNum++; #ifdef DEBUG cout << "VRAY_clusterThis::render() - myInstanceNum: " << myInstanceNum << std::endl; #endif } } // for number of recursions ... } // for number of copies ... } // User wants a curve instanced on this point if((myPrimType == CLUSTER_PRIM_CURVE) && (myMethod == CLUSTER_INSTANCE_NOW) && (!skip)) VRAY_clusterThis::instanceCurve(inst_gdp, mb_gdp, theta, point_num); // Increment our point counter point_num++; // Print out stats to the console if(myVerbose > CLUSTER_MSG_INFO && (myPrimType != CLUSTER_PRIM_CURVE)) if((long int)(point_num % stat_interval) == 0) cout << "VRAY_clusterThis::render() Number of points processed: " << point_num << " Number of instances: " << myInstanceNum << endl; } // for all points ... if(myVerbose > CLUSTER_MSG_QUIET) if(myMethod == CLUSTER_INSTANCE_NOW) if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) cout << "VRAY_clusterThis::render() - Memory usage(MB): " << (fpreal)(inst_gdp->getMemoryUsage() + mb_gdp->getMemoryUsage() / (1024.0 * 1024.0)) << endl; else cout << "VRAY_clusterThis::render() - Memory usage(MB): " << (fpreal)(inst_gdp->getMemoryUsage() / (1024.0 * 1024.0)) << endl; // If the "instance all the geo at once method" is used, add the the instanced geo for mantra to render ... switch(myMethod) { case CLUSTER_INSTANCE_NOW: if(myCVEX_Exec_post) { if(myVerbose > CLUSTER_MSG_INFO) cout << "VRAY_clusterThis::render() Executing Post Process CVEX code" << endl; VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname_post, CLUSTER_CVEX_POINT); } VRAY_Procedural::openGeometryObject(); VRAY_Procedural::addGeometry(inst_gdp, 0.0); if(myDoMotionBlur == CLUSTER_MB_VELOCITY) VRAY_Procedural::addVelocityBlurGeometry(inst_gdp, myShutter, myShutter2); // float addVelocityBlurGeometry (GU_Detail *gdp, fpreal pre_blur, fpreal post_blur, const char *velocity_attribute="v") if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) VRAY_Procedural::addGeometry(mb_gdp, myShutter); VRAY_Procedural::setComputeN(1); // setSurface(myMaterial); VRAY_Procedural::closeObject(); break; case CLUSTER_INSTANCE_DEFERRED: break; } if(myVerbose > CLUSTER_MSG_QUIET && (myPrimType != CLUSTER_PRIM_CURVE)) cout << "VRAY_clusterThis::render() Total number of instances: " << myInstanceNum << endl; // Save the geo to temp location so it doesn't have to be regenerated for a deep shadow pass, etc. if(myMethod == CLUSTER_INSTANCE_NOW && myUseTempFile) { ofstream myGeoStream; // myGeoStream.open("/tmp/thisGeo.bgeo"); myGeoStream.open((const char *)myTempFname, ios_base::binary); UT_Options myOptions; inst_gdp->save(myGeoStream, 1, &myOptions); myGeoStream.flush(); myGeoStream.close(); if(myVerbose > CLUSTER_MSG_QUIET) cout << "VRAY_clusterThis::render() - Saved geometry to temp file: " << myTempFname << endl; } if(myPrimType == CLUSTER_FILE) VRAY_Procedural::freeGeometry(file_gdp); // We're done, free the original geometry VRAY_Procedural::freeGeometry(gdp); } /// if (rendered) ...
void SOP_PrimGroupCentroid::buildTransform(UT_Matrix4 &mat, const GU_Detail *input_geo, const UT_Vector3 centroid, GA_Offset ptOff) { bool use_orient = false; fpreal pscale = 1; GA_ROAttributeRef dir_gah, orient_gah, pscale_gah, rot_gah, scale_gah, trans_gah, up_gah; GA_ROHandleF pscale_h; GA_ROHandleV3 dir_h, scale_h, trans_h, up_h; GA_ROHandleV4 orient_h, rot_h; UT_Matrix4 pre_xform, xform; UT_Quaternion orient, rot; UT_Vector3 dir, pt_pos, scale, trans, up; pt_pos = input_geo->getPos3(ptOff); pre_xform.identity(); pre_xform.translate(centroid[0], centroid[1], centroid[2]); pre_xform.invert(); // Try to find the specific attribute. orient_gah = input_geo->findFloatTuple(GA_ATTRIB_POINT, GA_SCOPE_PUBLIC, "orient", 4, 4); // Found the attribute. if (orient_gah.isValid()) { orient_h.bind(orient_gah.getAttribute()); // Get the attribute value. UT_Vector4 value = orient_h.get(ptOff); // Construct a quaternion from the values. orient.assign(value[0], value[1], value[2], value[3]); use_orient = true; } // Try to find the 'trans' point attribute. trans_gah = input_geo->findFloatTuple(GA_ATTRIB_POINT, GA_SCOPE_PUBLIC, "trans", 3, 3); // We found it. if (trans_gah.isValid()) { // Bind the handle to the attribute.. trans_h.bind(trans_gah.getAttribute()); // Get the attribute value. trans = trans_h.get(ptOff); } else trans.assign(0, 0, 0); // Try to find the scale attribute. scale_gah = input_geo->findFloatTuple(GA_ATTRIB_POINT, GA_SCOPE_PUBLIC, "scale", 3, 3); // Try to find the pscale attribute. pscale_gah = input_geo->findFloatTuple(GA_ATTRIB_POINT, GA_SCOPE_PUBLIC, "pscale", 1, 1); // If the pscale attribute exists, get the value. if (pscale_gah.isValid()) { pscale_h.bind(pscale_gah.getAttribute()); pscale = pscale_h.get(ptOff); } // The scale attribute exists. if (scale_gah.isValid()) { scale_h.bind(scale_gah.getAttribute()); // Get the scale. scale = scale_h.get(ptOff); } else { // Use a default scale. scale.assign(1, 1, 1); } // Try to find the specific attribute. rot_gah = input_geo->findFloatTuple(GA_ATTRIB_POINT, GA_SCOPE_PUBLIC, "rot", 4, 4); // Found the attribute. if (rot_gah.isValid()) { rot_h.bind(rot_gah.getAttribute()); // Get the attribute value. UT_Vector4 value = rot_h.get(ptOff); // Construct a quaternion from the values. rot.assign(value[0], value[1], value[2], value[3]); } if (use_orient) { xform.instance(pt_pos, dir, pscale, &scale, &up, &rot, &trans, &orient); } // Need to build the transform manually. else { // Try to find the point Normal attribute. dir_gah = input_geo->findNormalAttribute(GA_ATTRIB_POINT); // We couldn't find the Normal attribute. if (dir_gah.isInvalid()) { // Try to find the velocity attribute. dir_gah = input_geo->findVelocityAttribute(GA_ATTRIB_POINT); } // We found either the normal or velocity attributes. if (dir_gah.isValid()) { // Bind the direction handle to the found attribute. dir_h.bind(dir_gah.getAttribute()); dir = dir_h.get(ptOff); } // Default to the Z-axis. else dir = UT_Vector3(0,0,1); // Try to find the upvector ('up') attribute. up_gah = input_geo->findFloatTuple(GA_ATTRIB_POINT, GA_SCOPE_PUBLIC, "up", 3, 3); // We found the up vector. if (up_gah.isValid()) { up_h.bind(up_gah.getAttribute()); // Get the up vector. up = up_h.get(ptOff); } // Leave the up vector as the zero vector. else up.assign(0,0,0); xform.instance(pt_pos, dir, pscale, &scale, &up, &rot, &trans, 0); } // Assign the transform. mat = pre_xform * xform; }
void VRAY_clusterThis::preProcess(GU_Detail * gdp) { GEO_Point * ppt; long int num_points = (long int) gdp->points().entries(); long int stat_interval = (long int)(num_points * 0.10) + 1; for(uint32 i = gdp->points().entries(); i-- > 0;) { ppt = gdp->points()(i); myPointList.append(i); } // If the user wants to build grids for pre processing // TODO: Should this be an option? There may be functions/features that will depend on this ... discuss! if(!myPreProcess) return; if(myVerbose > CLUSTER_MSG_INFO) cout << "VRAY_clusterThis::preProcess() Pre Processing Voxels" << std::endl; // openvdb::ScalarGrid::Accessor accessor; // openvdb::FloatTree myTree; openvdb::FloatTree::ConstPtr myGeoTreePtr; openvdb::VectorTree::ConstPtr myGeoGradTreePtr; ParticleList paGeoList(gdp, myPreVDBRadiusMult, myPreVDBVelocityMult); openvdb::tools::PointSampler myGeoSampler, geoGradSampler; // openvdb::tools::GridSampling<openvdb::FloatTree> myGridSampler; if(myVerbose == CLUSTER_MSG_DEBUG) std::cout << "VRAY_clusterThis::preProcess() paGeoList.size() ... " << paGeoList.size() << std::endl; if(paGeoList.size() != 0) { hvdb::Interrupter boss("VRAY_clusterThis::preProcess() Converting particles to level set"); Settings settings; settings.mRadiusMin = myPreRadiusMin; settings.mRasterizeTrails = myPreRasterType; settings.mDx = myPreDx; // only used for rasterizeTrails() settings.mFogVolume = myPreFogVolume; settings.mGradientWidth = myPreGradientWidth; // only used for fog volume float background; // background in WS units if(myPreWSUnits) background = myPreBandWidth; // background NOT in WS units else background = myPreVoxelSize * myPreBandWidth; // Construct a new scalar grid with the specified background value. openvdb::math::Transform::Ptr transform = openvdb::math::Transform::createLinearTransform(myPreVoxelSize); // openvdb::ScalarGrid::Ptr myGeoGrid = openvdb::ScalarGrid::create(background); myGeoGrid = openvdb::ScalarGrid::create(background); myGeoGrid->setTransform(transform); myGeoGrid->setGridClass(openvdb::GRID_LEVEL_SET); // Perform the particle conversion. this->convert(myGeoGrid, paGeoList, settings, boss); if(myVerbose == CLUSTER_MSG_DEBUG) { std::cout << "VRAY_clusterThis::preProcess() - activeVoxelCount(): " << myGeoGrid->activeVoxelCount() << std::endl; std::cout << "VRAY_clusterThis::preProcess() - background: " << myGeoGrid->background() << std::endl; } // Insert the new grid into the ouput detail. UT_String gridNameStr = "ClusterGrid"; myGeoGrid->insertMeta("float type", openvdb::StringMetadata("averaged_velocity")); myGeoGrid->insertMeta("name", openvdb::StringMetadata((const char *)gridNameStr)); myGeoGrid->insertMeta("VoxelSize", openvdb::FloatMetadata(myPreVoxelSize)); myGeoGrid->insertMeta("background", openvdb::FloatMetadata(background)); UT_Vector3 pos, seed_pos, currVel; // const GA_PointGroup * sourceGroup = NULL; long int pt_counter = 0; float radius = 5.0f; if(myVerbose > CLUSTER_MSG_INFO) std::cout << "VRAY_clusterThis::preProcess() - Massaging data ... " << std::endl; long int pointsFound = 0; GEO_AttributeHandle inst_vel_gah = gdp->getPointAttribute("v"); GEO_AttributeHandle source_vel_gah = gdp->getPointAttribute("v"); GEO_AttributeHandle inst_N_gah = gdp->getPointAttribute("N"); GEO_AttributeHandle source_N_gah = gdp->getPointAttribute("N"); GEO_AttributeHandle inst_Cd_gah = gdp->getPointAttribute("Cd"); GEO_AttributeHandle source_Cd_gah = gdp->getPointAttribute("Cd"); GEO_AttributeHandle inst_Alpha_gah = gdp->getPointAttribute("Alpha"); GEO_AttributeHandle source_Alpha_gah = gdp->getPointAttribute("Alpha"); if(!inst_vel_gah.isAttributeValid()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::preProcess() Instance velocity handle invalid, exiting ...", 1); if(!source_vel_gah.isAttributeValid()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::preProcess() Source velocity handle invalid, exiting ...", 1); if(!inst_N_gah.isAttributeValid()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::preProcess() Instance normal handle invalid, exiting ...", 1); if(!source_N_gah.isAttributeValid()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::preProcess() Source normal handle invalid, exiting ...", 1); if(!inst_Cd_gah.isAttributeValid()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::preProcess() Instance color handle invalid, exiting ...", 1); if(!source_Cd_gah.isAttributeValid()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::preProcess() Source color handle invalid, exiting ...", 1); if(!inst_Alpha_gah.isAttributeValid()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::preProcess() Instance alpha handle invalid, exiting ...", 1); if(!source_Alpha_gah.isAttributeValid()) throw VRAY_clusterThis_Exception("VRAY_clusterThis::preProcess() Source alpha handle invalid, exiting ...", 1); openvdb::FloatTree::ValueType sampleResult; openvdb::VectorGrid::ValueType gradResult; const openvdb::FloatTree aTree; openvdb::FloatTree& myGeoTree = myGeoGrid->treeRW(); openvdb::tools::Filter<openvdb::FloatGrid> preProcessFilter(*myGeoGrid); // openvdb::tools::Filter<openvdb::FloatGrid> barFilter(myGeoGrid); if(myPreVDBMedianFilter) preProcessFilter.median(); if(myPreVDBMeanFilter) preProcessFilter.mean(); if(myPreVDBMeanCurvatureFilter) preProcessFilter.meanCurvature(); if(myPreVDBLaplacianFilter) preProcessFilter.laplacian(); // if(myVDBReNormalizeFilter) // float r = barFilter.renormalize(3, 0.1); if(myPreVDBOffsetFilter) preProcessFilter.offset(myPreVDBOffsetFilterAmount); myGradientGrid = openvdb::VectorGrid::create(); // openvdb::VectorGrid::Ptr myGradientGrid = openvdb::VectorGrid::create(); myGradientGrid->setTransform(transform); // myGradientGrid->setGridClass(openvdb::GRID_FOG_VOLUME ); myGradientGrid->setGridClass(openvdb::GRID_LEVEL_SET); openvdb::tools::Gradient<openvdb::ScalarGrid> myGradient(*myGeoGrid); myGradientGrid = myGradient.process(); openvdb::VectorTree& myGeoGradTree = myGradientGrid->treeRW(); gridNameStr = "ClusterGradientGrid"; myGradientGrid->insertMeta("vector type", openvdb::StringMetadata("covariant (gradient)")); myGradientGrid->insertMeta("name", openvdb::StringMetadata((const char *)gridNameStr)); myGradientGrid->insertMeta("VoxelSize", openvdb::FloatMetadata(myPreVoxelSize)); myGradientGrid->insertMeta("background", openvdb::FloatMetadata(background)); GA_FOR_ALL_GPOINTS(gdp, ppt) { // myCurrPtOff = ppt->getMapOffset(); // std::cout << "myCurrPtOff: " << myCurrPtOff << std::endl; pos = ppt->getPos(); // Vec3d worldToIndex ( const Vec3d & xyz ) const // openvdb::Vec3R theIndex = // (openvdb::Vec3R(pos[0], pos[1], pos[2])); openvdb::Vec3R theIndex = myGeoGrid->worldToIndex(openvdb::Vec3R(pos[0], pos[1], pos[2])); radius = static_cast<fpreal>(ppt->getValue<fpreal>(myInstAttrRefs.pointVDBRadius, 0)); // std::cout << "radius: " << radius << std::endl; // static bool sample (const TreeT &inTree, const Vec3R &inCoord, typename TreeT::ValueType &sampleResult) const openvdb::Vec3R inst_sample_pos(theIndex[0], theIndex[1], theIndex[2]); bool success = myGeoSampler.sample(myGeoTree, inst_sample_pos, sampleResult); geoGradSampler.sample(myGeoGradTree, inst_sample_pos, gradResult); // // std::cout << "success: " << success << "\tpos: " << pos // << "\tinst_sample_pos: " << inst_sample_pos // << "\tsampleResult: " << sampleResult << std::endl; //ValueType sampleWorld (const Vec3R &pt) const //ValueType sampleWorld (Real x, Real y, Real z) const // if the instanced point is within the vdb volume if(success) { // std::cout << "pos: " << pos << " inst_sample_pos: " // << inst_sample_pos << " sampleResult: " << sampleResult // << " gradResult: " << gradResult << std::endl; // float weight; pointsFound++; inst_vel_gah.setElement(ppt); currVel = inst_vel_gah.getV3(); UT_Vector3 gradVect = UT_Vector3(gradResult[0], gradResult[1], gradResult[2]); ppt->setPos(pos + (myPrePosInfluence *(sampleResult * gradVect))); // ppt->setPos(pos + (sampleResult * myPosInfluence *(currVel / myFPS))); // inst_vel_gah.setV3(currVel * ((1 / sampleResult) * radius)); inst_vel_gah.setV3(currVel + (myPreVelInfluence *(sampleResult * gradVect))); // std::cout << "currVel: " << currVel << " sampleResult " << sampleResult // << " new vel: " << currVel * sampleResult << std::endl; inst_N_gah.setV3(inst_N_gah.getV3() + (myPreNormalInfluence *(sampleResult * gradVect))); // inst_Cd_gah.setElement(ppt); // inst_Cd_gah.setV3(inst_Cd_gah.getV3() * abs(sampleResult)); // // // inst_Alpha_gah.setElement(ppt); // inst_Alpha_gah.setF(inst_Alpha_gah.getF() * abs(sampleResult)); } // if the instanced point is within the vdb volume if(myVerbose == CLUSTER_MSG_DEBUG) { pt_counter++; if((long int)(pt_counter % (stat_interval * myNumCopies * myRecursion)) == 0) { cout << "VRAY_clusterThis::preProcess() Number of points pre processed: " << pt_counter << "\t - Number of points found in vdb grid: " << pointsFound << std::endl; } } }