?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix game:addSpawnShapesByZone
[ryzomcore.git] / nel / tools / 3d / zone_welder / zone_welder.cpp
blobe33dd6862f7263f228436971b469832592f3041a
1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This source file has been modified by the following contributors:
5 // Copyright (C) 2019 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
6 //
7 // This program is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU Affero General Public License as
9 // published by the Free Software Foundation, either version 3 of the
10 // License, or (at your option) any later version.
11 //
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU Affero General Public License for more details.
16 //
17 // You should have received a copy of the GNU Affero General Public License
18 // along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20
21 #include "../zone_lib/zone_utility.h"
22
23 #include <iostream>
24 #include <sstream>
25 #include <vector>
26 #include <set>
27
28 #include "nel/misc/types_nl.h"
29 #include "nel/misc/file.h"
30 #include "nel/misc/common.h"
31 #include "nel/3d/quad_tree.h"
32 #include "nel/3d/zone.h"
33 #include "nel/3d/landscape.h"
34 #include "nel/3d/zone_smoother.h"
35 #include "nel/3d/zone_tgt_smoother.h"
36 #include "nel/3d/zone_corner_smoother.h"
37
38
39 using namespace NL3D;
40 using namespace NLMISC;
41 using namespace std;
42
43
44 #define WELD_LOG 1
45
46 FILE *fdbg;
47
48 std::string inputDir;
49 std::string inputExt;
50 std::string outputDir;
51 std::string outputExt;
52
53 float weldRadius = 1.1f;
54
55 /* Zone ID
56 0 1 2
57 3 4
58 5 6 7
59 */
60
61 // Define this to stop the welder on a source edge
62 // #define NL_DEBUG_WELD
63 #define NL_DEBUG_WELD_V0 (CVector(16320,-24064,0))
64 #define NL_DEBUG_WELD_V1 (CVector(16352,-24065,0))
65 #define NL_DEBUG_WELD_THRESHOLD 1.f
66
67 #ifdef NL_DEBUG_WELD
68 bool isTheSame (const CVector &v0, const CVector &v1)
69 {
70 CVector delta = v0 - v1;
71 delta.z = 0;
72 return delta.norm() < NL_DEBUG_WELD_THRESHOLD;
73 }
74 #endif // NL_DEBUG_WELD
75
76 /**
77 * CWeldableVertexInfos
78 */
79 struct CWeldableVertexInfos
80 {
81 uint16 IndexInZone; // base vertex
82 sint PatchIndex; // patch
83 uint8 PatchVertex; // 0,1,2,3
84
85 CWeldableVertexInfos()
86 {
87 IndexInZone = 0;
88 PatchIndex = 0;
89 PatchVertex = 0;
90 }
91
92 bool operator< (const CWeldableVertexInfos& wvinf) const
93 {
94 if(IndexInZone<wvinf.IndexInZone)
95 return true;
96 if(IndexInZone>wvinf.IndexInZone)
97 return false;
98 if(PatchIndex<wvinf.PatchIndex)
99 return true;
100 if(PatchIndex>wvinf.PatchIndex)
101 return false;
102 return PatchVertex<wvinf.PatchVertex;
103 }
104 };
105
106
107 struct CVectorInfluence
108 {
109 CVector Vertex;
110 float Inf;
111 bool OnBorder;
112 };
113
114
115 struct CAdjacentVertex
116 {
117 CVector Vertex;
118 uint IdOnCenterZone;
119 bool OnBorder;
120 };
121
122
123 /*******************************************************************\
124 writeInstructions()
125 \*******************************************************************/
126 void writeInstructions()
127 {
128 printf("zone_welder <input.zone><output.zone>[<weld threshold>]\n");
129 printf("\t/? for this help\n");
130 }
131
132
133 /*******************************************************************\
134 findPatchIndex()
135 \*******************************************************************/
136 bool getPatchAndEdge(const std::vector<CPatchInfo>& patchs,
137 uint16 baseVertex1, uint16 baseVertex2,
138 uint16& patchIndex,
139 uint8& edgeIndex)
140 {
141 uint ptch;
142
143 for(ptch=0; ptch<patchs.size(); ptch++)
144 {
145 uint i;
146 for(i=0; i<4; i++)
147 {
148 if(patchs[ptch].BaseVertices[i] == baseVertex1)
149 {
150 #if WELD_LOG
151 fprintf(fdbg,"patch %d continent bv %d : %d %d %d %d\n",
152 ptch,
153 baseVertex1,
154 patchs[ptch].BaseVertices[0],
155 patchs[ptch].BaseVertices[1],
156 patchs[ptch].BaseVertices[2],
157 patchs[ptch].BaseVertices[3]);
158 #endif
159
160 if(patchs[ptch].BaseVertices[(i+1)%4] == baseVertex2)
161 {
162 edgeIndex = i;
163 patchIndex = ptch;
164 return true;
165 }
166 if(patchs[ptch].BaseVertices[(i-1)%4] == baseVertex2)
167 {
168 edgeIndex = (i-1)%4;
169 patchIndex = ptch;
170 return true;
171 }
172 }
173 }
174 }
175 return false;
176 }
177
178 void CleanZone ( std::vector<CPatchInfo> &zoneInfos, uint zoneId, const CAABBoxExt &zoneBBox, float weldThreshold);
179
180 /*******************************************************************\
181 weldZones()
182 \*******************************************************************/
183 void weldZones(const char *center)
184 {
185 uint i,j;
186
187 // load zone in the center
188 CIFile zoneFile(inputDir+center+inputExt);
189 CZone zone;
190 zone.serial(zoneFile);
191 zoneFile.close();
192
193 // retrieving infos from the center zone
194 uint16 centerZoneId = zone.getZoneId();
195 std::vector<CPatchInfo> centerZonePatchs;
196 std::vector<CBorderVertex> centerZoneBorderVertices;
197 zone.retrieve(centerZonePatchs, centerZoneBorderVertices);
198
199 std::vector<CPatchInfo>::iterator itptch;
200 std::vector<CBorderVertex>::iterator itbv;
201
202 // if no id yet, we add a correct id
203 if(centerZoneId==0)
204 {
205 centerZoneId = createZoneId(center);
206
207 // edge neighbour : current zone
208 for(itptch = centerZonePatchs.begin(); itptch!=centerZonePatchs.end(); itptch++)
209 {
210 for(j=0; j<4; j++)
211 {
212 (*itptch).BindEdges[j].ZoneId = centerZoneId;
213 }
214 }
215
216 // border vertices neighbour : current zone
217 for(itbv = centerZoneBorderVertices.begin(); itbv<centerZoneBorderVertices.end(); itbv++)
218 {
219 (*itbv).NeighborZoneId = centerZoneId;
220 }
221
222 }
223 #if WELD_LOG
224 fprintf(fdbg,"id(center) = %d\n",centerZoneId);
225 #endif
226
227 // *** Clean internal zone
228 // * Bind 1-1 1-2 1-4 internal patches that are not binded
229 // * Make a global welded on vertices
230 // * Force tangents position
231 CleanZone ( centerZonePatchs, centerZoneId, zone.getZoneBB(), weldRadius);
232
233 // Yoyo was here: Smooth the tangents of the zone.
234 //================================================
235 // NB: do it only for edges sharing 2 patchs of centerZone. (don't care adjacent zones).
236 // smoothing with adjacent zones is done with a better smoothing tool: CZoneTgtSmoother, see below,
237 // after the weld of the zone.
238 {
239 CZoneSmoother zonesmoother;
240 CZoneSmoother::CZoneInfo smoothZones[5];
241 smoothZones[0].ZoneId= centerZoneId;
242 smoothZones[0].Patchs= &centerZonePatchs;
243 // 30deg ???
244 zonesmoother.smoothTangents(smoothZones, (float)(Pi/6));
245 }
246
247
248
249 // load 8 adjacent adjZones
250 bool adjZoneFileFound[8];
251 CZone adjZones[8];
252 CZoneInfo adjZoneInfos[8];
253 uint16 adjZonesId[8];
254 std::vector<std::string> adjZonesName;
255 getAdjacentZonesName(center, adjZonesName);
256 for(i=0; i<8; i++)
257 {
258 if(adjZonesName[i]=="empty") continue;
259
260 adjZoneFileFound[i] = true;
261 CIFile f;
262 try
263 {
264 std::string ss(outputDir+adjZonesName[i]+outputExt);
265 if (f.open(ss))
266 {
267 printf("reading file %s\n", ss.c_str());
268 adjZones[i].serial(f);
269 adjZones[i].retrieve(adjZoneInfos[i].Patchs, adjZoneInfos[i].BorderVertices);
270 adjZoneInfos[i].ZoneId= adjZonesId[i] = adjZones[i].getZoneId();
271 f.close();
272 }
273 else
274 {
275 // nlwarning ("WARNING File not found: %s\n", ss.c_str());
276 adjZonesName[i]="empty";
277 }
278 }
279 catch(const exception &e)
280 {
281 nlwarning ("ERROR %s\n", e.what ());
282 adjZoneFileFound[i] = false;
283 }
284 }
285
286 // QuadTree for storing adjZones points
287 CQuadTree<CWeldableVertexInfos> quadTrees[8];
288
289 // new base, to change from XZ to XY (Nel speaking)
290 CMatrix base;
291 CVector I(1,0,0);
292 CVector J(0,0,-1);
293 CVector K(0,1,0);
294 base.setRot(I,J,K, true);
295
296
297
298 uint ptch;
299
300 uint16 weldCount = 0;
301
302 // Error messages
303 vector<string> errorMessage;
304
305 for(i=0; i<8; i++)
306 {
307 if(adjZonesName[i]=="empty") continue;
308 if(!adjZoneFileFound[i]) continue;
309
310 // setting quad tree
311 uint qTreeDepth = 5;
312 CAABBoxExt bb = adjZones[i].getZoneBB();
313 quadTrees[i].create (5, bb.getCenter(), 2*bb.getRadius());
314 quadTrees[i].changeBase(base);
315
316 // retrieving infos from the current adjacent zone
317 std::vector<CPatchInfo> &adjZonePatchs= adjZoneInfos[i].Patchs;
318 std::vector<CBorderVertex> &adjZoneBorderVertices= adjZoneInfos[i].BorderVertices;
319
320
321 // if no id yet, we add a correct id
322 nlassert(adjZonesId[i]!=0);
323 if(adjZonesId[i]==0)
324 {
325 adjZonesId[i] = createZoneId(getName (adjZonesName[i]));
326 adjZoneInfos[i].ZoneId= adjZonesId[i];
327
328 // edge neighbour : current zone
329 for(itptch = adjZonePatchs.begin(); itptch!=adjZonePatchs.end(); itptch++)
330 {
331 for(j=0; j<4; j++)
332 {
333 (*itptch).BindEdges[j].ZoneId = adjZonesId[i];
334 }
335 }
336
337 // border vertices neighbour : current zone
338 for(itbv = adjZoneBorderVertices.begin(); itbv!=adjZoneBorderVertices.end(); itbv++)
339 {
340 (*itbv).NeighborZoneId = adjZonesId[i];
341 }
342
343 }
344 #if WELD_LOG
345 fprintf(fdbg,"------------------------------------------\n");
346 fprintf(fdbg,"id(%d) = %d\n",i,adjZonesId[i]);
347 #endif
348
349 // an edge of current adjacent patch with neighbour zoneId==center zoneId is
350 // set to no neighbour.
351 for(ptch = 0; ptch<adjZonePatchs.size(); ptch++)
352 {
353 for(j=0; j<4; j++)
354 {
355 if(adjZonePatchs[ptch].BindEdges[j].ZoneId == centerZoneId)
356 {
357 adjZonePatchs[ptch].BindEdges[j].NPatchs = 0;
358 }
359 }
360 }
361
362 fprintf(fdbg,"(before) zone %u bordervertices size : %u\n",i,(uint)adjZoneBorderVertices.size());
363
364 // delete border vertices of the adjacent zone if their neighbour zoneId
365 // is equal to current zone zoneId
366 std::vector<CBorderVertex>::iterator itborder = adjZoneBorderVertices.begin();
367 while(itborder != adjZoneBorderVertices.end())
368 {
369 if((*itborder).NeighborZoneId == centerZoneId)
370 {
371 itborder = adjZoneBorderVertices.erase(itborder);
372 }
373 else
374 itborder++;
375 }
376 fprintf(fdbg,"(after) zone %u bordervertices size : %u\n",i,(uint)adjZoneBorderVertices.size());
377
378 // A set for storing base vertex index already added in the quad tree
379 std::set<uint16> adjBaseVertexIndexSet;
380
381 // if point in adjacent zone is not in the set :
382 // -> add it in the set
383 // -> add it in the quad
384 for(ptch = 0; ptch<adjZonePatchs.size(); ptch++)
385 {
386 for(j=0; j<4; j++)
387 {
388 CWeldableVertexInfos wvinf;
389 wvinf.IndexInZone = adjZonePatchs[ptch].BaseVertices[j]; // useful ????
390 wvinf.PatchIndex = ptch;
391 wvinf.PatchVertex = j;
392 if(adjBaseVertexIndexSet.find(wvinf.IndexInZone) == adjBaseVertexIndexSet.end())
393 {
394 adjBaseVertexIndexSet.insert(wvinf.IndexInZone);
395 CVector bboxmin;
396 CVector bboxmax;
397 bboxmin.x = adjZonePatchs[ptch].Patch.Vertices[j].x;
398 bboxmin.y = adjZonePatchs[ptch].Patch.Vertices[j].y;
399 bboxmin.z = adjZonePatchs[ptch].Patch.Vertices[j].z;
400 bboxmax = bboxmin;
401 quadTrees[i].insert(bboxmin,bboxmax,wvinf);
402 }
403 }
404 }
405
406 quadTrees[i].clearSelection();
407
408
409 float bboxRadius = 10; //TEMP !!
410
411 std::set<uint16> centerBaseVertexIndexSet;
412 std::set<uint16> currentAdjBaseVertexIndexSet;
413
414 for(ptch=0; ptch<centerZonePatchs.size(); ptch++) // for all patchs in center zone
415 {
416 // stores infos for edge part
417 CWeldableVertexInfos nearVertexInfos[4];
418
419 bool toWeld[4];
420
421 CVector bboxmin;
422 CVector bboxmax;
423
424
425 // for every points in center patch we look for close points in adjacent patch
426 for(j=0; j<4; j++) // 4 patch vertices (in center zone)
427 {
428 toWeld[j] = false;
429
430
431 // already 'checked for welding' vertices are stored in a set
432 centerBaseVertexIndexSet.insert(centerZonePatchs[ptch].BaseVertices[j]);
433
434 //fprintf(fdbg,"%d - %d) CZBV(%d)\n",i,baseVertexIndexSet.size(),centerZonePatchs[ptch].BaseVertices[j]);
435
436 bboxmin.x = centerZonePatchs[ptch].Patch.Vertices[j].x - bboxRadius;
437 bboxmin.y = centerZonePatchs[ptch].Patch.Vertices[j].y - bboxRadius;
438 bboxmin.z = centerZonePatchs[ptch].Patch.Vertices[j].z - bboxRadius;
439
440 bboxmax.x = centerZonePatchs[ptch].Patch.Vertices[j].x + bboxRadius;
441 bboxmax.y = centerZonePatchs[ptch].Patch.Vertices[j].y + bboxRadius;
442 bboxmax.z = centerZonePatchs[ptch].Patch.Vertices[j].z + bboxRadius;
443
444 //quadTrees[i].select(bboxmin,bboxmax);
445 quadTrees[i].selectAll(); // TEMP !!!
446
447 // current vertex coordinates in center zone
448 CVector vctr;
449 vctr.x = centerZonePatchs[ptch].Patch.Vertices[j].x;
450 vctr.y = centerZonePatchs[ptch].Patch.Vertices[j].y;
451 vctr.z = centerZonePatchs[ptch].Patch.Vertices[j].z;
452
453 CWeldableVertexInfos wvinf;
454 float minDistance = weldRadius + 1; // rq: we weld only if we found a distance
455 // inferior to weldRadius
456
457 CQuadTree<CWeldableVertexInfos>::CIterator itqdt = quadTrees[i].begin();
458 // for all points near of current vertex in adjacent zone..
459 while (itqdt != quadTrees[i].end())
460 {
461 CVector vadj;
462 vadj.x = adjZonePatchs[(*itqdt).PatchIndex].Patch.Vertices[(*itqdt).PatchVertex].x;
463 vadj.y = adjZonePatchs[(*itqdt).PatchIndex].Patch.Vertices[(*itqdt).PatchVertex].y;
464 vadj.z = adjZonePatchs[(*itqdt).PatchIndex].Patch.Vertices[(*itqdt).PatchVertex].z;
465
466 CVector adjToCenter;
467 adjToCenter.x = vctr.x - vadj.x;
468 adjToCenter.y = vctr.y - vadj.y;
469 adjToCenter.z = vctr.z - vadj.z;
470 float dist = adjToCenter.norm();
471
472 // if dist min we keep infos on this vertex(adj zone)
473 // we keep the closest.
474 if(dist<weldRadius && dist<minDistance)
475 {
476 #ifdef NL_DEBUG_WELD
477 nlverify (!isTheSame (centerZonePatchs[ptch].Patch.Vertices[j], NL_DEBUG_WELD_V0));
478 nlverify (!isTheSame (centerZonePatchs[ptch].Patch.Vertices[j], NL_DEBUG_WELD_V1));
479 #endif // NL_DEBUG_WELD
480 minDistance = dist;
481 wvinf = (*itqdt);
482 }
483 itqdt++;
484 }
485
486 quadTrees[i].clearSelection();
487
488 if(minDistance<weldRadius) // i.e if we have found 2 vertices to weld
489 {
490 // we save CBorderVertex info, and add it into the adjacent zone
491 CBorderVertex adjBorderV;
492 adjBorderV.CurrentVertex = wvinf.IndexInZone;
493 adjBorderV.NeighborZoneId = centerZoneId;
494 adjBorderV.NeighborVertex = centerZonePatchs[ptch].BaseVertices[j];
495 nearVertexInfos[j] = wvinf;
496
497 // we save CBorderVertex info, and add it into the center zone
498 CBorderVertex centerBorderV;
499 centerBorderV.CurrentVertex = centerZonePatchs[ptch].BaseVertices[j];
500 centerBorderV.NeighborZoneId = adjZonesId[i];
501 centerBorderV.NeighborVertex = wvinf.IndexInZone;
502
503 toWeld[j] = true;
504
505 if(centerBaseVertexIndexSet.find(centerZonePatchs[ptch].BaseVertices[j]) != centerBaseVertexIndexSet.end())
506 {
507 if(currentAdjBaseVertexIndexSet.find(wvinf.IndexInZone) == currentAdjBaseVertexIndexSet.end())
508 {
509 currentAdjBaseVertexIndexSet.insert(wvinf.IndexInZone);
510 adjZoneBorderVertices.push_back(adjBorderV);
511 centerZoneBorderVertices.push_back(centerBorderV);
512
513 weldCount++;
514 #if WELD_LOG
515 fprintf(fdbg,"%d) weld vertices : zone%d.(patch%d.vertex%d).baseVertex%d to centerZone.(patch%d.vertex%d).baseVertex%d\n",
516 weldCount,i,wvinf.PatchIndex,wvinf.PatchVertex,wvinf.IndexInZone,ptch,j,centerZonePatchs[ptch].BaseVertices[j]);
517 #endif
518 }
519 }
520 }
521 }
522
523
524
525 // then we bind edges (made of weldable vertices) and modify tangents
526
527 for(j=0; j<4; j++)
528 {
529 #ifdef NL_DEBUG_WELD
530 if (
531 (isTheSame (centerZonePatchs[ptch].Patch.Vertices[j], NL_DEBUG_WELD_V0) ||
532 isTheSame (centerZonePatchs[ptch].Patch.Vertices[(j+1)%4], NL_DEBUG_WELD_V0) ) &&
533 (isTheSame (centerZonePatchs[ptch].Patch.Vertices[j], NL_DEBUG_WELD_V1) ||
534 isTheSame (centerZonePatchs[ptch].Patch.Vertices[(j+1)%4], NL_DEBUG_WELD_V1) )
535 )
536 nlstop;
537 #endif // NL_DEBUG_WELD
538 // if vertex has been welded...
539 if(toWeld[j] == false) continue;
540 // ...we look if next vertex(i.e if the edge) in center zone has to be welded
541 if(toWeld[(j+1)%4] == false) continue;
542
543 // We know the two adjacent base vertices
544 // we look for the adjacent patch and the edge containing these vertices
545 uint8 edgeIndex;
546 uint16 patchIndex;
547 if(! getPatchAndEdge(adjZonePatchs,
548 nearVertexInfos[j].IndexInZone,
549 nearVertexInfos[(j+1)%4].IndexInZone,
550 patchIndex,
551 edgeIndex))
552 {
553 #if WELD_LOG
554 fprintf(fdbg,"* Error * : Can't find patch containing the following edge : %d - %d\n",
555 nearVertexInfos[j].IndexInZone,
556 nearVertexInfos[(j+1)%4].IndexInZone);
557 #endif
558 nlwarning ("ERROR : zone_welder : Can't find patch containing the following edge : %d - %d\n",
559 nearVertexInfos[j].IndexInZone,
560 nearVertexInfos[(j+1)%4].IndexInZone);
561 continue;
562 }
563
564 #if WELD_LOG
565 fprintf(fdbg,"weld edges : zone%d.patch%d.edge%d(%d-%d) to centerZone.patch%d.edge%d(%d-%d)\n",
566 i,
567 patchIndex,
568 edgeIndex,
569 nearVertexInfos[j].IndexInZone,
570 nearVertexInfos[(j+1)%4].IndexInZone,
571 ptch,
572 j,
573 centerZonePatchs[ptch].BaseVertices[j],
574 centerZonePatchs[ptch].BaseVertices[(j+1)%4] );
575 fprintf(fdbg,"center patch %d : %d %d %d %d\n\n",
576 ptch,
577 centerZonePatchs[ptch].BaseVertices[0],
578 centerZonePatchs[ptch].BaseVertices[1],
579 centerZonePatchs[ptch].BaseVertices[2],
580 centerZonePatchs[ptch].BaseVertices[3]);
581 #endif
582
583 // Check the edge find is not binded
584 if (adjZonePatchs[patchIndex].BindEdges[edgeIndex].NPatchs!=0)
585 {
586 // Build an error message
587 char buf[2048];
588 stringstream sserror;
589
590 // Zone name
591 string nameCenter, nameAdj;
592 getZoneNameByCoord (centerZoneId&0xff, (centerZoneId>>8)+1, nameCenter);
593 getZoneNameByCoord (adjZonesId[i]&0xff, (adjZonesId[i]>>8)+1, nameAdj);
594
595 // Main message
596 smprintf(buf, 2048,
597 "Bind Error: try to bind the patch n %d in zone n %s with patch n %d in zone %s\n"
598 "This patch is already binded with the following patches : ", ptch+1, nameAdj.c_str(),
599 patchIndex+1, nameCenter.c_str() );
600 sserror << buf;
601
602 // Sub message
603 for (uint i=0; i<adjZonePatchs[patchIndex].BindEdges[edgeIndex].NPatchs; i++)
604 {
605 // Last patch ?
606 bool last=(i==(uint)(adjZonePatchs[patchIndex].BindEdges[edgeIndex].NPatchs-1));
607
608 // Sub message
609 smprintf(buf, 2048,
610 "patch n %d%s", adjZonePatchs[patchIndex].BindEdges[edgeIndex].Next[i]+1, last?"\n":",");
611
612 // Concat the message
613 sserror << buf;
614 }
615
616 // Add an error message
617 errorMessage.push_back(sserror.str());
618 }
619 else
620 {
621 #ifdef NL_DEBUG_WELD
622 if (
623 (isTheSame (centerZonePatchs[ptch].Patch.Vertices[j], NL_DEBUG_WELD_V0) ||
624 isTheSame (centerZonePatchs[ptch].Patch.Vertices[(j+1)%4], NL_DEBUG_WELD_V0) ) &&
625 (isTheSame (centerZonePatchs[ptch].Patch.Vertices[j], NL_DEBUG_WELD_V1) ||
626 isTheSame (centerZonePatchs[ptch].Patch.Vertices[(j+1)%4], NL_DEBUG_WELD_V1) )
627 )
628 nlstop;
629 #endif // NL_DEBUG_WELD
630 centerZonePatchs[ptch].BindEdges[j].NPatchs = 1;
631 centerZonePatchs[ptch].BindEdges[j].ZoneId = adjZonesId[i];
632 centerZonePatchs[ptch].BindEdges[j].Next[0] = patchIndex;
633 centerZonePatchs[ptch].BindEdges[j].Edge[0] = edgeIndex;
634
635 // adjacent zone edge
636 adjZonePatchs[patchIndex].BindEdges[edgeIndex].NPatchs = 1;
637 adjZonePatchs[patchIndex].BindEdges[edgeIndex].ZoneId = centerZoneId;
638 adjZonePatchs[patchIndex].BindEdges[edgeIndex].Next[0] = ptch;
639 adjZonePatchs[patchIndex].BindEdges[edgeIndex].Edge[0] = j;
640
641 // force the same smooth flag
642 bool smoothFlag = centerZonePatchs[ptch].getSmoothFlag (j);
643 smoothFlag &= adjZonePatchs[patchIndex].getSmoothFlag (edgeIndex);
644 centerZonePatchs[ptch].setSmoothFlag (j, smoothFlag);
645 adjZonePatchs[patchIndex].setSmoothFlag (edgeIndex, smoothFlag);
646
647 // tangent become the mean or both tangents (adj and center)
648 // Here we cross the mean because adjacent edges are counter-oriented
649 // due to the patchs constant orientation.
650 CVector middle0= (centerZonePatchs[ptch].Patch.Tangents[2*j]+
651 adjZonePatchs[patchIndex].Patch.Tangents[2*edgeIndex+1])/2;
652 CVector middle1= (centerZonePatchs[ptch].Patch.Tangents[2*j+1]+
653 adjZonePatchs[patchIndex].Patch.Tangents[2*edgeIndex])/2;
654
655 centerZonePatchs[ptch].Patch.Tangents[2*j] =
656 adjZonePatchs[patchIndex].Patch.Tangents[2*edgeIndex+1] = middle0;
657
658 centerZonePatchs[ptch].Patch.Tangents[2*j+1] =
659 adjZonePatchs[patchIndex].Patch.Tangents[2*edgeIndex] = middle1;
660 }
661 }
662
663 }
664
665 }
666
667
668 // Yoyo: compute the mean on vertices beetween zones.
669 //====================================
670 // do it before "make coplanar beetween zones", because CZoneTgtSmoother use tangents and vertices to smooth.
671 {
672 // build all input vertices for center and adjacents zones
673 //------------------
674
675 // For center zone rebuild vertices.
676 vector<CVector> centerVertices;
677 // for all patch, fill the array of vertices.
678 for(ptch=0; ptch<centerZonePatchs.size(); ptch++)
679 {
680 CPatchInfo &pa= centerZonePatchs[ptch];
681 for(uint corner= 0; corner<4; corner++)
682 {
683 uint idVert= pa.BaseVertices[corner];
684
685 // write this vertex in array.
686 centerVertices.resize( max((uint)centerVertices.size(), idVert+1) );
687 centerVertices[idVert]= pa.Patch.Vertices[corner];
688 }
689 }
690
691 // For all adjacent zone rebuild vertices.
692 map<uint16, vector<CAdjacentVertex> > adjVertices;
693 for(i=0;i<8;i++)
694 {
695 if(adjZonesName[i]=="empty") continue;
696 if(!adjZoneFileFound[i]) continue;
697
698 // create the entry in the map.
699 vector<CAdjacentVertex> &verts= adjVertices[adjZonesId[i]];
700
701 // for all patch, fill the array of vertices.
702 std::vector<CPatchInfo> &adjZonePatchs= adjZoneInfos[i].Patchs;
703 for(ptch=0; ptch<adjZonePatchs.size(); ptch++)
704 {
705 CPatchInfo &pa= adjZonePatchs[ptch];
706 for(uint corner= 0; corner<4; corner++)
707 {
708 uint idVert= pa.BaseVertices[corner];
709
710 // write this vertex in array.
711 verts.resize( max((uint)verts.size(), idVert+1) );
712 verts[idVert].Vertex= pa.Patch.Vertices[corner];
713 verts[idVert].OnBorder= false;
714 }
715 }
716
717 // for all borderVertices with centerZoneId, fill verts neighbor info.
718 std::vector<CBorderVertex> &adjZoneBorderVertices= adjZoneInfos[i].BorderVertices;
719 uint bv;
720 for(bv=0; bv<adjZoneBorderVertices.size(); bv++)
721 {
722 CBorderVertex &adjBV= adjZoneBorderVertices[bv];
723 if(adjBV.NeighborZoneId == centerZoneId)
724 {
725 verts[adjBV.CurrentVertex].OnBorder= true;
726 verts[adjBV.CurrentVertex].IdOnCenterZone= adjBV.NeighborVertex;
727 }
728 }
729
730 }
731
732 // compute the mean on border vertices
733 //------------------
734
735
736 // create / reset the result vertices.
737 vector<CVectorInfluence> outVertices;
738 outVertices.resize(centerVertices.size());
739 for(i=0; i<outVertices.size(); i++)
740 {
741 outVertices[i].Vertex= centerVertices[i];
742 outVertices[i].Inf= 1;
743 outVertices[i].OnBorder= false;
744 }
745
746
747 // For all borderVertices of centerZone, choose the good vertex, add neighbor influence
748 uint bv;
749 for(bv=0; bv<centerZoneBorderVertices.size(); bv++)
750 {
751 CBorderVertex &centerBV= centerZoneBorderVertices[bv];
752 uint centerVert= centerBV.CurrentVertex;
753 if( adjVertices.find(centerBV.NeighborZoneId) != adjVertices.end() )
754 {
755 outVertices[centerVert].Vertex+= adjVertices[centerBV.NeighborZoneId][centerBV.NeighborVertex].Vertex;
756 outVertices[centerVert].Inf++;
757 outVertices[centerVert].OnBorder= true;
758 }
759 }
760 // normalize influence.
761 for(i=0; i<outVertices.size(); i++)
762 {
763 if(outVertices[i].Inf!=1)
764 {
765 outVertices[i].Vertex/= outVertices[i].Inf;
766 outVertices[i].Inf= 1;
767 }
768 }
769
770
771 // for all zones, get the new vertices.
772 //------------------
773
774 // For center zone, for all patchs, copy from outVertices.
775 for(ptch=0; ptch<centerZonePatchs.size(); ptch++)
776 {
777 CPatchInfo &pa= centerZonePatchs[ptch];
778 for(uint corner= 0; corner<4; corner++)
779 {
780 uint idVert= pa.BaseVertices[corner];
781
782 if(outVertices[idVert].OnBorder)
783 {
784 // copy the vertex.
785 pa.Patch.Vertices[corner]= outVertices[idVert].Vertex;
786 }
787 }
788 }
789
790
791 // For all borderVertices of adjacentZone, copy from outVertices.
792 for(i=0;i<8;i++)
793 {
794 if(adjZonesName[i]=="empty") continue;
795 if(!adjZoneFileFound[i]) continue;
796
797 // get the entry in the map.
798 vector<CAdjacentVertex> &verts= adjVertices[adjZonesId[i]];
799
800 // for all patch, get vertices which are n Border of the cetnerZone.
801 std::vector<CPatchInfo> &adjZonePatchs= adjZoneInfos[i].Patchs;
802 for(ptch=0; ptch<adjZonePatchs.size(); ptch++)
803 {
804 CPatchInfo &pa= adjZonePatchs[ptch];
805 for(uint corner= 0; corner<4; corner++)
806 {
807 uint idVert= pa.BaseVertices[corner];
808
809 if(verts[idVert].OnBorder)
810 {
811 pa.Patch.Vertices[corner]= outVertices[verts[idVert].IdOnCenterZone].Vertex;
812 }
813 }
814 }
815
816 }
817
818 }
819
820
821
822 // Yoyo: make coplanar beetween zones.
823 //====================================
824 {
825 std::vector<CZoneInfo> zones;
826 CZoneInfo zinf;
827
828 // center.
829 zinf.ZoneId= centerZoneId;
830 zinf.Patchs= centerZonePatchs;
831 zinf.BorderVertices= centerZoneBorderVertices;
832 zones.push_back(zinf);
833
834 // adjs.
835 for(i=0;i<8;i++)
836 {
837 if(adjZonesName[i]=="empty") continue;
838 if(!adjZoneFileFound[i]) continue;
839 zones.push_back(adjZoneInfos[i]);
840 }
841
842 CZoneTgtSmoother tgtsmoother;
843 tgtsmoother.makeVerticesCoplanar(zones);
844
845 // retrieve center zone result.
846 centerZonePatchs= zones[0].Patchs;
847 centerZoneBorderVertices= zones[0].BorderVertices;
848
849 // retrieve adj zone result.
850 sint numZone= 1;
851 for(i=0;i<8;i++)
852 {
853 if(adjZonesName[i]=="empty") continue;
854 if(!adjZoneFileFound[i]) continue;
855
856 adjZoneInfos[i]= zones[numZone];
857 numZone++;
858 }
859 }
860
861
862 // Yoyo: compute corner smooth info.
863 //====================================
864 // CANNOT DO IT HERE, BECAUSE THE CURRENT ZONE MAY NOT BE CORRECLTY WELDED.
865 // MUST DO IT IN ZONE_LIGHTER.
866 /*{
867 // build a landscape, because CZoneCornerSmooth use compiled zones.
868 CLandscape land;
869 CZoneCornerSmoother zcs;
870
871 land.init();
872
873 // add center zone.
874 zone.build(centerZoneId, centerZonePatchs, centerZoneBorderVertices);
875 land.addZone(zone);
876 CZone *centerZone= land.getZone(centerZoneId);
877
878 // add adjacent zones.
879 vector<CZone*> nbZones;
880 for(i=0;i<8;i++)
881 {
882 if(adjZonesName[i]=="empty") continue;
883 if(!adjZoneFileFound[i]) continue;
884
885 std::vector<CPatchInfo> &adjZonePatchs= adjZoneInfos[i].Patchs;
886 std::vector<CBorderVertex> &adjZoneBorderVertices= adjZoneInfos[i].BorderVertices;
887
888 adjZones[i].build(adjZonesId[i], adjZonePatchs, adjZoneBorderVertices);
889 land.addZone(adjZones[i]);
890
891 CZone *nbZone= land.getZone(adjZonesId[i]);
892 if(nbZone)
893 nbZones.push_back(nbZone);
894 }
895
896 // now, do the zoneCornerSmoother.
897 if(centerZone)
898 {
899 // go.
900 zcs.computeAllCornerSmoothFlags(centerZone, nbZones);
901
902 // get result from the compiled zone, and copy in the uncompiled one (ie in centerZonePatchs).
903 for(i=0;i<centerZonePatchs.size();i++)
904 {
905 const CPatch &paSrc= *((const CZone*)centerZone)->getPatch(i);
906 CPatchInfo &paDst= centerZonePatchs[i];
907 for(uint corner=0; corner<4; corner++)
908 paDst.setCornerSmoothFlag(corner, paSrc.getCornerSmoothFlag(corner));
909 }
910 }
911 }*/
912
913 // Some errors ?
914 if (errorMessage.empty())
915 {
916 // Save adjacent zones.
917 //=====================
918 for(i=0;i<8;i++)
919 {
920 if(adjZonesName[i]=="empty") continue;
921 if(!adjZoneFileFound[i]) continue;
922
923 std::vector<CPatchInfo> &adjZonePatchs= adjZoneInfos[i].Patchs;
924 std::vector<CBorderVertex> &adjZoneBorderVertices= adjZoneInfos[i].BorderVertices;
925
926 adjZones[i].build(adjZonesId[i], adjZonePatchs, adjZoneBorderVertices);
927 #if WELD_LOG
928 fprintf(fdbg,"[%d] binds :\n", i);
929 adjZones[i].debugBinds(fdbg);
930 #endif
931 std::string strtmp;
932
933 //strtmp = outputPath;
934 strtmp = outputDir+adjZonesName[i]+outputExt;
935 COFile adjSave(strtmp);
936 printf("writing file %s\n",strtmp.c_str());
937 adjZones[i].serial(adjSave);
938
939 }
940
941 // Save center zone.
942 //==================
943 zone.build(centerZoneId, centerZonePatchs, centerZoneBorderVertices);
944 std::string strtmp;
945 strtmp = outputDir+center+outputExt;
946
947 COFile centerSave(strtmp);
948 printf("writing file %s\n",strtmp.c_str());
949 zone.serial(centerSave);
950 }
951 else
952 {
953 // Main message
954 nlwarning ("ERROR weld failed. Correct errors below: (indices are MAX indices (+1))\n");
955
956 // For each message
957 for (uint i=0; i<errorMessage.size(); i++)
958 {
959 // Message
960 nlwarning ("%s", errorMessage[i].c_str());
961 }
962 }
963
964 }
965
966
967
968 /*******************************************************************\
969 main()
970 \*******************************************************************/
971 int main(sint argc, char **argv)
972 {
973 // no zone file in argument
974 if(argc<3)
975 {
976 writeInstructions();
977 return 0;
978 }
979
980 // help
981 if(strcmp(argv[1],"/?")==0)
982 {
983 writeInstructions();
984 return 0;
985 }
986
987 #if WELD_LOG
988 fdbg = nlfopen("log.txt","wt");
989 fprintf(fdbg,"Center zone : %s\n",argv[1]);
990 #endif
991
992 printf("Center zone : %s\n",argv[1]);
993
994 inputDir = getDir (argv[1]);
995 inputExt = getExt (argv[1]);
996 outputDir = getDir (argv[2]);
997 outputExt = getExt (argv[2]);
998
999 if(argc == 4)
1000 {
1001 NLMISC::fromString(argv[3], weldRadius);
1002 }
1003
1004 std::string center=getName(argv[1]).c_str();
1005 weldZones(center.c_str());
1006
1007 #if WELD_LOG
1008 fclose(fdbg);
1009 #endif
1010
1011 return 0;
1012 }
1013
1014
1015