void MakeTree(int FStart,int FEnd,int MStart,int MEnd,node &T) { T.d = FList[FStart]; bool Found = false; for(int i = MStart;i<= MEnd && !Found;i++) { if( FList[FStart] == MList[i]) { Found = true; if( i != MStart) { node *p = new node(); T.rChild = p; MakeTree(FStart+1,FStart+i-MStart,MStart,i-1,*(T.rChild)); } if( i != MEnd) { node *p = new node(); T.lChild = p; MakeTree(FStart+i-MStart+1,FEnd,i+1,MEnd,*(T.lChild)); } } } if(!Found) { cout<<"\n error"<<endl; } }
/* Build tree bottom-up */ static Node MakeTree(int iDepth) { if (iDepth<=0) { return leaf_Node(); } else { return make_Node(MakeTree(iDepth-1), MakeTree(iDepth-1)); } }
int main(int argc, char argv[]) { Node *root; int T; int N; scanf("%d ", &T); for (int test_case = 1; test_case <= T; test_case++) { scanf("%d ", &N); root = GetNode(); MakeTree(root, N); printf("# Preorder\n"); PreorderTraversal(root->left); putchar('\n'); printf("# Inorder\n"); InorderTraversal(root->left); putchar('\n'); printf("# Postorder\n"); PostorderTraversal(root->left); putchar('\n'); if (root != NULL) { DeleteNode(root); //DeleteAllNode(); } } return 0; }
static void TimeConstruction(int depth) { long tStart, tFinish; int iNumIters = NumIters(depth); Node tempTree; printf("Creating %d trees of depth %d\n", iNumIters, depth); tStart = currentTime(); for (int i = 0; i < iNumIters; ++i) { # ifndef GC tempTree = new Node0(); # else tempTree = new GC_NEW(Node0) Node0(); # endif Populate(depth, tempTree); # ifndef GC delete tempTree; # endif tempTree = 0; } tFinish = currentTime(); printf("\tTop down construction took %d msec\n", elapsedTime(tFinish - tStart)); tStart = currentTime(); for (int i = 0; i < iNumIters; ++i) { tempTree = MakeTree(depth); # ifndef GC delete tempTree; # endif tempTree = 0; } tFinish = currentTime(); printf("\tBottom up construction took %d msec\n", elapsedTime(tFinish - tStart)); }
/******************************************************** *! @brief 関数 - @param[out] - @param[in] - @par - @return - @note *********************************************************/ PRIVATE EVALUATE_TREE_T* CreateEvaluateTree( PLAYER_T CurrentPlayer ) { EVALUATE_TREE_T *pEvaluateTreeTop; EVALUATE_TABLE_T *pReversiTableTop; SIZE_T AllocateAreaSize; unsigned int Depth; /* Create Evaluate Table of Top Node */ pReversiTableTop = (EVALUATE_TABLE_T*)malloc( sizeof(EVALUATE_TABLE_T) ); AllocateAreaSize = sizeof( pReversiTableTop->aEvaluatReversiTable ); CopyCurrentReversiTable( pReversiTableTop->aEvaluatReversiTable, AllocateAreaSize ); /* Create Evaluate Tree Top Node */ pEvaluateTreeTop = (EVALUATE_TREE_T*)malloc( sizeof(EVALUATE_TREE_T) ); pEvaluateTreeTop->Depth = 0; pEvaluateTreeTop->NodeID = 0; pEvaluateTreeTop->DiscInfo.h = 0; pEvaluateTreeTop->DiscInfo.v = 0; pEvaluateTreeTop->DiscInfo.CurrentPlayer= TOGGLE_PLAYER( CurrentPlayer ); /* Currentは1手前の相手ターンの盤面 */ pEvaluateTreeTop->NumNextIndex = 0; pEvaluateTreeTop->pEvaluatReversiTable = pReversiTableTop; pEvaluateTreeTop->Score = CalcScore( pEvaluateTreeTop->DiscInfo.CurrentPlayer, pEvaluateTreeTop->pEvaluatReversiTable->aEvaluatReversiTable ); pEvaluateTreeTop->pNextNode = NULL; pEvaluateTreeTop->pNextDepthNode = NULL; /* Create Tree */ MakeTree( pEvaluateTreeTop ); return pEvaluateTreeTop; }
/** * Creates a tree tile * Ground type and density is preserved. * * @pre the tile must be suitable for trees. * * @param tile where to plant the trees. * @param treetype The type of the tree * @param count the number of trees (minus 1) * @param growth the growth status */ static void PlantTreesOnTile(TileIndex tile, TreeType treetype, uint count, uint growth) { assert(treetype != TREE_INVALID); assert(CanPlantTreesOnTile(tile, true)); TreeGround ground; uint density = 3; switch (GetTileType(tile)) { case MP_WATER: ground = TREE_GROUND_SHORE; break; case MP_CLEAR: switch (GetClearGround(tile)) { case CLEAR_GRASS: ground = TREE_GROUND_GRASS; break; case CLEAR_ROUGH: ground = TREE_GROUND_ROUGH; break; case CLEAR_SNOW: ground = GetRawClearGround(tile) == CLEAR_ROUGH ? TREE_GROUND_ROUGH_SNOW : TREE_GROUND_SNOW_DESERT; break; default: ground = TREE_GROUND_SNOW_DESERT; break; } if (GetClearGround(tile) != CLEAR_ROUGH) density = GetClearDensity(tile); break; default: NOT_REACHED(); } MakeTree(tile, treetype, count, growth, ground, density); }
void * FbMasterInfoBase::Execute(wxEvtHandler * owner, FbThread * thread, const FbFilterObj &filter) { if (thread->IsClosed()) return NULL; FbCommonDatabase database; database.JoinThread(thread); FbGenreFunction func_genre; FbAggregateFunction func_aggregate; database.CreateFunction(wxT("AGGREGATE"), 1, func_aggregate); database.CreateFunction(wxT("GENRE"), 1, func_genre); database.AttachConfig(); if (thread->IsClosed()) return NULL; wxString sql; switch (GetMode()) { case FB2_MODE_LIST: sql = GetListSQL(database); break; case FB2_MODE_TREE: sql = GetTreeSQL(database); break; } sql = FormatSQL(sql, GetWhere(database), filter); FbSQLite3Statement stmt = database.PrepareStatement(sql); Bind(stmt); FbSQLite3ResultSet result = stmt.ExecuteQuery(); if (!result.IsOk()) return NULL; switch (GetMode()) { case FB2_MODE_LIST: MakeList(owner, thread, result); break; case FB2_MODE_TREE: MakeTree(owner, thread, result); break; } return NULL; }
// Build tree bottom-up static Node MakeTree(int iDepth) { if (iDepth<=0) { # ifndef GC return new Node0(); # else return new (GC_NEW(Node0)) Node0(); # endif } else { # ifndef GC return new Node0(MakeTree(iDepth-1), MakeTree(iDepth-1)); # else return new (GC_NEW(Node0)) Node0(MakeTree(iDepth-1), MakeTree(iDepth-1)); # endif } }
int main() { int kase,i,n; Tsize=1;root=0; while(scanf("%d",&n)==1){ MakeTree(n);} PostOrder(root); // getchar();getchar(); return 0; }
void MakeTree(STreeNode &p,int i) { if( i< length) { p.node = CNodeList[i]; p.lChild = NULL; p.rChild = NULL; if(i*2+1<length) { STreeNode *r = new STreeNode(); p.rChild = r; MakeTree(*(p.rChild),i*2+1); } if(i*2+2 < length) { STreeNode *l = new STreeNode(); p.lChild = l; MakeTree(*(p.lChild),i*2+2); } } }
void main() { cout<<"Please enter the tree node list"<<endl; cin>> CNodeList; STreeNode Head ; STreeNode *p = NULL; length = strlen(CNodeList); MakeTree(Head,0); ShowTree(&Head); cout<<endl; cout<<"叶节点个数为 "<<count/2<<endl; }
hrf::ScoreAverager::IScorerVector TreeCreator::MakeTrees(int n) { assert(n >= 0); std::vector<std::unique_ptr<hrf::IScorer>>* raw_result = new std::vector<std::unique_ptr<hrf::IScorer>>; raw_result->reserve(n); for (int i=0; i<n; ++i) { raw_result->push_back(MakeTree()); } return std::unique_ptr<const std::vector<std::unique_ptr<hrf::IScorer>>>(raw_result); }
// Build tree bottom-up static Node MakeTree(int iDepth) { Node result; if (iDepth<=0) { # ifndef GC result = calloc(1, sizeof(Node0)); # else result = GC_NEW(Node0); HOLE(); # endif /* result is implicitly initialized in both cases. */ return result; } else { Node left = MakeTree(iDepth-1); Node right = MakeTree(iDepth-1); # ifndef GC result = malloc(sizeof(Node0)); # else result = GC_NEW(Node0); HOLE(); # endif init_Node(result, left, right); return result; } }
void Tree::MakeTree(Tree * node, const SuperCategoryParameter::TreeScheme * node_param){ if( node_param->children_size() == 0 ){ CHECK_NE(node_param->label(),-1); node->SetLabel(node_param->label()); } else { CHECK_EQ(node->label,-1); for(int i = 0; i < node_param->children_size(); ++i) { shared_ptr<Tree> child(new Tree()); node->InsertChild(child); MakeTree(child.get(), &node_param->children(i)); } } }
void main() { node Head; cout<<"请输入前序序列"<<endl; cin>>FList; cout<<"请输入中序序列"<<endl; cin>>MList; MakeTree(0,strlen(FList)-1,0,strlen(MList)-1,Head); cout<<"后序序列为"<<endl; BackOrder(&Head); cout<<"数有 "<<leaf(&Head)<<" 个叶子"<<endl; cout<<"数高 "<<Height(&Head,0)<<endl; }
main() { Node root; Node longLivedTree; Node tempTree; double *array; int i; int d; printf ("Garbage Collector Test\n"); printf (" Live storage will peak at %d bytes.\n\n", 2 * sizeof(struct Node0) * TreeSize(kLongLivedTreeDepth) + sizeof(double) * kArraySize); printf (" Stretching memory with a binary tree of depth %d\n", kStretchTreeDepth); PrintDiagnostics(); /* Stretch the memory space quickly */ tempTree = MakeTree(kStretchTreeDepth); free_Node(tempTree); tempTree = 0; /* Create a long lived object */ printf (" Creating a long-lived binary tree of depth %d\n", kLongLivedTreeDepth); longLivedTree = leaf_Node(); Populate(kLongLivedTreeDepth, longLivedTree); /* Create long-lived array, filling half of it */ printf (" Creating a long-lived array of %d doubles\n", kArraySize); array = (double *) malloc(kArraySize*sizeof(double)); for (i = 0; i < kArraySize/2; ++i) { array[i] = 1.0/i; /* sic */ } PrintDiagnostics(); for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) { TimeConstruction(d); } if (longLivedTree == 0 || array[1000] != 1.0/1000) printf ("Failed\n"); /* Fake reference to LongLivedTree */ /* and array */ /* to keep them from being optimized away */ PrintDiagnostics(); }
int main() { int i,j,temp; int *pscore; char namebuf[31],c; MakeTree(); pscore = searchscore("Li Ming"); for(i=0;i<nCourse;++i) { for(j=0;j<nStudent;++j) { scanf("%d",&temp); getchar(); gets(namebuf); *(searchscore(namebuf)) += temp; } rank = 1; nowscore = *pscore; PostOrder(root); printf("%d\n",rank); } return 0; }
void TreeCreator::MakeTreesParallelHelper(bkp::JobQueue<std::unique_ptr<MakeTreesJob>>& job_queue) { bool got_job; std::unique_ptr<MakeTreesJob> job; auto tied_result = std::tie(got_job, job); while (!job_queue.IsComplete()) { tied_result = job_queue.TryPopFront(); if (got_job) { auto iter = job->begin_; auto end = job->end_; while (iter != end) { *iter = MakeTree(); ++iter; } } } }
static void TimeConstruction(int depth) { long tStart, tFinish; int iNumIters = NumIters(depth); Node tempTree; int i; printf ("Creating %d trees of depth %d\n", iNumIters, depth); for (i = 0; i < iNumIters; ++i) { tempTree = leaf_Node(); Populate(depth, tempTree); free_Node(tempTree); tempTree = 0; } for (i = 0; i < iNumIters; ++i) { tempTree = MakeTree(depth); free_Node(tempTree); tempTree = 0; } }
static void TimeConstruction(int depth) { long tStart, tFinish; int iNumIters = NumIters(depth); Node tempTree; cout << "Creating " << iNumIters << " trees of depth " << depth << endl; tStart = currentTime(); for (int i = 0; i < iNumIters; ++i) { # ifndef GC tempTree = new Node0(); # else tempTree = new (GC_NEW(Node0)) Node0(); # endif Populate(depth, tempTree); # ifndef GC delete tempTree; # endif tempTree = 0; } tFinish = currentTime(); cout << "\tTop down construction took " << elapsedTime(tFinish - tStart) << " msec" << endl; tStart = currentTime(); for (int i = 0; i < iNumIters; ++i) { tempTree = MakeTree(depth); # ifndef GC delete tempTree; # endif tempTree = 0; } tFinish = currentTime(); cout << "\tBottom up construction took " << elapsedTime(tFinish - tStart) << " msec" << endl; }
int PCS_Model::SaveToPOF(std::string filename, AsyncProgress* progress) { PCS_Model::BSP_MAX_DEPTH = 0; PCS_Model::BSP_NODE_POLYS = 1; PCS_Model::BSP_TREE_TIME = 0; PCS_Model::BSP_COMPILE_ERROR = false; POF poffile; unsigned int i,j,k,l; progress->setTarget(6 + light_arrays.size() + ai_paths.size() + insignia.size() + shield_mesh.size() + thrusters.size() + docking.size() + turrets.size() + weapons.size() + special.size() + eyes.size() + model_info.size() + subobjects.size() + textures.size()); char cstringtemp[256]; // Update Progress progress->incrementWithMessage("Writing Header Pt1"); // --------- convert cross sections --------- std::vector<cross_section> sections; sections.resize(header.cross_sections.size()); for (i = 0; i < header.cross_sections.size(); i++) { sections[i].depth = header.cross_sections[i].depth; sections[i].radius = header.cross_sections[i].radius; } poffile.HDR2_Set_CrossSections(header.cross_sections.size(), sections); // Update Progress progress->incrementWithMessage("Writing Header Pt2"); // --------- ACEN --------- poffile.ACEN_Set_acen(POFTranslate(autocentering)); // Update Progress progress->incrementWithMessage("Writing Acen"); // --------- TXTR --------- // Update Progress progress->incrementWithMessage("Writing Textures"); for (i = 0; i < textures.size(); i++) poffile.TXTR_AddTexture(textures[i]); // --------- Sub object Consversion --------- wxLongLong time = wxGetLocalTimeMillis(); bool bsp_compiled = false; header.max_radius = 0.0f; for (i = 0; i < subobjects.size(); i++) { // Update Progress //if (subobjects[i].name == "debris08") // sprintf(cstringtemp, "Submodel %d: %s SENTINAL!", i, subobjects[i].name.c_str()); //else sprintf(cstringtemp, "Submodel %d: %s", i, subobjects[i].name.c_str()); progress->incrementWithMessage(cstringtemp); //memset((char *)&obj, 0, sizeof(OBJ2)); this is NO LONGER ALLOWED - obj2 now contains an class w/ vtable boost::scoped_ptr<OBJ2> obj(new OBJ2); obj->submodel_number = i; if (!PMFObj_to_POFObj2(i, *obj, bsp_compiled, header.max_radius)) { return 2; // error occured in bsp splitting! } poffile.OBJ2_Add(*obj); // takes over object management - including pointers } time = wxGetLocalTimeMillis() - time; // we succeeded in compiling - let's cache the result can_bsp_cache = true; bsp_cache.resize(subobjects.size()); for (i = 0; i < subobjects.size(); i++) poffile.OBJ2_Get_BSPData(i, bsp_cache[i].bsp_data); // --------- ---------------------- --------- int idx = GetModelInfoCount(); char cstrtmp[256]; wxString strtmp = PCS2_VERSION; sprintf(cstrtmp, "PMFSaveToPOF: Compiled on %s with %s\nmax BSP depth was %d\nmost polys in a single node was %d\nTotal Compile time was %ldms, tree generation time was %ldms", std::string(strtmp.mb_str()).c_str(), std::string(PCS2_COMP_VERSION.mb_str()).c_str(), PCS_Model::BSP_MAX_DEPTH,PCS_Model::BSP_NODE_POLYS, time.ToLong(), PCS_Model::BSP_TREE_TIME.ToLong()); bool found = false; for (i = 0; i < model_info.size() && !found; i++) { if (strstr(model_info[i].c_str(), "PMFSaveToPOF") != NULL) { found = true; if (bsp_compiled) // update the string model_info[i] = cstrtmp; } } if (!found) AddModelInfo(cstrtmp); j = 0; for (i = 0; i < model_info.size(); i++) j += model_info[i].length() + 1; boost::scoped_ptr<char> pinf(new char[j]); memset(pinf.get(), 0, j); j = 0; for (i = 0; i < model_info.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing String %d", i); progress->incrementWithMessage(cstringtemp); strncpy(pinf.get()+j, model_info[i].c_str(), model_info[i].length()); j+= model_info[i].length() + 1; } poffile.PINF_Set(pinf.get(), j); if (found) model_info.resize(idx); // back down to size // --------- EYE --------- for (i = 0; i < eyes.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Eye %d", i); progress->incrementWithMessage(cstringtemp); poffile.EYE_Add_Eye(eyes[i].sobj_number, POFTranslate(eyes[i].sobj_offset), POFTranslate(eyes[i].normal)); } // --------- SPCL --------- for (i = 0; i < special.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Special %d", i); progress->incrementWithMessage(cstringtemp); poffile.SPCL_AddSpecial(special[i].name, special[i].properties, POFTranslate(special[i].point), special[i].radius); } k = l = 0; // --------- weapons (GPNT/MPNT) --------- for (i = 0; i < weapons.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Weapon %d", i); progress->incrementWithMessage(cstringtemp); if (weapons[i].type == GUN) { poffile.GPNT_AddSlot(); for (j = 0; j < weapons[i].muzzles.size(); j++) { poffile.GPNT_AddPoint(k, POFTranslate(weapons[i].muzzles[j].point), POFTranslate(weapons[i].muzzles[j].norm)); } k++; } else { poffile.MPNT_AddSlot(); for (j = 0; j < weapons[i].muzzles.size(); j++) { poffile.MPNT_AddPoint(l, POFTranslate(weapons[i].muzzles[j].point), POFTranslate(weapons[i].muzzles[j].norm)); } l++; } } // --------- turrets TGUN/TMIS --------- k = l = 0; for (i = 0; i < turrets.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Turret %d", i); progress->incrementWithMessage(cstringtemp); if (turrets[i].type == GUN) { poffile.TGUN_Add_Bank(turrets[i].sobj_parent, turrets[i].sobj_par_phys, POFTranslate(turrets[i].turret_normal)); for (j = 0; j < turrets[i].fire_points.size(); j++) { poffile.TGUN_Add_FirePoint(k, POFTranslate(turrets[i].fire_points[j])); } k++; } else { poffile.TMIS_Add_Bank(turrets[i].sobj_parent, turrets[i].sobj_par_phys, POFTranslate(turrets[i].turret_normal)); for (j = 0; j < turrets[i].fire_points.size(); j++) { poffile.TMIS_Add_FirePoint(l, POFTranslate(turrets[i].fire_points[j])); } l++; } } // --------- docking --------- for (i = 0; i < docking.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Docking %d", i); progress->incrementWithMessage(cstringtemp); poffile.DOCK_Add_Dock(docking[i].properties); for (j = 0; j < docking[i].dockpoints.size(); j++) { poffile.DOCK_Add_Point(i, POFTranslate(docking[i].dockpoints[j].point), POFTranslate(docking[i].dockpoints[j].norm)); } for (j = 0; j < docking[i].paths.size(); j++) { poffile.DOCK_Add_SplinePath(i, docking[i].paths[j]); } } // --------- thrusters --------- for (i = 0; i < thrusters.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Thruster %d", i); progress->incrementWithMessage(cstringtemp); poffile.FUEL_Add_Thruster(thrusters[i].properties); for (j = 0; j < thrusters[i].points.size(); j++) { poffile.FUEL_Add_GlowPoint(i, thrusters[i].points[j].radius, POFTranslate(thrusters[i].points[j].pos), POFTranslate(thrusters[i].points[j].norm)); } } // --------- shield_mesh --------- int fcs[3], nbs[3]; std::vector<vector3d> points(shield_mesh.size()*3); vector3d shldtvect; // make points list l = 0; for (i = 0; i < shield_mesh.size(); i++) { for (j = 0; j < 3; j++) { bool found_corner = false; for (auto& p : points) { if (p == POFTranslate(shield_mesh[i].corners[j])) { found_corner = true; break; } } if (!found_corner) { if (l >= points.size()) points.resize(points.size()*2); points[l] = POFTranslate(shield_mesh[i].corners[j]); l++; } } } points.resize(l); // translate shield mesh for (i = 0; i < shield_mesh.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Shield Tri %d", i); progress->incrementWithMessage(cstringtemp); // adds points to list if need, determine fcs[] for (j = 0; j < 3; j++) { shldtvect = POFTranslate(shield_mesh[i].corners[j]); fcs[j] = FindInList(points, shldtvect); } // determine neighbors (nbs[]) j=0; for (k = 0; k < shield_mesh.size() && j < 3; k++) { if (Neighbor(shield_mesh[i], shield_mesh[k]) && i != k) { nbs[j] = k; j++; } } // add poffile.SHLD_Add_Face(POFTranslate(shield_mesh[i].face_normal), fcs, nbs); } // add points // Update Progress progress->incrementWithMessage("Writing Shield Points"); for (i = 0; i < points.size(); i++) poffile.SHLD_Add_Vertex(points[i]); progress->incrementWithMessage("Writing Shield Collision Tree"); // --------------- generate shield collision tree ---------------- if (poffile.SHLD_Count_Faces() > 0) { std::vector<pcs_polygon> shldmesh(poffile.SHLD_Count_Faces()); // make a pcs_polygon mesh from the shields for (i = 0; i < shldmesh.size(); i++) { shldmesh[i].verts.resize(3); poffile.SHLD_Get_Face(i, shldmesh[i].norm, fcs, nbs); for (j = 0; j < 3; j++) { poffile.SHLD_Get_Vertex(fcs[j], shldmesh[i].verts[j].point); shldmesh[i].verts[j].norm = shldmesh[i].norm; } shldmesh[i].centeroid = PolygonCenter(shldmesh[i]); } // make the tree vector3d smin, smax; std::unique_ptr<bsp_tree_node> shld_root = MakeTree(shldmesh, smax, smin); // pack the tree int sldc_size = CalcSLDCTreeSize(shld_root.get()); std::vector<char> sldc; sldc.resize(sldc_size); PackTreeInSLDC(shld_root.get(), 0, &sldc.front(), sldc_size); poffile.SLDC_SetTree(std::move(sldc)); // POFHandler will steal our copy of the buffer } // --------- insignia --------- vector3d uv, vv; float *u = (float *)&uv, *v = (float *)&vv; for (i = 0; i < insignia.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Insignia %d", i); progress->incrementWithMessage(cstringtemp); poffile.INSG_Add_insignia(insignia[i].lod, POFTranslate(insignia[i].offset)); for (j = 0; j < insignia[i].faces.size(); j++) { for (k = 0; k < 3; k++) { while ((l = poffile.INST_Find_Vert(i, POFTranslate(insignia[i].faces[j].verts[k]))) == (unsigned)-1) { poffile.INSG_Add_Insig_Vertex(i, POFTranslate(insignia[i].faces[j].verts[k])); } fcs[k] = l; u[k] = insignia[i].faces[j].u[k]; v[k] = insignia[i].faces[j].v[k]; } poffile.INSG_Add_Insig_Face(i, fcs, uv, vv); } } // --------- ai_paths --------- for (i = 0; i < ai_paths.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Path %d", i); progress->incrementWithMessage(cstringtemp); poffile.PATH_Add_Path(ai_paths[i].name, ai_paths[i].parent); for (j = 0; j < ai_paths[i].verts.size(); j++) { poffile.PATH_Add_Vert(i, POFTranslate(ai_paths[i].verts[j].pos), ai_paths[i].verts[j].radius); } } // --------- light arrays --------- pcs_glow_array *gla; for (i = 0; i < light_arrays.size(); i++) { // Update Progress sprintf(cstringtemp, "Writing Glow %d", i); progress->incrementWithMessage(cstringtemp); gla = &light_arrays[i]; poffile.GLOW_Add_LightGroup(gla->disp_time, gla->on_time, gla->off_time, gla->obj_parent, gla->LOD, gla->type, gla->properties); for (j = 0; j < gla->lights.size(); j++) { poffile.GLOW_Add_GlowPoint(i, gla->lights[j].radius, POFTranslate(gla->lights[j].pos), POFTranslate(gla->lights[j].norm)); } } // --------- HDR2 --------- // let's make new BBoxes based on the subobjects vector3d minbox, maxbox, tmpmin, tmpmax; poffile.OBJ2_Get_BoundingMax(0, maxbox); poffile.OBJ2_Get_BoundingMin(0, minbox); for (i = 1; i < poffile.OBJ2_Count(); i++) { vector3d sobj_offset(POFTranslate(OffsetFromParent(i))); poffile.OBJ2_Get_BoundingMax(i, tmpmax); poffile.OBJ2_Get_BoundingMin(i, tmpmin); ExpandBoundingBoxes(maxbox, minbox, tmpmax + sobj_offset); ExpandBoundingBoxes(maxbox, minbox, tmpmin + sobj_offset); } for (i = 0; i < poffile.SHLD_Count_Vertices(); i++) { poffile.SHLD_Get_Vertex(i, tmpmax); ExpandBoundingBoxes(maxbox, minbox, tmpmax); } // update our bounding boxes //axis doesn't matter on the bounding boxes - it's all negative/positive values! i'm a faqing moron poffile.HDR2_Set_MinBound(header.min_bounding_overridden ? header.min_bounding_override : minbox); poffile.HDR2_Set_MaxBound(header.max_bounding_overridden ? header.max_bounding_override : maxbox); this->header.max_bounding = minbox; this->header.min_bounding = maxbox; poffile.HDR2_Set_MaxRadius(header.max_radius_overridden ? header.max_radius_override : header.max_radius); poffile.HDR2_Set_Details(header.detail_levels.size(), header.detail_levels); poffile.HDR2_Set_Debris(header.debris_pieces.size(), header.debris_pieces); poffile.HDR2_Set_Mass(header.mass); poffile.HDR2_Set_MassCenter(POFTranslate(header.mass_center)); poffile.HDR2_Set_MomentInertia(header.MOI); poffile.HDR2_Set_SOBJCount(GetSOBJCount()); std::ofstream out(filename.c_str(), std::ios::out | std::ios::binary); if (!poffile.SavePOF(out)) return 1; return 0; }
QuadTree MakeTree(int size, int center_x, int center_y, int lo_proc, int hi_proc, QuadTree parent, ChildType ct, int level) { int intersect=0; QuadTree retval; #ifdef FUTURES retval = (QuadTree) ALLOC(lo_proc,sizeof(*retval)); #else retval = (QuadTree) mymalloc(sizeof(*retval)); #endif retval->parent = parent; retval->childtype = ct; intersect = CheckIntersect(center_x,center_y,size); size = size/2; if ((intersect==0) && (size<512)) { retval->color = white; retval->nw = NULL; retval->ne = NULL; retval->sw = NULL; retval->se = NULL; } else if (intersect==2) { retval->color=black; retval->nw = NULL; retval->ne = NULL; retval->sw = NULL; retval->se = NULL; } else { if (!level) { retval->color = black; retval->nw = NULL; retval->ne = NULL; retval->sw = NULL; retval->se = NULL; } else { int mid1,mid2; #ifdef FUTURES future_cell_int fc_sw,fc_se,fc_ne; #endif mid1 = (lo_proc+hi_proc)/2; mid2 = (lo_proc+hi_proc+1)/2; #ifndef FUTURES retval->sw = MakeTree(size,center_x-size,center_y-size, (mid2+hi_proc+1)/2,hi_proc,retval, southwest,level-1); retval->se = MakeTree(size,center_x+size,center_y-size, mid2,(mid2+hi_proc)/2,retval, southeast,level-1); retval->ne = MakeTree(size,center_x+size,center_y+size, (lo_proc+mid1+1)/2,mid1,retval, northeast,level-1); retval->nw = MakeTree(size,center_x-size,center_y+size, lo_proc,(lo_proc+mid1)/2,retval, northwest,level-1); #else FUTURE(size,center_x-size,center_y-size, (mid2+hi_proc+1)/2,hi_proc,retval, southwest,level-1,MakeTree,&fc_sw); FUTURE(size,center_x+size,center_y-size, mid2,(mid2+hi_proc)/2,retval, southeast,level-1,MakeTree,&fc_se); FUTURE(size,center_x+size,center_y+size, (lo_proc+mid1+1)/2,mid1,retval, northeast,level-1,MakeTree,&fc_ne); retval->nw = MakeTree(size,center_x-size,center_y+size, lo_proc,(lo_proc+mid1)/2,retval, northwest,level-1); TOUCH(&fc_sw); retval->sw = (QuadTree) fc_sw.value; TOUCH(&fc_se); retval->se = (QuadTree) fc_se.value; TOUCH(&fc_ne); retval->ne = (QuadTree) fc_ne.value; #endif retval->color = grey; } } return retval; }
/******************************************************** *! @brief 関数 - @param[out] - @param[in] - @par - @return - @note *********************************************************/ PRIVATE void MakeTree( EVALUATE_TREE_T *pCurrentNode ) { int h, v; DISC_INFO_T DiscInfo; ERROR_CHECK Result; EVALUATE_TREE_T *pNextDepthNode; EVALUATE_TREE_T *pNextNode; if ( pCurrentNode->Depth <= DEPTH_MAX ) { #ifdef DEBUG_MAKE_NODE printf("\nDepth = %d, NodeID = %d, CurrentPlayer = %d, Pos = [%d, %d], Score = %d" ,pCurrentNode->Depth ,pCurrentNode->NodeID ,pCurrentNode->DiscInfo.CurrentPlayer ,pCurrentNode->DiscInfo.h ,pCurrentNode->DiscInfo.v/COEF_LINE ,pCurrentNode->Score ); PrintReversiTable( pCurrentNode->pEvaluatReversiTable->aEvaluatReversiTable ); #endif /* 有効な位置を探す */ for ( v=REALV(1); v < VERTICAL_NUM; v=v+REALV(1) ) { for ( h=REALH(1); h < HORIZON_NUM; h=h+REALH(1) ) { DiscInfo.h = h; DiscInfo.v = v; DiscInfo.CurrentPlayer = TOGGLE_PLAYER( pCurrentNode->DiscInfo.CurrentPlayer ); Result = CheckInputPos( &DiscInfo, pCurrentNode->pEvaluatReversiTable->aEvaluatReversiTable, FALSE ); /* 有効な位置を見つけたら新しいノードを生成する */ if ( Result == SUCCESS ) { if ( pCurrentNode->NumNextIndex == 0 ) { /* 1つでも有効な位置が見つかったら次の深さのノードを生成する */ /* Tableへのポインタは生成し終わったら消滅して欲しいのでスコープは必要最低限に限定する */ EVALUATE_TABLE_T *pNextDepthTable; /* Create Evaluate Table of Next Depth Node */ pNextDepthTable = (EVALUATE_TABLE_T*)malloc( sizeof(EVALUATE_TABLE_T) ); memcpy( pNextDepthTable, pCurrentNode->pEvaluatReversiTable, sizeof(EVALUATE_TABLE_T) ); /* CurrentノードのTableをコピーする */ ReversingDisc( DiscInfo, pNextDepthTable->aEvaluatReversiTable ); /* コピーしたTableで石をひっくり返す */ /* Create Evaluate Tree Next Depth Node */ pCurrentNode->pNextDepthNode = (EVALUATE_TREE_T*)malloc( sizeof(EVALUATE_TREE_T) ); pNextDepthNode = pCurrentNode->pNextDepthNode; /* 確保した領域にポインタを繋ぐ */ pNextDepthNode->Depth = pCurrentNode->Depth + 1; pNextDepthNode->NodeID = pCurrentNode->NumNextIndex; pNextDepthNode->DiscInfo.h = DiscInfo.h; pNextDepthNode->DiscInfo.v = DiscInfo.v; pNextDepthNode->DiscInfo.CurrentPlayer = DiscInfo.CurrentPlayer; pNextDepthNode->pEvaluatReversiTable = pNextDepthTable; pNextDepthNode->Score = CalcScore( pNextDepthNode->DiscInfo.CurrentPlayer, pNextDepthNode->pEvaluatReversiTable->aEvaluatReversiTable ); pNextDepthNode->pNextNode = NULL; pNextDepthNode->pNextDepthNode = NULL; /* Create Evaluate Tree Next Next Depth Node */ MakeTree( pNextDepthNode ); /* 探索深度限界判定 */ if ( pNextDepthNode != NULL ) { /* NextDepthがまだ探索深度限界に達していない */ pNextNode = pNextDepthNode->pNextNode; /* 以後、新しい選択肢が見つかったらNextNodeに新規Nodeを追加していく */ } else { /* NextDepthが探索深度限界に達していた */ return; /* 深度限界なので他の選択肢を探る必要なし */ } } else { /* 次の選択肢が見つかったらノードを生成する */ /* Tableへのポインタは生成し終わったら消滅して欲しいのでスコープは必要最低限に限定する */ EVALUATE_TABLE_T *pNextTable; /* Create Evaluate Table of Next Node */ pNextTable = (EVALUATE_TABLE_T*)malloc( sizeof(EVALUATE_TABLE_T) ); memcpy( pNextTable, pCurrentNode->pEvaluatReversiTable, sizeof(EVALUATE_TABLE_T) ); /* CurrentノードのTableをコピーする */ ReversingDisc( DiscInfo, pNextTable->aEvaluatReversiTable ); /* コピーしたTableで石をひっくり返す */ /* Create Evaluate Tree Next Node */ pNextNode = (EVALUATE_TREE_T*)malloc( sizeof(EVALUATE_TREE_T) ); pNextNode->Depth = pCurrentNode->pNextDepthNode->Depth; pNextNode->NodeID = pCurrentNode->NumNextIndex; pNextNode->DiscInfo.h = DiscInfo.h; pNextNode->DiscInfo.v = DiscInfo.v; pNextNode->DiscInfo.CurrentPlayer = DiscInfo.CurrentPlayer; pNextNode->pEvaluatReversiTable = pNextTable; pNextNode->Score = CalcScore( pNextNode->DiscInfo.CurrentPlayer, pNextNode->pEvaluatReversiTable->aEvaluatReversiTable ); pNextNode->pNextNode = NULL; pNextNode->pNextDepthNode = NULL; /* Create Evaluate Tree Next Depth Next Node */ MakeTree( pNextNode ); /* pNextNodeに今回生成したNodeのNextNodeアドレスを入れておく * 新しい選択肢が見つかったらpNextNodeに追加していく */ pNextNode = pNextNode->pNextNode; } pCurrentNode->NumNextIndex++; /* 有効な選択肢が見つかったら次の深さのノード数をインクリメントする */ } } } } else { /* 評価木の深度が限界に達したので、確保した領域を解放してTree生成終了 */ FREE( pCurrentNode->pEvaluatReversiTable ); FREE( pCurrentNode ); return; } #ifdef DEBUG_MAKE_NODE printf("\n [Depth = %d] NumNextIndex = %d" ,pCurrentNode->Depth ,pCurrentNode->NumNextIndex ); #endif return; }
LRESULT CSideBar::OnFocusGraph(WPARAM wParam, LPARAM lParam) { /* if (m_linelayer_chooser) { if (lParam == 9) { m_linelayer_chooser->DestroyWindow(); delete m_linelayer_chooser; m_linelayer_chooser = NULL; } else { m_linelayer_chooser->PostMessage(WM_DMP_FOCUS_GRAPH, wParam, lParam); } } */ // Replacement for m_linelayer_chooser is my tree ctrl: CTreeCtrl& tree = GetTreeCtrl(); CListCtrl& list = GetListCtrl(); if (::IsWindow(tree.m_hWnd)) { CGraphDoc *pDoc = (CGraphDoc *) wParam; if (lParam == CGraphDoc::CONTROLS_DESTROYALL && pDoc == m_treeDoc) { // Lost graph m_topgraph = NULL; m_backgraph = NULL; tree.DeleteAllItems(); list.DeleteAllItems(); list.SetColumnWidth(0,0); m_treeDoc = NULL; } else if (lParam == CGraphDoc::CONTROLS_LOADALL && pDoc != m_treeDoc) { // [Possible] change of window (sent on focus) m_treeDoc = pDoc; m_topgraph = NULL; m_backgraph = NULL; MakeTree(); } else if (lParam == CGraphDoc::CONTROLS_LOADGRAPH && pDoc == m_treeDoc) { // Force update if match current window m_topgraph = NULL; m_backgraph = NULL; MakeGraphTree(); // also make drawing tree as this overrides layer visible status sometimes: MakeDrawingTree(); } else if (lParam == CGraphDoc::CONTROLS_RELOADGRAPH && pDoc == m_treeDoc) { // Force reload of graph tree if match current window m_topgraph = NULL; m_backgraph = NULL; ClearGraphTree(); MakeGraphTree(); } else if (lParam == CGraphDoc::CONTROLS_LOADDRAWING && pDoc == m_treeDoc) { // Force update if match current window MakeDrawingTree(); } else if (lParam == CGraphDoc::CONTROLS_LOADATTRIBUTES && pDoc == m_treeDoc) { // Force update if match current window MakeAttributeList(); } else if (lParam == CGraphDoc::CONTROLS_CHANGEATTRIBUTE && pDoc == m_treeDoc) { // Force update if match current window SetAttributeChecks(); } else if (lParam == CGraphDoc::CONTROLS_LOADCONVERT && pDoc == m_treeDoc) { m_topgraph = NULL; m_backgraph = NULL; MakeGraphTree(); // conversions typically turn off drawing layers: SetDrawingTreeChecks(); } if (m_treeDoc == NULL) { tree.EnableWindow(FALSE); // Stop some strange auto scroll property: SetTreeStyle(TVS_NOSCROLL, TRUE); } else { tree.EnableWindow(TRUE); // Stop some strange auto scroll property: SetTreeStyle(TVS_NOSCROLL, FALSE); } } return 0; }
int main() { Node root; Node longLivedTree; Node tempTree; long tStart, tFinish; long tElapsed; int i, d; double *array; #ifdef GC // GC_full_freq = 30; // GC_free_space_divisor = 16; // GC_enable_incremental(); #endif printf("Garbage Collector Test\n"); printf(" Live storage will peak at %d bytes.\n\n", 2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) + sizeof(double) * kArraySize); printf(" Stretching memory with a binary tree of depth %d\n", kStretchTreeDepth); PrintDiagnostics(); # ifdef PROFIL init_profiling(); # endif tStart = currentTime(); // Stretch the memory space quickly tempTree = MakeTree(kStretchTreeDepth); # ifndef GC destroy_Node(tempTree); # endif tempTree = 0; // Create a long lived object printf(" Creating a long-lived binary tree of depth %d\n", kLongLivedTreeDepth); # ifndef GC longLivedTree = calloc(1, sizeof(Node0)); # else longLivedTree = GC_NEW(Node0); # endif Populate(kLongLivedTreeDepth, longLivedTree); ggggc_collectFull(); // Create long-lived array, filling half of it printf(" Creating a long-lived array of %d doubles\n", kArraySize); # ifndef GC array = malloc(kArraySize * sizeof(double)); # else # ifndef NO_PTRFREE array = GC_MALLOC_ATOMIC(sizeof(double) * kArraySize); # else array = GC_MALLOC(sizeof(double) * kArraySize); # endif # endif ggggc_collectFull(); for (i = 0; i < kArraySize/2; ++i) { array[i] = 1.0/i; } PrintDiagnostics(); for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) { TimeConstruction(d); } if (longLivedTree == 0 || array[1000] != 1.0/1000) fprintf(stderr, "Failed\n"); // fake reference to LongLivedTree // and array // to keep them from being optimized away tFinish = currentTime(); tElapsed = elapsedTime(tFinish-tStart); PrintDiagnostics(); printf("Completed in %d msec\n", tElapsed); # ifdef GC printf("Completed %d collections\n", GC_gc_no); printf("Heap size is %d\n", GC_get_heap_size()); # endif # ifdef PROFIL dump_profile(); # endif }
void main() { Node root; Node longLivedTree; Node tempTree; long tStart, tFinish; long tElapsed; #ifdef GC // GC_full_freq = 30; GC_enable_incremental(); #endif cout << "Garbage Collector Test" << endl; cout << " Live storage will peak at " << 2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) + sizeof(double) * kArraySize << " bytes." << endl << endl; cout << " Stretching memory with a binary tree of depth " << kStretchTreeDepth << endl; PrintDiagnostics(); tStart = currentTime(); // Stretch the memory space quickly tempTree = MakeTree(kStretchTreeDepth); # ifndef GC delete tempTree; # endif tempTree = 0; // Create a long lived object cout << " Creating a long-lived binary tree of depth " << kLongLivedTreeDepth << endl; # ifndef GC longLivedTree = new Node0(); # else longLivedTree = new (GC_NEW(Node0)) Node0(); # endif Populate(kLongLivedTreeDepth, longLivedTree); // Create long-lived array, filling half of it cout << " Creating a long-lived array of " << kArraySize << " doubles" << endl; # ifndef GC double *array = new double[kArraySize]; # else double *array = (double *) GC_MALLOC_ATOMIC(sizeof(double) * kArraySize); # endif for (int i = 0; i < kArraySize/2; ++i) { array[i] = 1.0/i; } PrintDiagnostics(); for (int d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) { TimeConstruction(d); } if (longLivedTree == 0 || array[1000] != 1.0/1000) cout << "Failed" << endl; // fake reference to LongLivedTree // and array // to keep them from being optimized away tFinish = currentTime(); tElapsed = elapsedTime(tFinish-tStart); PrintDiagnostics(); cout << "Completed in " << tElapsed << " msec" << endl; # ifdef GC cout << "Completed " << GC_gc_no << " collections" <<endl; cout << "Heap size is " << GC_get_heap_size() << endl; # endif }
bool PCS_Model::PMFObj_to_POFObj2(int src_num, OBJ2 &dst, bool &bsp_compiled, float& model_radius) { pcs_sobj &src = subobjects[src_num]; dst.submodel_parent = src.parent_sobj; dst.offset = POFTranslate(src.offset); dst.geometric_center = POFTranslate(src.geometric_center); dst.submodel_name = APStoString(src.name); dst.properties = APStoString(src.properties); switch (src.movement_type) { case ROTATE: dst.movement_type = 1; break; default: dst.movement_type = -1; } switch (src.movement_axis) { case MV_X: dst.movement_axis = 0; break; case MV_Z: dst.movement_axis = 1; break; case MV_Y: dst.movement_axis = 2; break; default: dst.movement_axis = -1; } dst.reserved = 0; if(!can_bsp_cache || bsp_cache[src_num].changed) { // convert them to POF axis std::vector<pcs_polygon> clean_list = src.polygons; for (size_t i = 0; i < clean_list.size(); i++) { clean_list[i].norm = POFTranslate(clean_list[i].norm); for (size_t j = 0; j < clean_list[i].verts.size(); j++) { clean_list[i].verts[j].point = POFTranslate(clean_list[i].verts[j].point); clean_list[i].verts[j].norm = POFTranslate(clean_list[i].verts[j].norm); } clean_list[i].centeroid = PolygonCenter(clean_list[i]); } // BSP Compilation! // assemble points list std::vector<bsp_vert> points_list; std::vector<vector3d> pnts; std::unordered_map<vector3d, int> point_to_index; std::unordered_map<vector3d, int> normal_to_index; for (size_t i = 0; i < pnts.size(); i++) { point_to_index.insert(std::make_pair(pnts[i], i)); } bsp_vert temp; points_list.reserve(clean_list.size()); for (size_t i = 0; i < clean_list.size(); i++) { for (size_t j = 0; j < clean_list[i].verts.size(); j++) { auto point = point_to_index.find(clean_list[i].verts[j].point); if (point == point_to_index.end()) { point_to_index.insert(std::make_pair(clean_list[i].verts[j].point, points_list.size())); points_list.emplace_back(); points_list.back().point = clean_list[i].verts[j].point; pnts.push_back(points_list.back().point); } auto normal = normal_to_index.find(clean_list[i].verts[j].norm); if (normal == normal_to_index.end()) { points_list[normal_to_index.size() / 128].norms.push_back(clean_list[i].verts[j].norm); normal_to_index.insert(std::make_pair(clean_list[i].verts[j].norm, normal_to_index.size())); } } } // create our defpoints BSP_DefPoints points; MakeDefPoints(points, points_list); vector3d AvgNormal; // create tree std::unique_ptr<bsp_tree_node> root = MakeTree(clean_list, dst.bounding_box_max_point, dst.bounding_box_min_point); // allocate buffer and write the defpoints dst.bsp_data.resize(points.head.size + CalculateTreeSize(root.get(), clean_list)); if (points.Write(&dst.bsp_data.front()) != points.head.size) return false; // calculation error //std::ofstream bsp_debug("c:\\bsp.txt"); //DebugPrintTree(root, bsp_debug); // pack the tree int error_flags = 0; PackTreeInBSP(root.get(), points.head.size, &dst.bsp_data.front(), clean_list, normal_to_index, point_to_index, points, dst.geometric_center, dst.bsp_data.size(), error_flags); // we got errors! if (error_flags != BSP_NOERRORS) return false; // update the bsp_compiled to be true bsp_compiled = true; // update the BSP cache with the new result if (can_bsp_cache) { // clear the saved - stale cache bsp_cache[src_num].decache(); bsp_cache[src_num].bsp_data = dst.bsp_data; bsp_cache[src_num].changed = false; } } else // Used cached copy! { dst.bsp_data = bsp_cache[src_num].bsp_data; } dst.radius = 0.0f; dst.bounding_box_max_point = vector3d(FLT_MIN, FLT_MIN, FLT_MIN); dst.bounding_box_min_point = vector3d(FLT_MAX, FLT_MAX, FLT_MAX); vector3d global_offset(OffsetFromParent(src_num)); for(unsigned int i = 0; i<src.polygons.size(); i++){ for(unsigned int j = 0; j<src.polygons[i].verts.size(); j++){ ExpandBoundingBoxes(dst.bounding_box_max_point, dst.bounding_box_min_point, src.polygons[i].verts[j].point); float norm = Magnitude(src.polygons[i].verts[j].point); if (norm > dst.radius) { dst.radius = norm; } float global_norm = Magnitude(src.polygons[i].verts[j].point + global_offset); if (global_norm > model_radius) { model_radius = global_norm; } } } if (dst.radius == 0.0f) { dst.bounding_box_max_point = vector3d(); dst.bounding_box_min_point = vector3d(); } if (src.radius_overridden) { dst.radius = src.radius_override; } if (src.bounding_box_min_point_overridden) { dst.bounding_box_min_point = src.bounding_box_min_point_override; } if (src.bounding_box_max_point_overridden) { dst.bounding_box_max_point = src.bounding_box_max_point_override; } POFTranslateBoundingBoxes(dst.bounding_box_min_point, dst.bounding_box_max_point); return true; }