aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-12-13 20:54:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/tools/leveldesign/prim_export/main.cpp

1162 lines
30 KiB
C++
Raw Normal View History

Remove duplicate cfg data
2014-02-21 19:39:24 +00:00
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdio.h>
#include <string>
#include <sstream>
#include "nel/misc/config_file.h"
#include "nel/misc/file.h"
#include "nel/misc/i_xml.h"
#include "nel/misc/path.h"
#include "nel/misc/progress_callback.h"
#include "nel/ligo/primitive.h"
#include "nel/ligo/ligo_config.h"
#include "nel/georges/u_form.h"
#include "nel/georges/u_form_elm.h"
#include "nel/georges/u_form_loader.h"
#include "nel/3d/zone.h"
#include "nel/3d/landscape.h"
#include "nel/3d/scene_group.h"
#ifdef NL_OS_WINDOWS
#include <windows.h>
#endif // NL_OS_WINDOWS
// ***************************************************************************
/*
Documentation
This tool generates ig from primitive files
- Load the landscape zone. Load all the *.zonew found in the InLandscapeDir and add them in a landscape
- For each primitive files found in PrimDirs
- Look for points with the "prim" primitive class
- Get the good height on the landscape
- Get the .plant georges file associed with the point
- Add an entry in the good ig file
- Set the shape filename
- Set the plant name
- 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)
- Set the ig date
- The date is the most recent date between the .zonew .plant .primitive files associed with the ig.
- Snap to ground only modified or created ig
- Save the modified or created ig files
*/
// ***************************************************************************
using namespace std;
using namespace NLMISC;
using namespace NL3D;
using namespace NLGEORGES;
using namespace NLLIGO;
// ***************************************************************************
// Utility functions
// ***************************************************************************
#define SELECTION_EPSILON 0.1f
#define BAR_LENGTH 21
const char *progressbar[BAR_LENGTH]=
{
"[ ]",
"[. ]",
"[.. ]",
"[... ]",
"[.... ]",
"[..... ]",
"[...... ]",
"[....... ]",
"[........ ]",
"[......... ]",
"[.......... ]",
"[........... ]",
"[............ ]",
"[............. ]",
"[.............. ]",
"[............... ]",
"[................ ]",
"[................. ]",
"[.................. ]",
"[................... ]",
"[....................]"
};
// ***************************************************************************
// Progress bar
class CMyCallback : public IProgressCallback
{
public:
void progress (float progress)
{
// Delta time, update max all the 300 ms
static sint64 time = CTime::getLocalTime ();
sint64 currentTime = CTime::getLocalTime ();
if ((currentTime - time) > 300)
{
// Crop the progress bar value
progress = getCropedValue (progress);
// Progress bar
char msg[512];
uint pgId= (uint)(progress*(float)BAR_LENGTH);
pgId= min(pgId, (uint)(BAR_LENGTH-1));
sprintf (msg, "\r%s: %s", DisplayString.c_str (), progressbar[pgId]);
uint i;
for (i=(uint)strlen(msg); i<79; i++)
msg[i]=' ';
msg[i]=0;
printf ("%s", msg);
printf ("\r");
time = currentTime;
}
}
};
// ***************************************************************************
sint getXFromZoneName (const string &ZoneName)
{
string xStr, yStr;
uint32 i = 0;
while (ZoneName[i] != '_')
{
yStr += ZoneName[i]; ++i;
if (i == ZoneName.size())
return -1;
}
++i;
while (i < ZoneName.size())
{
xStr += ZoneName[i]; ++i;
}
return ((xStr[0] - 'A')*26 + (xStr[1] - 'A'));
}
// ***************************************************************************
bool getZoneCoordByName(const char * name, uint16& x, uint16& y)
{
uint i;
std::string zoneName(name);
// y
std::string::size_type ind1 = zoneName.find("_");
if(ind1 == std::string::npos)
{
nlwarning("bad file name");
return false;
}
std::string ystr = zoneName.substr(0,ind1);
for(i=0; i<ystr.length(); i++)
{
if(!isdigit(ystr[i]))
{
nlwarning("y code size is not a 2 characters code");
return false;
}
}
NLMISC::fromString(ystr, y);
y = -y;
// x
x = 0;
uint ind2 = (uint)zoneName.length();
if((ind2-ind1-1)!=2)
{
nlwarning("x code size is not a 2 characters code");
return false;
}
std::string xstr = zoneName.substr(ind1+1,ind2-ind1-1);
for(i=0; i<xstr.length(); i++)
{
if (isalpha(xstr[i]))
{
x *= 26;
x += (tolower(xstr[i])-'a');
}
else
{
nlwarning("invalid");
return false;
}
}
return true;
}
// ***************************************************************************
sint getYFromZoneName (const string &ZoneName)
{
string xStr, yStr;
uint32 i = 0;
while (ZoneName[i] != '_')
{
yStr += ZoneName[i]; ++i;
if (i == ZoneName.size())
return 1;
}
++i;
while (i < ZoneName.size())
{
xStr += ZoneName[i]; ++i;
}
sint y = 0;
NLMISC::fromString(yStr, y);
return -y;
}
// ***************************************************************************
void outString (const string &sText)
{
createDebug ();
InfoLog->displayRaw(sText.c_str());
}
// ***************************************************************************
string getPrimitiveName (const IPrimitive &primitive)
{
string name;
primitive.getPropertyByName ("name", name);
return name;
}
// ***************************************************************************
uint16 getZoneId (sint x, sint y)
{
return (uint16)((((-y)-1)<<8) + x);
}
// ***************************************************************************
void getLettersFromNum(uint16 num, std::string& code)
{
if(num>26*26)
{
nlwarning("zone index too high");
return;
}
code.resize(0);
uint16 remainder = num%26;
code += 'A' + num/26;
code += 'A' + remainder;
}
// ***************************************************************************
void getZoneNameByCoord(sint16 x, sint16 y, std::string& zoneName)
{
if ((y>0) || (y<-255) || (x<0) || (x>255))
return;
zoneName = toString(-y) + "_";
zoneName += ('A' + (x/26));
zoneName += ('A' + (x%26));
}
// ***************************************************************************
bool triangleIntersect2DGround (const CTriangle &tri, const CVector &pos0)
{
const CVector &p0= tri.V0;
const CVector &p1= tri.V1;
const CVector &p2= tri.V2;
// Test if the face enclose the pos in X/Y plane.
// NB: compute and using a BBox to do a rapid test is not a very good idea, since it will
// add an overhead which is NOT negligeable compared to the following test.
float a,b,c; // 2D cartesian coefficients of line in plane X/Y.
// Line p0-p1.
a= -(p1.y-p0.y);
b= (p1.x-p0.x);
c= -(p0.x*a + p0.y*b);
if( (a*pos0.x + b*pos0.y + c) < 0) return false;
// Line p1-p2.
a= -(p2.y-p1.y);
b= (p2.x-p1.x);
c= -(p1.x*a + p1.y*b);
if( (a*pos0.x + b*pos0.y + c) < 0) return false;
// Line p2-p0.
a= -(p0.y-p2.y);
b= (p0.x-p2.x);
c= -(p2.x*a + p2.y*b);
if( (a*pos0.x + b*pos0.y + c) < 0) return false;
return true;
}
// ***************************************************************************
// CExportOptions
// ***************************************************************************
struct CExportOptions
{
std::string InLandscapeDir; // Directory where to get .zonew files
std::string OutIGDir; // Directory where to put IG
std::string LandBankFile; // The .smallbank file associated with the landscape
std::string LandFarBankFile; // The .farbank file
float CellSize; // Typically 160.0
std::string LandTileNoiseDir; // Directory where to get displacement map
std::vector<std::string> PrimDirs; // Directory to parse for .flora and .prim associated
// This is here we get continent.cfg file
std::string FormDir; // Directory to get georges dfn
std::string WorldEditorFiles;
CExportOptions ();
bool loadcf (NLMISC::CConfigFile &cf);
};
// ***************************************************************************
CExportOptions::CExportOptions ()
{
CellSize = 160.0f;
}
// ***************************************************************************
bool CExportOptions::loadcf (CConfigFile &cf)
{
// Out
CConfigFile::CVar &cvOutIGDir = cf.getVar("OutIGDir");
OutIGDir = cvOutIGDir.asString();
// In
CConfigFile::CVar &cvInLandscapeDir = cf.getVar("ZoneWDir");
InLandscapeDir = cvInLandscapeDir.asString();
CConfigFile::CVar &cvLandBankFile = cf.getVar("SmallBank");
LandBankFile = cvLandBankFile.asString();
CConfigFile::CVar &cvLandFarBankFile = cf.getVar("FarBank");
LandFarBankFile = cvLandFarBankFile.asString();
CConfigFile::CVar &cvLandTileNoiseDir = cf.getVar("DisplaceDir");
LandTileNoiseDir = cvLandTileNoiseDir.asString();
CConfigFile::CVar &cvCellSize = cf.getVar("CellSize");
CellSize = cvCellSize.asFloat();
CConfigFile::CVar &cvPrimDir = cf.getVar("PrimDirs");
uint i;
PrimDirs.resize (cvPrimDir.size());
for (i=0; i<(uint)cvPrimDir.size(); i++)
PrimDirs[i] = cvPrimDir.asString(i);
CConfigFile::CVar &cvFormDir = cf.getVar("FormDir");
FormDir = cvFormDir.asString();
CConfigFile::CVar &cvWorldEditorFiles = cf.getVar("WorldEditorFiles");
WorldEditorFiles = cvWorldEditorFiles.asString();
return true;
}
// ***************************************************************************
// Array of ig
class CIgContainer
{
public:
// An ig
class CIG
{
public:
// Additionnal parameters
class CAdditionnalParam
{
public:
CAdditionnalParam (uint snapLayer, const string &primitiveName, const string &primitiveFile, bool snap) : SnapLayer (snapLayer), PrimitiveName (primitiveName), PrimitiveFile (primitiveFile)
{
Snap = snap;
};
// Snap over the landscape
bool Snap;
// Snap layer
uint SnapLayer;
// Primitive name
string PrimitiveName;
// Primitive file
string PrimitiveFile;
};
// Default ctor
CIG ()
{
Date = 0;
}
// Update date if new date is more recent
void updateDate (uint32 newDate)
{
if (newDate > Date)
Date = newDate;
}
// The ig
CInstanceGroup::TInstanceArray Instances;
// Additionnal information
vector<CAdditionnalParam> AdditionnalInfo;
// The ig date
uint32 Date;
};
// Init the container
void init (sint minx, sint maxx, sint miny, sint maxy, const char *zoneDir)
{
// Save the values
Minx = minx;
Miny = miny;
Maxx = maxx+1;
Maxy = maxy+1;
Width = maxx - minx + 1;
// Resize the array
IGS.clear ();
IGS.resize (Width*(maxy-miny+1));
// Directory
string dir = CPath::standardizePath (zoneDir, true);
// For each zone
for (sint y=miny; y<=maxy; y++)
for (sint x=minx; x<=maxx; x++)
{
// The zone name
string zoneFilename;
getZoneNameByCoord ((sint16)x, (sint16)y, zoneFilename);
zoneFilename = dir + zoneFilename + ".zonew";
// Get the date
if (CFile::fileExists (zoneFilename))
get (x, y).Date = CFile::getFileModificationDate (zoneFilename);
}
}
// Get the ig
CIG &get (sint x, sint y)
{
return IGS[(x-Minx)+(y-Miny)*Width];
}
// Size and position
uint Width;
sint Minx;
sint Miny;
sint Maxx;
sint Maxy;
// The ig vector
vector<CIG> IGS;
};
// ***************************************************************************
// Array of ig
class CFormContainer
{
private:
// The map value
struct CValue
{
CValue (CSmartPtr<UForm> ptr, uint32 date) : Ptr (ptr), Date (date) {};
// The form pointer
CSmartPtr<UForm> Ptr;
// Its date
uint32 Date;
};
public:
// Default ctor
CFormContainer ()
{
_FormLoader = UFormLoader::createLoader ();
}
// Dtor
~CFormContainer ()
{
UFormLoader::releaseLoader (_FormLoader);
}
// The form container
const UForm *loadForm (const char *formName, uint32 &formDate)
{
// The form
UForm *form = NULL;
formDate = 0;
// In the map ?
string formShortName = NLMISC::toLower(CFile::getFilename (formName));
map<string, CValue >::iterator ite = _FormMap.find (formShortName);
if (ite == _FormMap.end ())
{
// Look for this plant file
string path = CPath::lookup (formName, false, false, false);
if (!path.empty ())
{
// Load it !
form = _FormLoader->loadForm (path.c_str ());
if (form)
{
// Get dependencies
set<string> dependencies;
form->getDependencies (dependencies);
// Get dependencies dates
formDate = 0;
set<string>::const_iterator ite = dependencies.begin ();
while (ite != dependencies.end ())
{
// Get the path name
string path = CPath::lookup (*ite, false, false, false);
if (!path.empty ())
{
// Get the file date
uint32 date = CFile::getFileModificationDate (path);
// Update date
if (date > formDate)
formDate = date;
}
// Next dependency
ite++;
}
// Add it
_FormMap.insert (map<string, CValue >::value_type (formShortName, CValue (form, formDate)));
}
else
{
// Error in the log
nlwarning ("Error : Can't load the form (%s)", path.c_str ());
}
}
}
else
{
form = ite->second.Ptr;
formDate = ite->second.Date;
}
// Return the form or NULL
return form;
}
private:
// The form loader
UFormLoader *_FormLoader;
// The form map
map<string, CValue > _FormMap;
};
// ***************************************************************************
void addPointPrimitive (CLandscape &landscape, const char *primFilename, uint32 primFileDate, const IPrimitive &primitive, CIgContainer &igs,
const CExportOptions &options, CFormContainer &formContainer, IProgressCallback &callback)
{
// Is this primitive a point ?
const CPrimPoint *point = dynamic_cast<const CPrimPoint *>(&primitive);
if (point)
{
// Get the class name
string className;
if (point->getPropertyByName ("class", className))
{
// Is it a plant ?
if (className == "prim")
{
// Get its plant name
string plantFilename;
if (point->getPropertyByName ("form", plantFilename))
{
// Add an extension
if (NLMISC::toLower(CFile::getExtension (plantFilename)) != "plant")
plantFilename += ".plant";
// Load this form
uint32 formDate;
const UForm *form = formContainer.loadForm (plantFilename.c_str (), formDate);
if (form)
{
// Get the parameters
string shape;
if (form->getRootNode ().getValueByName (shape, "3D.Shape"))
{
// Get the position
CVector position = point->Point;
// Get the scale
string scaleText;
float scale = 1;
if (point->getPropertyByName ("scale", scaleText))
scale = (float) atof (scaleText.c_str ());
// Get zone coordinates
sint x = (sint)floor (position.x / options.CellSize);
sint y = (sint)floor (position.y / options.CellSize);
if ( (x >= igs.Minx) && (x < igs.Maxx) && (y >= igs.Miny) && (y < igs.Maxy) )
{
// Get its layer
string text;
uint layer = 0;
if (point->getPropertyByName ("depth", text))
{
layer = atoi (text.c_str ());
}
// Not snap yet
position.z = 0;
// Snap flag
bool snap = true;
if (point->getPropertyByName ("snap", text))
snap = text != "false";
// Get height
if (!snap && point->getPropertyByName ("height", text))
position.z = (float)atof(text.c_str());
// *** Add the instance
// Create it
CInstanceGroup::CInstance instance;
instance.Pos = position;
instance.Rot = CQuat(CVector::K, point->Angle);
instance.Scale = CVector (scale, scale, scale);
instance.nParent = -1;
instance.Name = shape;
instance.InstanceName = NLMISC::toLower(CFile::getFilename (plantFilename));
// Get the instance group ref
CIgContainer::CIG &instances = igs.get (x, y);
instances.Instances.push_back (instance);
instances.AdditionnalInfo.push_back (CIgContainer::CIG::CAdditionnalParam (layer,
getPrimitiveName (primitive), primFilename, snap));
// Update the date with the primitive filename
instances.updateDate (primFileDate);
// Update the date with the plant filename
instances.updateDate (formDate);
// Update the date with the zone filename
string zoneFilename;
getZoneNameByCoord (x, y, zoneFilename);
zoneFilename = CPath::standardizePath (options.InLandscapeDir, true) + zoneFilename + ".zonew";
// todo hulud needed ? instances.updateDate (zoneFilename);
}
}
else
{
// Error in the log
nlwarning ("Error : Can't get a shape name in the form (%s) for the primitive (%s) in the file (%s)",
plantFilename.c_str (), getPrimitiveName (primitive).c_str (), primFilename);
}
}
else
{
// Error in the log
nlwarning ("Error : can't load the file (%s) used by the primitive (%s) in the file (%s).", plantFilename.c_str (),
getPrimitiveName (primitive).c_str (), primFilename);
}
}
else
{
// Error in the log
nlwarning ("Error : in file (%s), the primitive (%s) has no plant file.", primFilename, getPrimitiveName (primitive).c_str ());
}
}
}
}
// Look in children
uint numChildren = primitive.getNumChildren ();
for (uint i=0; i<numChildren; i++)
{
// Progress bar
callback.progress ((float)i/(float)numChildren);
callback.pushCropedValues ((float)i/(float)numChildren, (float)(i+1)/(float)numChildren);
// Get the child
const IPrimitive *child;
nlverify (primitive.getChild (child, i));
addPointPrimitive (landscape, primFilename, primFileDate, *child, igs, options, formContainer, callback);
// Progress bar
callback.popCropedValues ();
}
}
// ***************************************************************************
int main (int argc, char**argv)
{
new NLMISC::CApplicationContext;
// Filter addSearchPath
NLMISC::createDebug();
InfoLog->addNegativeFilter ("addSearchPath");
// Register ligo
NLLIGO::Register ();
if (argc != 2)
{
printf ("Use : prim_export configfile.cfg\n");
printf ("\nExample of config.cfg\n\n");
printf ("\n// Export Options\n");
printf ("OutIGDir = \"c:/temp/outIG\";\n");
printf ("ZoneWDir = \"c:/temp/inZoneW\";\n");
printf ("SmallBank = \"//amiga/3d/database/landscape/_texture_tiles/jungle/jungle.bank\";\n");
printf ("FarBank = \"//amiga/3d/database/landscape/_texture_tiles/jungle/jungle.farbank\";\n");
printf ("DisplaceDir = \"//amiga/3d/database/landscape/_texture_tiles/displace\";\n");
printf ("CellSize = 160.0;\n");
printf ("PrimDirs = {\"//server/leveldesign/world/fyros\"};\n");
return -1;
}
try
{
// Load the config file
CExportOptions options;
string sTmp = string("loading cfg file : ") + string(argv[1]) + "\n";
// outString(sTmp);
{
CConfigFile cf;
cf.load (argv[1]);
if (!options.loadcf(cf))
{
sTmp = "Error : options not loaded from config file\n";
outString (sTmp);
return -1;
}
}
// *** Add pathes in the search path for georges forms
CPath::addSearchPath (options.FormDir, true, true);
CPath::addSearchPath (options.WorldEditorFiles, true, true);
// Ligo config
CLigoConfig config;
string path = CPath::lookup ("world_editor_classes.xml", false, false, false);
if (path.empty())
nlwarning ("Error : File world_editor_classes.xml not found");
else
config.readPrimitiveClass (path.c_str(), false);
// *** Load the landscape
// Init the landscape
CLandscape landscape;
landscape.init ();
// Get file list
vector<string> files;
CPath::getPathContent (options.InLandscapeDir, false, false, true, files);
// Landscape bounding box
sint minx = 0x7fffffff;
sint miny = 0x7fffffff;
sint maxx = 0x80000000;
sint maxy = 0x80000000;
// The callback
CMyCallback callback;
// For each zone files
if (files.empty())
{
nlwarning ("Error : no zonew files found. Abort.");
}
else
{
uint i;
for (i=0; i<files.size (); i++)
{
// Progress
callback.DisplayString = "Loading zones";
callback.progress ((float)i/(float)files.size ());
// Zonew ?
if (NLMISC::toLower(CFile::getExtension (files[i])) == "zonew")
{
// Load it
try
{
// The zone
CZone zone;
// Load
CIFile inFile;
if (inFile.open (files[i]))
{
// Read the zone
zone.serial (inFile);
// Add the zone in the landscape
landscape.addZone (zone);
// Extand the bounding box
string name = CFile::getFilenameWithoutExtension (files[i]);
sint x = getXFromZoneName (name);
sint y = getYFromZoneName (name);
if (x<minx)
minx = x;
if (y<miny)
miny = y;
if (x>maxx)
maxx = x;
if (y>maxy)
maxy = y;
}
else
{
// Error in the log
nlwarning ("Error : can't open the file (%s) for reading", files[i].c_str ());
}
}
catch(const Exception &e)
{
// Error in the log
nlwarning ("Error loading zone file (%s) : %s", files[i].c_str (), e.what ());
}
}
}
// *** Create the igs
CIgContainer igs;
igs.init (minx, maxx, miny, maxy, options.InLandscapeDir.c_str ());
// *** Create a form container
CFormContainer formContainer;
// *** For each primitive files
// Get the primitive files liste
files.clear ();
for (i=0; i<options.PrimDirs.size(); i++)
CPath::getPathContent (options.PrimDirs[i], true, false, true, files);
// For each
uint fileCount = (uint)files.size ();
for (i=0; i<fileCount; i++)
{
// Primitive file ?
if (NLMISC::toLower(CFile::getExtension (files[i])) == "primitive")
{
// Progress bar
nlinfo (files[i].c_str());
callback.DisplayString = "Add primitives from "+CFile::getFilename(files[i]);
callback.progress ((float)i/(float)fileCount);
callback.pushCropedValues ((float)i/(float)fileCount, (float)(i+1)/(float)fileCount);
// Load it
try
{
// Load it
CIFile inFile;
if (inFile.open (files[i]))
{
// Open an xml stream
CIXml inXml;
inXml.init (inFile);
// Read it
CPrimitives primitives;
if (primitives.read (inXml.getRootNode (), files[i].c_str (), config))
{
// Look for primitives
addPointPrimitive (landscape, files[i].c_str (), CFile::getFileModificationDate (files[i]), *primitives.RootNode, igs, options, formContainer, callback);
}
else
{
// Error in the log
nlwarning ("Error : can't read the primitive file %s", files[i].c_str ());
}
}
else
{
// Error in the log
nlwarning ("Error : can't open the file (%s) for reading", files[i].c_str ());
}
}
catch(const Exception &e)
{
// Error in the log
nlwarning ("Error loading primitive file (%s) : %s", files[i].c_str (), e.what ());
}
// Progress bar
callback.popCropedValues ();
}
}
// *** Save igs
for (sint y=miny; y<=maxy; y++)
for (sint x=minx; x<=maxx; x++)
{
// Get the instance ref
CIgContainer::CIG &instance = igs.get (x, y);
// Good date ?
if (instance.Date)
{
// Get the final filename
string igFilename;
getZoneNameByCoord (x, y, igFilename);
igFilename = CPath::standardizePath (options.OutIGDir, true) + igFilename + ".ig";
// Something in the ig ?
if (!instance.Instances.empty ())
{
// Check date
if (CFile::fileExists (igFilename) && (instance.Date < CFile::getFileModificationDate (igFilename)))
{
outString ("SKIP " + CFile::getFilename (igFilename) + " \n");
}
else
{
// *** Snap to ground
// Get the zone bbox
const CZone *zone = landscape.getZone (getZoneId (x, y));
if (zone)
{
// Checks
nlassert (instance.Instances.size () == instance.AdditionnalInfo.size ());
// For each instances
uint i;
for (i=0; i<instance.Instances.size (); i++)
{
// Have to snap it ?
if (instance.AdditionnalInfo[i].Snap)
{
// Progress bar
callback.DisplayString = "Snap to ground " + CFile::getFilename (igFilename);
callback.progress ((float)i/(float)instance.Instances.size ());
// Get the zone bbox
CAABBoxExt zoneBBox = zone->getZoneBB ();
// The bbox used to select triangles
CAABBox bbox;
CVector &position = instance.Instances[i].Pos;
bbox.setCenter (CVector (position.x + SELECTION_EPSILON, position.y + SELECTION_EPSILON, zoneBBox.getMax ().z + SELECTION_EPSILON));
bbox.extend (CVector (position.x - SELECTION_EPSILON, position.y - SELECTION_EPSILON, zoneBBox.getMin ().z - SELECTION_EPSILON));
// Select some triangles
vector<CTrianglePatch> triangles;
landscape.buildTrianglesInBBox (bbox, triangles, 0);
// Ray trace triangles
set<float> selectedHeight;
uint j;
for (j=0; j<triangles.size (); j++)
{
// Ref on triangle
const CTriangle &triangle = triangles[j];
// Test this triangle
if (triangleIntersect2DGround (triangle, position))
{
// build the plane
CPlane plane;
plane.make (triangle.V0, triangle.V1, triangle.V2);
// Get the final height
CVector intersect = plane.intersect (bbox.getMin (), bbox.getMax ());
selectedHeight.insert (intersect.z);
}
}
// Get its layer
uint layer = instance.AdditionnalInfo[i].SnapLayer;
// Found some triangles ?
const uint setSize = (uint)selectedHeight.size ();
if (setSize)
{
// Look for the triangle in the good layer
uint currentLayer = 0;
// Layer exist ?
if (layer >= setSize)
{
// Error in the log
nlwarning ("Error : Layer %d used by the primitive (%s) in the file (%s) doesn't exist. Select layer %d instead.",
layer, instance.AdditionnalInfo[i].PrimitiveName.c_str (),
instance.AdditionnalInfo[i].PrimitiveFile.c_str (), setSize-1);
// New layer
layer = setSize-1;
}
// Invert the layer number
layer = setSize - layer - 1;
set<float>::iterator ite = selectedHeight.begin ();
while (ite != selectedHeight.end ())
{
// Good layer ?
if (currentLayer == layer)
break;
// Next layer
currentLayer++;
ite++;
}
// Should be found
nlassert (ite != selectedHeight.end ());
// Get the final height
position.z = *ite;
}
else
{
// Error in the log
nlwarning ("Error : No landscape under the primitive (%s) in the file (%s).",
instance.AdditionnalInfo[i].PrimitiveName.c_str (), instance.AdditionnalInfo[i].PrimitiveFile.c_str ());
}
}
}
}
else
{
// Error in the log
nlwarning ("Error : No landscape for the zone (%s)", CFile::getFilename (igFilename).c_str ());
}
// Build an instance group
CInstanceGroup ig;
CVector vGlobalPos = CVector::Null;
vector<CCluster> Portals;
vector<CPortal> Clusters;
ig.build (vGlobalPos, instance.Instances, Portals, Clusters);
// *** Save the ig file
try
{
// The file
COFile outFile;
if (outFile.open (igFilename))
{
ig.serial (outFile);
// Done
outString ("OK " + CFile::getFilename (igFilename) + " \n");
}
else
{
// Error in the log
nlwarning ("Error : can't open the file (%s) for writing.", igFilename.c_str ());
}
}
catch (const Exception &e)
{
// Error in the log
nlwarning ("Error writing the file (%s) : %s", igFilename.c_str (), e.what ());
}
}
}
else
{
// File exist ?
if (CFile::fileExists (igFilename))
{
// Done
outString ("REMOVE " + CFile::getFilename (igFilename) + " \n");
// Remove it
if (remove (igFilename.c_str ()) != 0)
{
// Error in the log
nlwarning ("Error : Can't remove the file (%s)", igFilename.c_str ());
}
}
}
}
}
}
}
catch (const Exception &e)
{
string sTmp = string("ERROR : ") + e.what();
outString (sTmp);
}
return 1;
}
/*
// *** Snap to the ground
// Get zone coordinates
sint x = (sint)floor (position.x / options.CellSize);
sint y = (sint)floor (position.y / options.CellSize);
*/
Reference in a new issue Copy permalink