VDPMLoader::~VDPMLoader(){ this->qFilename_.clear(); this->mesh_loaded = false; vsplit_loaded.clear(); vfront_.clear(); vhierarchy_.clear(); index2handle_map.clear(); //mesh_.clear(); VDPMMesh::FaceIter fIt(mesh_.faces_begin()), fEnd(mesh_.faces_end()); for(; fIt != fEnd; ++fIt){ mesh_.delete_face(fIt.handle()); } VDPMMesh::VertexIter vIt(mesh_.vertices_begin()), vEnd(mesh_.vertices_end()); for(; vIt != vEnd; ++vIt){ mesh_.delete_vertex(vIt.handle()); } mesh_.garbage_collection(); if(base_info_data != NULL){ delete [] base_info_data; base_info_data = NULL; } base_info_data_size = 0; }
void transform(const TMeshImageP &meshImage, const TAffine &aff) { const std::vector<TTextureMeshP> &meshes = meshImage->meshes(); int m, mCount = meshes.size(); for (m = 0; m != mCount; ++m) { TTextureMesh &mesh = *meshes[m]; tcg::list<TTextureMesh::vertex_type> &vertices = mesh.vertices(); tcg::list<TTextureMesh::vertex_type>::iterator vt, vEnd(vertices.end()); for (vt = vertices.begin(); vt != vEnd; ++vt) vt->P() = aff * vt->P(); } }
/** * @return The angle from between two vectors using the current vector as the center * return 0, if the angle is not well defined */ double RS_Vector::angleBetween(const RS_Vector& v1, const RS_Vector& v2) const { if (!valid || !v1.valid || !v2.valid) { return 0.0; } else { RS_Vector vStart(v1- (*this)); RS_Vector vEnd(v2- (*this)); // if( vStart.magnitude() < RS_TOLERANCE // || vEnd.magnitude() < RS_TOLERANCE) return 0.0; return RS_Math::correctAngle( atan2( vStart.x*vEnd.y-vStart.y*vEnd.x, vStart.x*vEnd.x+vStart.y*vEnd.y)); // std::cout<<"old algorithm:: "<<RS_Math::correctAngle(vEnd.angle() - vStart.angle())<<std::endl; // return RS_Math::correctAngle(vEnd.angle() - vStart.angle()); } }
/** * this should handle modifyOffset *@ coord, indicate direction of offset *@ distance of offset * *@Author, Dongxu Li */ bool RS_Polyline::offset(const RS_Vector& coord, const double& distance){ double dist; //find the nearest one int length=count(); std::vector<RS_Vector> intersections(length); if(length>1){//sort the polyline entity start/end point order int i(0); double d0,d1; RS_Entity* en0(entityAt(0)); RS_Entity* en1(entityAt(1)); RS_Vector vStart(en0->getStartpoint()); RS_Vector vEnd(en0->getEndpoint()); en1->getNearestEndpoint(vStart,&d0); en1->getNearestEndpoint(vEnd,&d1); if(d0<d1) en0->revertDirection(); for(i=1;i<length;en0=en1){ //linked to head-tail chain en1=entityAt(i); vStart=en1->getStartpoint(); vEnd=en1->getEndpoint(); en0->getNearestEndpoint(vStart,&d0); en0->getNearestEndpoint(vEnd,&d1); if(d0>d1) en1->revertDirection(); intersections[i-1]=(en0->getEndpoint()+en1->getStartpoint())*0.5; i++; } } RS_Entity* en(getNearestEntity(coord, &dist, RS2::ResolveNone)); if(en==NULL) return false; int indexNearest=findEntity(en); // RS_Vector vp(en->getNearestPointOnEntity(coord,false)); // RS_Vector direction(en->getTangentDirection(vp)); // RS_Vector vp1(-direction.y,direction.x);//normal direction // double a2(vp1.squared()); // if(a2<RS_TOLERANCE2) return false; // vp1 *= distance/sqrt(a2); // move(vp1); // return true; RS_Polyline* pnew= static_cast<RS_Polyline*>(clone()); int i; i=indexNearest; int previousIndex(i); pnew->entityAt(i)->offset(coord,distance); RS_Vector vp; //offset all //fixme, this is too ugly for(i=indexNearest-1;i>=0;i--){ RS_VectorSolutions sol0=RS_Information::getIntersection(pnew->entityAt(previousIndex),entityAt(i),true); // RS_VectorSolutions sol1; double dmax(RS_TOLERANCE15); RS_Vector trimP(false); for(const RS_Vector& vp: sol0){ double d0( (vp - pnew->entityAt(previousIndex)->getStartpoint()).squared());//potential bug, need to trim better if(d0>dmax) { dmax=d0; trimP=vp; } } if(trimP.valid){ static_cast<RS_AtomicEntity*>(pnew->entityAt(previousIndex))->trimStartpoint(trimP); static_cast<RS_AtomicEntity*>(pnew->entityAt(i))->trimEndpoint(trimP); vp=pnew->entityAt(previousIndex)->getMiddlePoint(); }else{ vp=pnew->entityAt(previousIndex)->getStartpoint(); vp.rotate(entityAt(previousIndex)->getStartpoint(),entityAt(i)->getDirection2()-entityAt(previousIndex)->getDirection1()+M_PI); } pnew->entityAt(i)->offset(vp,distance); previousIndex=i; } previousIndex=indexNearest; for(i=indexNearest+1;i<length;i++){ RS_VectorSolutions sol0=RS_Information::getIntersection(pnew->entityAt(previousIndex),entityAt(i),true); // RS_VectorSolutions sol1; double dmax(RS_TOLERANCE15); RS_Vector trimP(false); for(const RS_Vector& vp: sol0){ double d0( (vp - pnew->entityAt(previousIndex)->getEndpoint()).squared());//potential bug, need to trim better if(d0>dmax) { dmax=d0; trimP=vp; } } if(trimP.valid){ static_cast<RS_AtomicEntity*>(pnew->entityAt(previousIndex))->trimEndpoint(trimP); static_cast<RS_AtomicEntity*>(pnew->entityAt(i))->trimStartpoint(trimP); vp=pnew->entityAt(previousIndex)->getMiddlePoint(); }else{ vp=pnew->entityAt(previousIndex)->getEndpoint(); vp.rotate(entityAt(previousIndex)->getEndpoint(),entityAt(i)->getDirection1()-entityAt(previousIndex)->getDirection2()+M_PI); } pnew->entityAt(i)->offset(vp,distance); previousIndex=i; } //trim //connect and trim RS_Modification m(*container, graphicView); for(i=0;i<length-1;i++){ RS_VectorSolutions sol0=RS_Information::getIntersection(pnew->entityAt(i),pnew->entityAt(i+1),true); if(sol0.getNumber()==0) { sol0=RS_Information::getIntersection(pnew->entityAt(i),pnew->entityAt(i+1)); // RS_Vector vp0(pnew->entityAt(i)->getEndpoint()); // RS_Vector vp1(pnew->entityAt(i+1)->getStartpoint()); // double a0(intersections.at(i).angleTo(vp0)); // double a1(intersections.at(i).angleTo(vp1)); RS_VectorSolutions sol1; for(const RS_Vector& vp: sol0){ if(RS_Math::isAngleBetween(intersections.at(i).angleTo(vp), pnew->entityAt(i)->getDirection2(), pnew->entityAt(i+1)->getDirection1(), false)==false){ sol1.push_back(vp); } } if(sol1.getNumber()==0) continue; RS_Vector trimP(sol1.getClosest(intersections.at(i))); static_cast<RS_AtomicEntity*>(pnew->entityAt(i))->trimEndpoint(trimP); static_cast<RS_AtomicEntity*>(pnew->entityAt(i+1))->trimStartpoint(trimP); }else{ RS_Vector trimP(sol0.getClosest(pnew->entityAt(i)->getStartpoint())); static_cast<RS_AtomicEntity*>(pnew->entityAt(i))->trimEndpoint(trimP); static_cast<RS_AtomicEntity*>(pnew->entityAt(i+1))->trimStartpoint(trimP); } } *this = *pnew; return true; }
//----------------------------------------------------------------------------- // Purpose: // Input : time - // type - // Output : float //----------------------------------------------------------------------------- float CSentence::GetIntensity( float time, float endtime ) { float zeroValue = 0.5f; int c = GetNumSamples(); if ( c <= 0 ) { return zeroValue; } int i; for ( i = -1 ; i < c; i++ ) { CEmphasisSample *s = GetBoundedSample( i, endtime ); CEmphasisSample *n = GetBoundedSample( i + 1, endtime ); if ( !s || !n ) continue; if ( time >= s->time && time <= n->time ) { break; } } int prev = i - 1; int start = i; int end = i + 1; int next = i + 2; prev = max( -1, prev ); start = max( -1, start ); end = min( end, GetNumSamples() ); next = min( next, GetNumSamples() ); CEmphasisSample *esPre = GetBoundedSample( prev, endtime ); CEmphasisSample *esStart = GetBoundedSample( start, endtime ); CEmphasisSample *esEnd = GetBoundedSample( end, endtime ); CEmphasisSample *esNext = GetBoundedSample( next, endtime ); float dt = esEnd->time - esStart->time; dt = clamp( dt, 0.01f, 1.0f ); Vector vPre( esPre->time, esPre->value, 0 ); Vector vStart( esStart->time, esStart->value, 0 ); Vector vEnd( esEnd->time, esEnd->value, 0 ); Vector vNext( esNext->time, esNext->value, 0 ); float f2 = ( time - esStart->time ) / ( dt ); f2 = clamp( f2, 0.0f, 1.0f ); Vector vOut; Catmull_Rom_Spline( vPre, vStart, vEnd, vNext, f2, vOut ); float retval = clamp( vOut.y, 0.0f, 1.0f ); return retval; }
//determines if the specified segment intersects a polygon. It fills out //passed in datastructure appropriately. bool CLightingBSP::IntersectSegment(const PVector& vSegStart, const PVector& vSegEnd, CLightBSPStack* pStack, CIntersectInfo* pInfo) const { ASSERT(pStack); uint32 nStackOff = 0; //the working endpoints PVector vStart(vSegStart); PVector vEnd(vSegEnd); //the polygon hit CLightBSPPoly* pHitPoly; //the working node CLightBSPNode* pNode = m_pHead; while(1) { //classify the points PReal fStartDot = vStart.Dot(pNode->m_vPlaneNorm) - pNode->m_fPlaneDist; PReal fEndDot = vEnd.Dot(pNode->m_vPlaneNorm) - pNode->m_fPlaneDist; //check for the same side if((fStartDot >= 0) && (fEndDot >= 0)) { //we are in the front pNode = pNode->m_pFront; } else if((fStartDot < 0) && (fEndDot < 0)) { //we are in the back pNode = pNode->m_pBack; } else { //save the node that we want to test first pStack[nStackOff].m_pTest = pNode; pStack[nStackOff].m_vEnd = vEnd; //we have intersected if(fStartDot < 0) { //setup our stack information pStack[nStackOff].m_pNode = pNode->m_pFront; //we do the back first pNode = pNode->m_pBack; } else { //setup our stack information pStack[nStackOff].m_pNode = pNode->m_pBack; //we do the front first pNode = pNode->m_pFront; } //calculate the new working endpoint vEnd = vStart + (vEnd - vStart) * -fStartDot / (fEndDot - fStartDot); //next stack item nStackOff++; } //if we hit a null node, we need to bubble out of the stack, or bail while(pNode == NULL) { //if the stack is empty, no intersection occurred if(nStackOff == 0) return false; //pop the stack nStackOff--; //the stack is not empty, we need to test against the specified node, //and then check behind it if no hit occurred if(pHitPoly = CheckHitNode(pStack[nStackOff].m_pTest, vEnd)) { if(pInfo) { pInfo->m_vNormal = pStack[nStackOff].m_pTest->m_vPlaneNorm; pInfo->m_vIntersectPt = vEnd; pInfo->m_nFlags = pHitPoly->m_nFlags; } return true; } //no intersection, so we now need to process the back half vStart = vEnd; vEnd = pStack[nStackOff].m_vEnd; pNode = pStack[nStackOff].m_pNode; } } //infinite loop. Exits when stack is popped off completely, or when poly is hit }
bool ExportMediaDialog::MessageReceived(EMListenerRepository* p_opSender, uint32 p_vMessage) { switch(p_vMessage) { /* case EM_DRAW: if(p_opSender == m_opMainView) { eo << "EM_DRAW: m_oBackgroundView" << ef; m_opMainView -> SetHighColor(EMColor(0, 255, 0, 255)); m_opMainView -> FillRect(m_opMainView -> Bounds()); } else eo << "EM_DRAW (unknown)" << ef; return true; */ case EM_BUTTON_SETTINGS: EMCommandRepository::Instance() -> ExecuteCommand(COMMAND_DISPLAY_EXPORT_MEDIA_SETTINGS_DIALOG, m_opDialogWindow, reinterpret_cast<void*>(m_opExportTypeComboBox -> GetSelectionIndex()), this); m_opExportTypeComboBox -> Notify(EXPORT_TYPE_COMBO_BOX_CHANGED); return true; case EM_BUTTON_BROWSE: eo << "Browse button pressed" << ef; if(m_opBrowseWindow == NULL) m_opBrowseWindow = EMFactory::Instance() -> CreateBrowseWindow(m_opMainView -> GetNativeView(), "Browse"); if(m_opBrowseWindow -> DisplayDialog()) m_opExportToTextControl -> SetText(m_opBrowseWindow -> GetPath() -> c_str()); return true; /* case EM_BUTTON_SAVE_TEMPLATE: eo << "Save Template button pressed" << ef; return true; case EM_BUTTON_DELETE_TEMPLATE: eo << "Delete Template button pressed" << ef; return true; */ case EM_RENDERING_COULD_NOT_START: if(m_vExporting) StopExporting(false); return true; case EM_RENDERING_HAS_FINNISHED: if(m_vExporting == false) return true; case EM_GUI_COMPONENT_ENTER_PRESSED: case EM_BUTTON_EXPORT: { eo << "Export button pressed" << ef; if(m_vExporting == false) { if(InvalidCharExist(m_opExportToTextControl -> Text(), m_opFilenameTextControl -> Text())) { eo << "Invalid Character found!!" << ef; return true; } string oDirectoryTemp = m_opExportToTextControl -> Text(); if(oDirectoryTemp.length() != oDirectoryTemp.find_last_of("\\") + 1) { oDirectoryTemp.append("\\"); m_opExportToTextControl -> SetText(oDirectoryTemp.c_str()); } int vResult = CreateDir(const_cast<char*>(m_opExportToTextControl -> Text()), const_cast<char*>(m_opFilenameTextControl -> Text())); switch(vResult) { case RESULT_OK: m_vExporting = true; m_vExportTypeOld = m_opExportTypeComboBox -> GetSelectionIndex(); m_oExportToOld = m_opExportToTextControl -> Text(); // m_oFilenameOld = m_ Export(); return true; case RESULT_NOT_OK: case RESULT_NO_BUTTON: eo << "Go back to dialog" << ef; return true; case RESULT_CANCEL_BUTTON: eo << "Close dialog and do nothing" << ef; break; } } else { StopExporting(); return true; } HideDialog(); return true; } case EM_GUI_COMPONENT_ESC_PRESSED: case EM_BUTTON_CANCEL: eo << "Cancel button pressed" << ef; if(m_vExporting) StopExporting(); HideDialog(); return true; case EM_TEXT_CONTROL_CHANGE: eo << "EM_TEXT_CONTROL_FILENAME_CHANGE" << ef; if(strlen(m_opFilenameTextControl -> Text()) == 0 || strlen(m_opExportToTextControl -> Text()) == 0) m_opExportButton -> Enable(false); else m_opExportButton -> Enable(true); if(p_opSender == m_opExportToTextControl) { if(m_vFilenameChanged) { m_vExportToChanged = false; m_vFilenameChanged = false; } else m_vExportToChanged = true; } if(p_opSender == m_opFilenameTextControl) { m_vFilenameChanged = true; AddToExportToTextControl(); } return true; case EM_GUI_COMPONENT_GOT_FOCUS: eo << "EM_TEXT_CONTROL_GOT_FOCUS" << ef; if(p_opSender == m_opFilenameTextControl) { eo << "Filename got Focus" << ef; string oFilename(m_opFilenameTextControl -> Text()); m_opFilenameTextControl -> SetSelection(0, oFilename.find_last_of('.')); } if(p_opSender == m_opDialogWindow) m_opExportButton -> SetFocus(); m_opDialogWindow -> SetCurrentFocus(); return true; case EM_GUI_COMPONENT_TAB_PRESSED: eo << "EM_GUI_COMPONENT_TAB_PRESSED" << ef; m_opDialogWindow -> NextTab(); return true; case EM_GUI_COMPONENT_SHIFT_TAB_PRESSED: m_opDialogWindow -> PreviousTab(); return true; case EM_TEXT_CONTROL_END_PRESSED: if(p_opSender == m_opFilenameTextControl) { eo << "EM_TEXT_CONTROL_END_ARROW_PRESSED" << ef; uint32 vModifiers = EMKeyboard::Instance() -> GetModifiers(); if((vModifiers & EM_SHIFT_KEY) == EM_SHIFT_KEY) { int32 vStart(0); int32 vEnd(0); m_opFilenameTextControl -> GetSelection(vStart, vEnd); m_opFilenameTextControl -> SetSelection(vStart, strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()); } else m_opFilenameTextControl -> SetSelection(strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length(), strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()); return true; } return false; case EM_TEXT_CONTROL_DELETE_PRESSED: if(p_opSender == m_opFilenameTextControl) { eo << "EM_TEXT_CONTROL_DELETE_PRESSED" << ef; int32 vStart(0); int32 vEnd(0); m_opFilenameTextControl -> GetSelection(vStart, vEnd); if(vStart == vEnd && vEnd >= strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()) return true; } return false; case EM_TEXT_CONTROL_DOWN_ARROW_PRESSED: case EM_TEXT_CONTROL_RIGHT_ARROW_PRESSED: if(p_opSender == m_opFilenameTextControl) { eo << "EM_TEXT_CONTROL_DOWN/RIGHT_ARROW_PRESSED" << ef; int32 vStart(0); int32 vEnd(0); m_opFilenameTextControl -> GetSelection(vStart, vEnd); if(vEnd >= strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()) return true; } return false; case EM_TEXT_CONTROL_LEFT_MOUSE_BUTTON_DOWN: if(p_opSender == m_opFilenameTextControl) { int32 vStart(0); int32 vEnd(0); m_opFilenameTextControl -> GetSelection(vStart, vEnd); if(vEnd >= strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length() && vStart >= strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()) { m_opFilenameTextControl -> SetSelection(strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length(), strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()); //return true; } else if(vEnd >= strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length() && vStart < strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()) { m_opFilenameTextControl -> SetSelection(vStart, strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()); //return true; } } return false; case EM_TEXT_CONTROL_MENU_SELECTED: eo << "EM_TEXT_CONTROL_MENU_SELECTED" << ef; if(p_opSender == m_opFilenameTextControl) { m_vSelectedFromMenu = true; return true; } return false; case EM_TEXT_CONTROL_SET_SELECTION: eo << "EM_TEXT_CONTROL_SET_SELECTION" << ef; if(p_opSender == m_opFilenameTextControl) { if(m_vSelectedFromMenu) { m_vSelectedFromMenu = false; m_opFilenameTextControl -> SetSelection(0, strlen(m_opFilenameTextControl -> Text()) - m_oFileExtension.length()); return true; } } return false; case EXPORT_TYPE_COMBO_BOX_CHANGED: { eo << "EXPORT_TYPE_COMBO_BOX_CHANGED" << ef; switch(m_opExportTypeComboBox -> GetSelectionIndex()) { case 0: m_vRenderAudio = true; m_vRenderVideo = false; m_oFileExtension = ".wav"; break; case 1: m_vRenderAudio = true; m_vRenderVideo = true; //m_oFileExtension = ".avi"; m_oFileExtension = ExportMediaSettingsDialog::m_vFileExtension; break; case 2: m_vRenderAudio = false; m_vRenderVideo = true; //m_oFileExtension = ".avi"; m_oFileExtension = ExportMediaSettingsDialog::m_vFileExtension; break; } string oFilename; oFilename.append(m_oDefaultFilename); oFilename.append(m_oFileExtension); m_opFilenameTextControl -> SetText(oFilename.c_str()); return true; } case EM_CLOSE_WINDOW: eo << "EM_CLOSE_WINDOW" << ef; if(m_vExporting) { StopExporting(); return true; } HideDialog(); return true; } return false; }
void VDPMLoader::openVDPM_ServerRendering(const char *_filename) { unsigned int i; unsigned int value; unsigned int fvi[3]; char fileformat[16]; Vec3f p, normal; float radius, sin_square, mue_square, sigma_square; VHierarchyNodeHandleContainer roots; VertexHandle vertex_handle; VHierarchyNodeIndex node_index; VHierarchyNodeIndex lchild_node_index, rchild_node_index; VHierarchyNodeIndex fund_lcut_index, fund_rcut_index; VHierarchyNodeHandle node_handle; VHierarchyNodeHandle lchild_node_handle, rchild_node_handle; std::ifstream ifs(_filename, std::ios::binary); if (!ifs) { std::cerr << "read error\n"; exit(1); } // bool swap = Endian::local() != Endian::LSB; // read header ifs.read(fileformat, 10); fileformat[10] = '\0'; if (std::string(fileformat) != std::string("VDProgMesh")) { std::cerr << "Wrong file format.\n"; ifs.close(); exit(1); } IO::restore(ifs, n_base_vertices_, swap); IO::restore(ifs, n_base_faces_, swap); IO::restore(ifs, n_details_, swap); mesh_.clear(); vfront_.clear(); vhierarchy_.clear(); vhierarchy_.set_num_roots(n_base_vertices_); // load base mesh for (i=0; i<n_base_vertices_; ++i) { IO::restore(ifs, p, swap); IO::restore(ifs, radius, swap); IO::restore(ifs, normal, swap); IO::restore(ifs, sin_square, swap); IO::restore(ifs, mue_square, swap); IO::restore(ifs, sigma_square, swap); vertex_handle = mesh_.add_vertex(p); node_index = vhierarchy_.generate_node_index(i, 1); node_handle = vhierarchy_.add_node(); VHierarchyNode &node = vhierarchy_.node(node_handle); node.set_index(node_index); node.set_vertex_handle(vertex_handle); mesh_.data(vertex_handle).set_vhierarchy_node_handle(node_handle); node.set_radius(radius); node.set_normal(normal); node.set_sin_square(sin_square); node.set_mue_square(mue_square); node.set_sigma_square(sigma_square); mesh_.set_normal(vertex_handle, normal); index2handle_map[node_index] = node_handle; roots.push_back(node_handle); } vfront_.init(roots, n_details_); for (i=0; i<n_base_faces_; ++i) { IO::restore(ifs, fvi[0], swap); IO::restore(ifs, fvi[1], swap); IO::restore(ifs, fvi[2], swap); mesh_.add_face(mesh_.vertex_handle(fvi[0]), mesh_.vertex_handle(fvi[1]), mesh_.vertex_handle(fvi[2])); } vsplit_loaded.clear(); // load details for (i=0; i<n_details_; ++i) { Vsplit avs; // position of v0 IO::restore(ifs, p, swap); avs.v0 = p; // vsplit info. IO::restore(ifs, value, swap); node_index = VHierarchyNodeIndex(value); avs.node_index = value; IO::restore(ifs, value, swap); fund_lcut_index = VHierarchyNodeIndex(value); avs.fund_lcut_index = value; IO::restore(ifs, value, swap); fund_rcut_index = VHierarchyNodeIndex(value); avs.fund_rcut_index = value; node_handle = index2handle_map[node_index]; vhierarchy_.make_children(node_handle); VHierarchyNode &node = vhierarchy_.node(node_handle); VHierarchyNode &lchild = vhierarchy_.node(node.lchild_handle()); VHierarchyNode &rchild = vhierarchy_.node(node.rchild_handle()); node.set_fund_lcut(fund_lcut_index); node.set_fund_rcut(fund_rcut_index); vertex_handle = mesh_.add_vertex(p); lchild.set_vertex_handle(vertex_handle); rchild.set_vertex_handle(node.vertex_handle()); index2handle_map[lchild.node_index()] = node.lchild_handle(); index2handle_map[rchild.node_index()] = node.rchild_handle(); // view-dependent parameters IO::restore(ifs, radius, swap); IO::restore(ifs, normal, swap); IO::restore(ifs, sin_square, swap); IO::restore(ifs, mue_square, swap); IO::restore(ifs, sigma_square, swap); lchild.set_radius(radius); lchild.set_normal(normal); lchild.set_sin_square(sin_square); lchild.set_mue_square(mue_square); lchild.set_sigma_square(sigma_square); avs.l_radius = radius; avs.l_normal = normal; avs.l_mue_square = mue_square; avs.l_sigma_square = sigma_square; avs.l_sin_square = sin_square; IO::restore(ifs, radius, swap); IO::restore(ifs, normal, swap); IO::restore(ifs, sin_square, swap); IO::restore(ifs, mue_square, swap); IO::restore(ifs, sigma_square, swap); rchild.set_radius(radius); rchild.set_normal(normal); rchild.set_sin_square(sin_square); rchild.set_mue_square(mue_square); rchild.set_sigma_square(sigma_square); avs.r_radius = radius; avs.r_normal = normal; avs.r_mue_square = mue_square; avs.r_sigma_square = sigma_square; avs.r_sin_square = sin_square; vsplit_loaded.push_back(avs); } ifs.close(); //refine 100 vsplits int cc = 0; for ( vfront_.begin(); !vfront_.end() && cc < 100; ++cc) { VHierarchyNodeHandle node_handle = vfront_.node_handle(); if (vhierarchy_.is_leaf_node(node_handle) != true) { force_vsplit(node_handle, vsplits_to_send); } vfront_.next(); std::cout << "vfront_ size " << vfront_.size() <<std::endl; } //**********// // update face and vertex normals mesh_.update_face_normals(); // bounding box VDPMMesh::ConstVertexIter vIt(mesh_.vertices_begin()), vEnd(mesh_.vertices_end()); VDPMMesh::Point bbMin, bbMax; bbMin = bbMax = mesh_.point(vIt); for (; vIt!=vEnd; ++vIt) { bbMin.minimize(mesh_.point(vIt)); bbMax.maximize(mesh_.point(vIt)); } // set center and radius VDPMMesh::Point center = 0.5f * (bbMin + bbMax); set_scene_pos(0.5f*(bbMin + bbMax), 0.5*(bbMin - bbMax).norm()); // info std::cerr << mesh_.n_vertices() << " vertices, " << mesh_.n_edges() << " edge, " << mesh_.n_faces() << " faces, " << n_details_ << " detail vertices\n"; mesh_loaded = true; }