?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' into main/rendor-staging
[ryzomcore.git] / ryzom / tools / leveldesign / prim_export / main.cpp
blob4d219ba783ac271d6c6a3e2dd63c915e1a624ba1
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This source file has been modified by the following contributors:
5 // Copyright (C) 2010 Matt RAYKOWSKI (sfb) <matt.raykowski@gmail.com>
6 // Copyright (C) 2010-2020 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
7 //
8 // This program is free software: you can redistribute it and/or modify
9 // it under the terms of the GNU Affero General Public License as
10 // published by the Free Software Foundation, either version 3 of the
11 // License, or (at your option) any later version.
12 //
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU Affero General Public License for more details.
17 //
18 // You should have received a copy of the GNU Affero General Public License
19 // along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21 #include <stdio.h>
22 #include <string>
23 #include <sstream>
24
25 #include "nel/misc/config_file.h"
26 #include "nel/misc/file.h"
27 #include "nel/misc/i_xml.h"
28 #include "nel/misc/path.h"
29 #include "nel/misc/progress_callback.h"
30
31 #include "nel/ligo/primitive.h"
32 #include "nel/ligo/ligo_config.h"
33
34 #include "nel/georges/u_form.h"
35 #include "nel/georges/u_form_elm.h"
36 #include "nel/georges/u_form_loader.h"
37
38 #include "nel/3d/zone.h"
39 #include "nel/3d/landscape.h"
40 #include "nel/3d/scene_group.h"
41
42 #ifdef NL_OS_WINDOWS
43 #include <windows.h>
44 #endif // NL_OS_WINDOWS
45
46 // ***************************************************************************
47
48 /*
49 Documentation
50
51 This tool generates ig from primitive files
52
53 - Load the landscape zone. Load all the *.zonew found in the InLandscapeDir and add them in a landscape
54 - For each primitive files found in PrimDirs
55 - Look for points with the "prim" primitive class
56 - Get the good height on the landscape
57 - Get the .plant georges file associed with the point
58 - Add an entry in the good ig file
59 - Set the shape filename
60 - Set the plant name
61 - Set the final position (x and y come from the primitive and z from height test with the landscape, the rotation comes from the primitive)
62 - Set the ig date
63 - The date is the most recent date between the .zonew .plant .primitive files associed with the ig.
64 - Snap to ground only modified or created ig
65 - Save the modified or created ig files
66 */
67
68 // ***************************************************************************
69
70 using namespace std;
71 using namespace NLMISC;
72 using namespace NL3D;
73 using namespace NLGEORGES;
74 using namespace NLLIGO;
75
76 // ***************************************************************************
77 // Utility functions
78 // ***************************************************************************
79
80 #define SELECTION_EPSILON 0.1f
81
82 #define BAR_LENGTH 21
83
84 const char *progressbar[BAR_LENGTH]=
85 {
86 "[ ]",
87 "[. ]",
88 "[.. ]",
89 "[... ]",
90 "[.... ]",
91 "[..... ]",
92 "[...... ]",
93 "[....... ]",
94 "[........ ]",
95 "[......... ]",
96 "[.......... ]",
97 "[........... ]",
98 "[............ ]",
99 "[............. ]",
100 "[.............. ]",
101 "[............... ]",
102 "[................ ]",
103 "[................. ]",
104 "[.................. ]",
105 "[................... ]",
106 "[....................]"
107 };
108
109 // ***************************************************************************
110
111 // Progress bar
112 class CMyCallback : public IProgressCallback
113 {
114 public:
115 void progress (float progress)
116 {
117 // Delta time, update max all the 300 ms
118 static sint64 time = CTime::getLocalTime ();
119 sint64 currentTime = CTime::getLocalTime ();
120 if ((currentTime - time) > 300)
121 {
122 // Crop the progress bar value
123 progress = getCropedValue (progress);
124
125 // Progress bar
126 char msg[512];
127 uint pgId= (uint)(progress*(float)BAR_LENGTH);
128 pgId= min(pgId, (uint)(BAR_LENGTH-1));
129 sprintf (msg, "\r%s: %s", DisplayString.c_str (), progressbar[pgId]);
130 uint i;
131 for (i=(uint)strlen(msg); i<79; i++)
132 msg[i]=' ';
133 msg[i]=0;
134 printf ("%s", msg);
135 printf ("\r");
136
137 time = currentTime;
138 }
139 }
140 };
141
142 // ***************************************************************************
143
144 sint getXFromZoneName (const string &ZoneName)
145 {
146 string xStr, yStr;
147 uint32 i = 0;
148 while (ZoneName[i] != '_')
149 {
150 yStr += ZoneName[i]; ++i;
151 if (i == ZoneName.size())
152 return -1;
153 }
154 ++i;
155 while (i < ZoneName.size())
156 {
157 xStr += ZoneName[i]; ++i;
158 }
159 return ((xStr[0] - 'A')*26 + (xStr[1] - 'A'));
160 }
161
162 // ***************************************************************************
163
164 bool getZoneCoordByName(const char * name, uint16& x, uint16& y)
165 {
166 uint i;
167
168 std::string zoneName(name);
169
170 // y
171 std::string::size_type ind1 = zoneName.find("_");
172 if(ind1 == std::string::npos)
173 {
174 nlwarning("bad file name");
175 return false;
176 }
177 std::string ystr = zoneName.substr(0,ind1);
178 for(i=0; i<ystr.length(); i++)
179 {
180 if(!isdigit(ystr[i]))
181 {
182 nlwarning("y code size is not a 2 characters code");
183 return false;
184 }
185 }
186
187 NLMISC::fromString(ystr, y);
188 y = -y;
189
190 // x
191 x = 0;
192 uint ind2 = (uint)zoneName.length();
193 if((ind2-ind1-1)!=2)
194 {
195 nlwarning("x code size is not a 2 characters code");
196 return false;
197 }
198 std::string xstr = zoneName.substr(ind1+1,ind2-ind1-1);
199 for(i=0; i<xstr.length(); i++)
200 {
201 if (isalpha(xstr[i]))
202 {
203 x *= 26;
204 x += (tolower(xstr[i])-'a');
205 }
206 else
207 {
208 nlwarning("invalid");
209 return false;
210 }
211 }
212 return true;
213 }
214
215 // ***************************************************************************
216
217 sint getYFromZoneName (const string &ZoneName)
218 {
219 string xStr, yStr;
220 uint32 i = 0;
221 while (ZoneName[i] != '_')
222 {
223 yStr += ZoneName[i]; ++i;
224 if (i == ZoneName.size())
225 return 1;
226 }
227 ++i;
228 while (i < ZoneName.size())
229 {
230 xStr += ZoneName[i]; ++i;
231 }
232
233 sint y = 0;
234 NLMISC::fromString(yStr, y);
235
236 return -y;
237 }
238
239 // ***************************************************************************
240
241 void outString (const string &sText)
242 {
243 createDebug ();
244 InfoLog->displayRaw(sText.c_str());
245 }
246
247 // ***************************************************************************
248
249 string getPrimitiveName (const IPrimitive &primitive)
250 {
251 string name;
252 primitive.getPropertyByName ("name", name);
253 return name;
254 }
255
256 // ***************************************************************************
257
258 uint16 getZoneId (sint x, sint y)
259 {
260 return (uint16)((((-y)-1)<<8) + x);
261 }
262
263 // ***************************************************************************
264
265 void getLettersFromNum(uint16 num, std::string& code)
266 {
267 if(num>26*26)
268 {
269 nlwarning("zone index too high");
270 return;
271 }
272 code.resize(0);
273 uint16 remainder = num%26;
274 code += 'A' + num/26;
275 code += 'A' + remainder;
276 }
277
278 // ***************************************************************************
279
280 void getZoneNameByCoord(sint16 x, sint16 y, std::string& zoneName)
281 {
282 if ((y>0) || (y<-255) || (x<0) || (x>255))
283 return;
284 zoneName = toString(-y) + "_";
285 zoneName += ('A' + (x/26));
286 zoneName += ('A' + (x%26));
287 }
288
289 // ***************************************************************************
290
291 bool triangleIntersect2DGround (const CTriangle &tri, const CVector &pos0)
292 {
293 const CVector &p0= tri.V0;
294 const CVector &p1= tri.V1;
295 const CVector &p2= tri.V2;
296
297 // Test if the face enclose the pos in X/Y plane.
298 // NB: compute and using a BBox to do a rapid test is not a very good idea, since it will
299 // add an overhead which is NOT negligeable compared to the following test.
300 float a,b,c; // 2D cartesian coefficients of line in plane X/Y.
301 // Line p0-p1.
302 a= -(p1.y-p0.y);
303 b= (p1.x-p0.x);
304 c= -(p0.x*a + p0.y*b);
305 if( (a*pos0.x + b*pos0.y + c) < 0) return false;
306 // Line p1-p2.
307 a= -(p2.y-p1.y);
308 b= (p2.x-p1.x);
309 c= -(p1.x*a + p1.y*b);
310 if( (a*pos0.x + b*pos0.y + c) < 0) return false;
311 // Line p2-p0.
312 a= -(p0.y-p2.y);
313 b= (p0.x-p2.x);
314 c= -(p2.x*a + p2.y*b);
315 if( (a*pos0.x + b*pos0.y + c) < 0) return false;
316
317 return true;
318 }
319
320 // ***************************************************************************
321 // CExportOptions
322 // ***************************************************************************
323
324 struct CExportOptions
325 {
326 std::string InLandscapeDir; // Directory where to get .zonew files
327 std::string OutIGDir; // Directory where to put IG
328 std::string LandBankFile; // The .smallbank file associated with the landscape
329 std::string LandFarBankFile; // The .farbank file
330 float CellSize; // Typically 160.0
331 std::string LandTileNoiseDir; // Directory where to get displacement map
332
333 std::vector<std::string> PrimDirs; // Directory to parse for .flora and .prim associated
334 // This is here we get continent.cfg file
335 std::string FormDir; // Directory to get georges dfn
336 std::string WorldEditorFiles;
337
338 CExportOptions ();
339 bool loadcf (NLMISC::CConfigFile &cf);
340 };
341
342 // ***************************************************************************
343
344 CExportOptions::CExportOptions ()
345 {
346 CellSize = 160.0f;
347 }
348
349 // ***************************************************************************
350
351 bool CExportOptions::loadcf (CConfigFile &cf)
352 {
353 // Out
354 CConfigFile::CVar &cvOutIGDir = cf.getVar("OutIGDir");
355 OutIGDir = cvOutIGDir.asString();
356
357 // In
358 CConfigFile::CVar &cvInLandscapeDir = cf.getVar("ZoneWDir");
359 InLandscapeDir = cvInLandscapeDir.asString();
360
361 CConfigFile::CVar &cvLandBankFile = cf.getVar("SmallBank");
362 LandBankFile = cvLandBankFile.asString();
363 CConfigFile::CVar &cvLandFarBankFile = cf.getVar("FarBank");
364 LandFarBankFile = cvLandFarBankFile.asString();
365 CConfigFile::CVar &cvLandTileNoiseDir = cf.getVar("DisplaceDir");
366 LandTileNoiseDir = cvLandTileNoiseDir.asString();
367
368 CConfigFile::CVar &cvCellSize = cf.getVar("CellSize");
369 CellSize = cvCellSize.asFloat();
370
371 CConfigFile::CVar &cvPrimDir = cf.getVar("PrimDirs");
372 uint i;
373 PrimDirs.resize (cvPrimDir.size());
374 for (i=0; i<(uint)cvPrimDir.size(); i++)
375 PrimDirs[i] = cvPrimDir.asString(i);
376
377 CConfigFile::CVar &cvFormDir = cf.getVar("FormDir");
378 FormDir = cvFormDir.asString();
379
380 CConfigFile::CVar &cvWorldEditorFiles = cf.getVar("WorldEditorFiles");
381 WorldEditorFiles = cvWorldEditorFiles.asString();
382
383 return true;
384 }
385
386 // ***************************************************************************
387
388 // Array of ig
389 class CIgContainer
390 {
391 public:
392
393 // An ig
394 class CIG
395 {
396 public:
397 // Additionnal parameters
398 class CAdditionnalParam
399 {
400 public:
401 CAdditionnalParam (uint snapLayer, const string &primitiveName, const string &primitiveFile, bool snap) : SnapLayer (snapLayer), PrimitiveName (primitiveName), PrimitiveFile (primitiveFile)
402 {
403 Snap = snap;
404 };
405
406 // Snap over the landscape
407 bool Snap;
408
409 // Snap layer
410 uint SnapLayer;
411
412 // Primitive name
413 string PrimitiveName;
414
415 // Primitive file
416 string PrimitiveFile;
417 };
418
419 // Default ctor
420 CIG ()
421 {
422 Date = 0;
423 }
424
425 // Update date if new date is more recent
426 void updateDate (uint32 newDate)
427 {
428 if (newDate > Date)
429 Date = newDate;
430 }
431
432 // The ig
433 CInstanceGroup::TInstanceArray Instances;
434
435 // Additionnal information
436 vector<CAdditionnalParam> AdditionnalInfo;
437
438 // The ig date
439 uint32 Date;
440 };
441
442 // Init the container
443 void init (sint minx, sint maxx, sint miny, sint maxy, const char *zoneDir)
444 {
445 // Save the values
446 Minx = minx;
447 Miny = miny;
448 Maxx = maxx+1;
449 Maxy = maxy+1;
450 Width = maxx - minx + 1;
451
452 // Resize the array
453 IGS.clear ();
454 IGS.resize (Width*(maxy-miny+1));
455
456 // Directory
457 string dir = CPath::standardizePath (zoneDir, true);
458
459 // For each zone
460 for (sint y=miny; y<=maxy; y++)
461 for (sint x=minx; x<=maxx; x++)
462 {
463 // The zone name
464 string zoneFilename;
465 getZoneNameByCoord ((sint16)x, (sint16)y, zoneFilename);
466 zoneFilename = dir + zoneFilename + ".zonew";
467
468 // Get the date
469 if (CFile::fileExists (zoneFilename))
470 get (x, y).Date = CFile::getFileModificationDate (zoneFilename);
471 }
472 }
473
474 // Get the ig
475 CIG &get (sint x, sint y)
476 {
477 return IGS[(x-Minx)+(y-Miny)*Width];
478 }
479
480 // Size and position
481 uint Width;
482 sint Minx;
483 sint Miny;
484 sint Maxx;
485 sint Maxy;
486
487 // The ig vector
488 vector<CIG> IGS;
489 };
490
491 // ***************************************************************************
492
493 // Array of ig
494 class CFormContainer
495 {
496 private:
497 // The map value
498 struct CValue
499 {
500 CValue (CSmartPtr<UForm> ptr, uint32 date) : Ptr (ptr), Date (date) {};
501
502 // The form pointer
503 CSmartPtr<UForm> Ptr;
504
505 // Its date
506 uint32 Date;
507 };
508 public:
509
510 // Default ctor
511 CFormContainer ()
512 {
513 _FormLoader = UFormLoader::createLoader ();
514 }
515
516 // Dtor
517 ~CFormContainer ()
518 {
519 UFormLoader::releaseLoader (_FormLoader);
520 }
521
522 // The form container
523 const UForm *loadForm (const char *formName, uint32 &formDate)
524 {
525 // The form
526 UForm *form = NULL;
527 formDate = 0;
528
529 // In the map ?
530 string formShortName = NLMISC::toLowerAscii(CFile::getFilename (formName));
531 map<string, CValue >::iterator ite = _FormMap.find (formShortName);
532 if (ite == _FormMap.end ())
533 {
534 // Look for this plant file
535 string path = CPath::lookup (formName, false, false, false);
536 if (!path.empty ())
537 {
538 // Load it !
539 form = _FormLoader->loadForm (path.c_str ());
540 if (form)
541 {
542 // Get dependencies
543 set<string> dependencies;
544 form->getDependencies (dependencies);
545
546 // Get dependencies dates
547 formDate = 0;
548 set<string>::const_iterator ite = dependencies.begin ();
549 while (ite != dependencies.end ())
550 {
551 // Get the path name
552 string path = CPath::lookup (*ite, false, false, false);
553 if (!path.empty ())
554 {
555 // Get the file date
556 uint32 date = CFile::getFileModificationDate (path);
557
558 // Update date
559 if (date > formDate)
560 formDate = date;
561 }
562
563 // Next dependency
564 ite++;
565 }
566
567 // Add it
568 _FormMap.insert (map<string, CValue >::value_type (formShortName, CValue (form, formDate)));
569 }
570 else
571 {
572 // Error in the log
573 nlwarning ("Error : Can't load the form (%s)", path.c_str ());
574 }
575 }
576 }
577 else
578 {
579 form = ite->second.Ptr;
580 formDate = ite->second.Date;
581 }
582
583 // Return the form or NULL
584 return form;
585 }
586
587 private:
588
589 // The form loader
590 UFormLoader *_FormLoader;
591
592 // The form map
593 map<string, CValue > _FormMap;
594 };
595
596 // ***************************************************************************
597
598 void addPointPrimitive (CLandscape &landscape, const char *primFilename, uint32 primFileDate, const IPrimitive &primitive, CIgContainer &igs,
599 const CExportOptions &options, CFormContainer &formContainer, IProgressCallback &callback)
600 {
601 // Is this primitive a point ?
602 const CPrimPoint *point = dynamic_cast<const CPrimPoint *>(&primitive);
603 if (point)
604 {
605 // Get the class name
606 string className;
607 if (point->getPropertyByName ("class", className))
608 {
609 // Is it a plant ?
610 if (className == "prim")
611 {
612 // Get its plant name
613 string plantFilename;
614 if (point->getPropertyByName ("form", plantFilename))
615 {
616 // Add an extension
617 if (NLMISC::toLowerAscii(CFile::getExtension (plantFilename)) != "plant")
618 plantFilename += ".plant";
619
620 // Load this form
621 uint32 formDate;
622 const UForm *form = formContainer.loadForm (plantFilename.c_str (), formDate);
623 if (form)
624 {
625 // Get the parameters
626 string shape;
627 if (form->getRootNode ().getValueByName (shape, "3D.Shape"))
628 {
629 // Get the position
630 CVector position = point->Point;
631
632 // Get the scale
633 string scaleText;
634 float scale = 1;
635 if (point->getPropertyByName ("scale", scaleText))
636 NLMISC::fromString(scaleText, scale);
637
638 // Get zone coordinates
639 sint x = (sint)floor (position.x / options.CellSize);
640 sint y = (sint)floor (position.y / options.CellSize);
641 if ( (x >= igs.Minx) && (x < igs.Maxx) && (y >= igs.Miny) && (y < igs.Maxy) )
642 {
643 // Get its layer
644 string text;
645 uint layer = 0;
646 if (point->getPropertyByName ("depth", text))
647 {
648 layer = atoi (text.c_str ());
649 }
650
651 // Not snap yet
652 position.z = 0;
653
654 // Snap flag
655 bool snap = true;
656 if (point->getPropertyByName ("snap", text))
657 snap = text != "false";
658
659 // Get height
660 if (!snap && point->getPropertyByName ("height", text))
661 NLMISC::fromString(text, position.z);
662
663 // *** Add the instance
664
665 // Create it
666 CInstanceGroup::CInstance instance;
667 instance.Pos = position;
668 instance.Rot = CQuat(CVector::K, point->Angle);
669 instance.Scale = CVector (scale, scale, scale);
670 instance.nParent = -1;
671 instance.Name = shape;
672 instance.InstanceName = NLMISC::toLowerAscii(CFile::getFilename (plantFilename));
673
674 // Get the instance group ref
675 CIgContainer::CIG &instances = igs.get (x, y);
676 instances.Instances.push_back (instance);
677 instances.AdditionnalInfo.push_back (CIgContainer::CIG::CAdditionnalParam (layer,
678 getPrimitiveName (primitive), primFilename, snap));
679
680 // Update the date with the primitive filename
681 instances.updateDate (primFileDate);
682
683 // Update the date with the plant filename
684 instances.updateDate (formDate);
685
686 // Update the date with the zone filename
687 string zoneFilename;
688 getZoneNameByCoord (x, y, zoneFilename);
689 zoneFilename = CPath::standardizePath (options.InLandscapeDir, true) + zoneFilename + ".zonew";
690 // todo hulud needed ? instances.updateDate (zoneFilename);
691 }
692 }
693 else
694 {
695 // Error in the log
696 nlwarning ("Error : Can't get a shape name in the form (%s) for the primitive (%s) in the file (%s)",
697 plantFilename.c_str (), getPrimitiveName (primitive).c_str (), primFilename);
698 }
699 }
700 else
701 {
702 // Error in the log
703 nlwarning ("Error : can't load the file (%s) used by the primitive (%s) in the file (%s).", plantFilename.c_str (),
704 getPrimitiveName (primitive).c_str (), primFilename);
705 }
706 }
707 else
708 {
709 // Error in the log
710 nlwarning ("Error : in file (%s), the primitive (%s) has no plant file.", primFilename, getPrimitiveName (primitive).c_str ());
711 }
712 }
713 }
714 }
715
716 // Look in children
717 uint numChildren = primitive.getNumChildren ();
718 for (uint i=0; i<numChildren; i++)
719 {
720 // Progress bar
721 callback.progress ((float)i/(float)numChildren);
722 callback.pushCropedValues ((float)i/(float)numChildren, (float)(i+1)/(float)numChildren);
723
724 // Get the child
725 const IPrimitive *child;
726 nlverify (primitive.getChild (child, i));
727 addPointPrimitive (landscape, primFilename, primFileDate, *child, igs, options, formContainer, callback);
728
729 // Progress bar
730 callback.popCropedValues ();
731 }
732 }
733
734 // ***************************************************************************
735
736 int main (int argc, char**argv)
737 {
738 new NLMISC::CApplicationContext;
739
740 // Filter addSearchPath
741 NLMISC::createDebug();
742 InfoLog->addNegativeFilter ("addSearchPath");
743
744 // Register ligo
745 NLLIGO::Register ();
746
747 if (argc != 2)
748 {
749 printf ("Use : prim_export configfile.cfg\n");
750 printf ("\nExample of config.cfg\n\n");
751
752 printf ("\n// Export Options\n");
753 printf ("OutIGDir = \"c:/temp/outIG\";\n");
754 printf ("ZoneWDir = \"c:/temp/inZoneW\";\n");
755 printf ("SmallBank = \"//amiga/3d/database/landscape/_texture_tiles/jungle/jungle.bank\";\n");
756 printf ("FarBank = \"//amiga/3d/database/landscape/_texture_tiles/jungle/jungle.farbank\";\n");
757 printf ("DisplaceDir = \"//amiga/3d/database/landscape/_texture_tiles/displace\";\n");
758 printf ("CellSize = 160.0;\n");
759 printf ("PrimDirs = {\"//server/leveldesign/world/fyros\"};\n");
760
761 return -1;
762 }
763
764 try
765 {
766 // Load the config file
767 CExportOptions options;
768
769 string sTmp = string("loading cfg file : ") + string(argv[1]) + "\n";
770 // outString(sTmp);
771 {
772 CConfigFile cf;
773 cf.load (argv[1]);
774 if (!options.loadcf(cf))
775 {
776 sTmp = "Error : options not loaded from config file\n";
777 outString (sTmp);
778 return -1;
779 }
780 }
781
782 // *** Add pathes in the search path for georges forms
783
784 CPath::addSearchPath (options.FormDir, true, true);
785 CPath::addSearchPath (options.WorldEditorFiles, true, true);
786
787 // Ligo config
788 CLigoConfig config;
789 string path = CPath::lookup ("world_editor_classes.xml", false, false, false);
790 if (path.empty())
791 nlwarning ("Error : File world_editor_classes.xml not found");
792 else
793 config.readPrimitiveClass (path.c_str(), false);
794
795 // *** Load the landscape
796
797 // Init the landscape
798 CLandscape landscape;
799 landscape.init ();
800
801 // Get file list
802 vector<string> files;
803 CPath::getPathContent (options.InLandscapeDir, false, false, true, files);
804
805 // Landscape bounding box
806 sint minx = 0x7fffffff;
807 sint miny = 0x7fffffff;
808 sint maxx = 0x80000000;
809 sint maxy = 0x80000000;
810
811 // The callback
812 CMyCallback callback;
813
814 // For each zone files
815 if (files.empty())
816 {
817 nlwarning ("Error : no zonew files found. Abort.");
818 }
819 else
820 {
821 uint i;
822 for (i=0; i<files.size (); i++)
823 {
824 // Progress
825 callback.DisplayString = "Loading zones";
826 callback.progress ((float)i/(float)files.size ());
827
828 // Zonew ?
829 if (NLMISC::toLowerAscii(CFile::getExtension (files[i])) == "zonew")
830 {
831 // Load it
832 try
833 {
834 // The zone
835 CZone zone;
836
837 // Load
838 CIFile inFile;
839 if (inFile.open (files[i]))
840 {
841 // Read the zone
842 zone.serial (inFile);
843
844 // Add the zone in the landscape
845 landscape.addZone (zone);
846
847 // Extand the bounding box
848 string name = CFile::getFilenameWithoutExtension (files[i]);
849 sint x = getXFromZoneName (name);
850 sint y = getYFromZoneName (name);
851 if (x<minx)
852 minx = x;
853 if (y<miny)
854 miny = y;
855 if (x>maxx)
856 maxx = x;
857 if (y>maxy)
858 maxy = y;
859 }
860 else
861 {
862 // Error in the log
863 nlwarning ("Error : can't open the file (%s) for reading", files[i].c_str ());
864 }
865 }
866 catch(const Exception &e)
867 {
868 // Error in the log
869 nlwarning ("Error loading zone file (%s) : %s", files[i].c_str (), e.what ());
870 }
871 }
872 }
873
874 // *** Create the igs
875 CIgContainer igs;
876 igs.init (minx, maxx, miny, maxy, options.InLandscapeDir.c_str ());
877
878 // *** Create a form container
879 CFormContainer formContainer;
880
881 // *** For each primitive files
882
883 // Get the primitive files liste
884 files.clear ();
885 for (i=0; i<options.PrimDirs.size(); i++)
886 CPath::getPathContent (options.PrimDirs[i], true, false, true, files);
887
888 // For each
889 uint fileCount = (uint)files.size ();
890 for (i=0; i<fileCount; i++)
891 {
892 // Primitive file ?
893 if (NLMISC::toLowerAscii(CFile::getExtension (files[i])) == "primitive")
894 {
895 // Progress bar
896 nlinfo (files[i].c_str());
897 callback.DisplayString = "Add primitives from "+CFile::getFilename(files[i]);
898 callback.progress ((float)i/(float)fileCount);
899 callback.pushCropedValues ((float)i/(float)fileCount, (float)(i+1)/(float)fileCount);
900
901 // Load it
902 try
903 {
904 // Load it
905 CIFile inFile;
906 if (inFile.open (files[i]))
907 {
908 // Open an xml stream
909 CIXml inXml;
910 inXml.init (inFile);
911
912 // Read it
913 CPrimitives primitives;
914 if (primitives.read (inXml.getRootNode (), files[i].c_str (), config))
915 {
916 // Look for primitives
917 addPointPrimitive (landscape, files[i].c_str (), CFile::getFileModificationDate (files[i]), *primitives.RootNode, igs, options, formContainer, callback);
918 }
919 else
920 {
921 // Error in the log
922 nlwarning ("Error : can't read the primitive file %s", files[i].c_str ());
923 }
924 }
925 else
926 {
927 // Error in the log
928 nlwarning ("Error : can't open the file (%s) for reading", files[i].c_str ());
929 }
930 }
931 catch(const Exception &e)
932 {
933 // Error in the log
934 nlwarning ("Error loading primitive file (%s) : %s", files[i].c_str (), e.what ());
935 }
936
937 // Progress bar
938 callback.popCropedValues ();
939 }
940 }
941
942 // *** Save igs
943
944 for (sint y=miny; y<=maxy; y++)
945 for (sint x=minx; x<=maxx; x++)
946 {
947 // Get the instance ref
948 CIgContainer::CIG &instance = igs.get (x, y);
949
950 // Good date ?
951 if (instance.Date)
952 {
953 // Get the final filename
954 string igFilename;
955 getZoneNameByCoord (x, y, igFilename);
956 igFilename = CPath::standardizePath (options.OutIGDir, true) + igFilename + ".ig";
957
958 // Something in the ig ?
959 if (!instance.Instances.empty ())
960 {
961 // Check date
962 if (CFile::fileExists (igFilename) && (instance.Date < CFile::getFileModificationDate (igFilename)))
963 {
964 outString ("SKIP " + CFile::getFilename (igFilename) + " \n");
965 }
966 else
967 {
968 // *** Snap to ground
969
970 // Get the zone bbox
971 const CZone *zone = landscape.getZone (getZoneId (x, y));
972 if (zone)
973 {
974 // Checks
975 nlassert (instance.Instances.size () == instance.AdditionnalInfo.size ());
976
977 // For each instances
978 uint i;
979 for (i=0; i<instance.Instances.size (); i++)
980 {
981 // Have to snap it ?
982 if (instance.AdditionnalInfo[i].Snap)
983 {
984 // Progress bar
985 callback.DisplayString = "Snap to ground " + CFile::getFilename (igFilename);
986 callback.progress ((float)i/(float)instance.Instances.size ());
987
988 // Get the zone bbox
989 CAABBoxExt zoneBBox = zone->getZoneBB ();
990
991 // The bbox used to select triangles
992 CAABBox bbox;
993 CVector &position = instance.Instances[i].Pos;
994 bbox.setCenter (CVector (position.x + SELECTION_EPSILON, position.y + SELECTION_EPSILON, zoneBBox.getMax ().z + SELECTION_EPSILON));
995 bbox.extend (CVector (position.x - SELECTION_EPSILON, position.y - SELECTION_EPSILON, zoneBBox.getMin ().z - SELECTION_EPSILON));
996
997 // Select some triangles
998 vector<CTrianglePatch> triangles;
999 landscape.buildTrianglesInBBox (bbox, triangles, 0);
1000
1001 // Ray trace triangles
1002 set<float> selectedHeight;
1003 uint j;
1004 for (j=0; j<triangles.size (); j++)
1005 {
1006 // Ref on triangle
1007 const CTriangle &triangle = triangles[j];
1008
1009 // Test this triangle
1010 if (triangleIntersect2DGround (triangle, position))
1011 {
1012 // build the plane
1013 CPlane plane;
1014 plane.make (triangle.V0, triangle.V1, triangle.V2);
1015
1016 // Get the final height
1017 CVector intersect = plane.intersect (bbox.getMin (), bbox.getMax ());
1018 selectedHeight.insert (intersect.z);
1019 }
1020 }
1021
1022 // Get its layer
1023 uint layer = instance.AdditionnalInfo[i].SnapLayer;
1024
1025 // Found some triangles ?
1026 const uint setSize = (uint)selectedHeight.size ();
1027 if (setSize)
1028 {
1029 // Look for the triangle in the good layer
1030 uint currentLayer = 0;
1031
1032 // Layer exist ?
1033 if (layer >= setSize)
1034 {
1035 // Error in the log
1036 nlwarning ("Error : Layer %d used by the primitive (%s) in the file (%s) doesn't exist. Select layer %d instead.",
1037 layer, instance.AdditionnalInfo[i].PrimitiveName.c_str (),
1038 instance.AdditionnalInfo[i].PrimitiveFile.c_str (), setSize-1);
1039
1040 // New layer
1041 layer = setSize-1;
1042 }
1043
1044 // Invert the layer number
1045 layer = setSize - layer - 1;
1046
1047 set<float>::iterator ite = selectedHeight.begin ();
1048 while (ite != selectedHeight.end ())
1049 {
1050 // Good layer ?
1051 if (currentLayer == layer)
1052 break;
1053
1054 // Next layer
1055 currentLayer++;
1056 ite++;
1057 }
1058
1059 // Should be found
1060 nlassert (ite != selectedHeight.end ());
1061
1062 // Get the final height
1063 position.z = *ite;
1064 }
1065 else
1066 {
1067 // Error in the log
1068 nlwarning ("Error : No landscape under the primitive (%s) in the file (%s).",
1069 instance.AdditionnalInfo[i].PrimitiveName.c_str (), instance.AdditionnalInfo[i].PrimitiveFile.c_str ());
1070 }
1071 }
1072 }
1073 }
1074 else
1075 {
1076 // Error in the log
1077 nlwarning ("Error : No landscape for the zone (%s)", CFile::getFilename (igFilename).c_str ());
1078 }
1079
1080 // Build an instance group
1081 CInstanceGroup ig;
1082 CVector vGlobalPos = CVector::Null;
1083 vector<CCluster> Portals;
1084 vector<CPortal> Clusters;
1085 ig.build (vGlobalPos, instance.Instances, Portals, Clusters);
1086
1087 // *** Save the ig file
1088
1089 try
1090 {
1091 // The file
1092 COFile outFile;
1093 if (outFile.open (igFilename))
1094 {
1095 ig.serial (outFile);
1096
1097 // Done
1098 outString ("OK " + CFile::getFilename (igFilename) + " \n");
1099 }
1100 else
1101 {
1102 // Error in the log
1103 nlwarning ("Error : can't open the file (%s) for writing.", igFilename.c_str ());
1104 }
1105 }
1106 catch (const Exception &e)
1107 {
1108 // Error in the log
1109 nlwarning ("Error writing the file (%s) : %s", igFilename.c_str (), e.what ());
1110 }
1111 }
1112 }
1113 else
1114 {
1115 // File exist ?
1116 if (CFile::fileExists (igFilename))
1117 {
1118 // Done
1119 outString ("REMOVE " + CFile::getFilename (igFilename) + " \n");
1120
1121 // Remove it
1122 if (!CFile::deleteFile(igFilename))
1123 {
1124 // Error in the log
1125 nlwarning ("Error : Can't remove the file (%s)", igFilename.c_str ());
1126 }
1127 }
1128 }
1129 }
1130 }
1131 }
1132 }
1133 catch (const Exception &e)
1134 {
1135 string sTmp = string("ERROR : ") + e.what();
1136 outString (sTmp);
1137 }
1138
1139 return 1;
1140 }
1141
1142
1143
1144
1145
1146
1147
1148
1149 /*
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159 // *** Snap to the ground
1160
1161 // Get zone coordinates
1162 sint x = (sint)floor (position.x / options.CellSize);
1163 sint y = (sint)floor (position.y / options.CellSize);
1164
1165 */