QString AndroidToolChain::makeCommand(const Environment &env) const
{
FileName makePath = AndroidConfigurations::currentConfig().makePath();
if (makePath.exists())
return makePath.toString();
const Utils::FileNameList extraDirectories
= Utils::transform(AndroidConfigurations::currentConfig().makeExtraSearchDirectories(),
[](const QString &s) { return Utils::FileName::fromString(s); });
if (HostOsInfo::isWindowsHost()) {
makePath = env.searchInPath("ma-make.exe", extraDirectories);
if (!makePath.isEmpty())
return makePath.toString();
makePath = env.searchInPath("mingw32-make", extraDirectories);
return makePath.isEmpty() ? QLatin1String("mingw32-make") : makePath.toString();
}
makePath = env.searchInPath("make", extraDirectories);
return makePath.isEmpty() ? "make" : makePath.toString();
}
void QmakeKitInformation::setup(Kit *k)
{
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k);
if (!version)
return;
FileName spec = QmakeKitInformation::mkspec(k);
if (spec.isEmpty())
spec = version->mkspec();
ToolChain *tc = ToolChainKitInformation::toolChain(k);
if (!tc || (!tc->suggestedMkspecList().empty() && !tc->suggestedMkspecList().contains(spec))) {
ToolChain *possibleTc = 0;
foreach (ToolChain *current, ToolChainManager::toolChains()) {
if (version->qtAbis().contains(current->targetAbi())) {
possibleTc = current;
if (current->suggestedMkspecList().contains(spec))
break;
}
}
ToolChainKitInformation::setToolChain(k, possibleTc);
}
// DataIO_OpenDx::ReadData()
int DataIO_OpenDx::ReadData(FileName const& fname,
DataSetList& datasetlist, std::string const& dsname)
{
// Add grid data set. Default to float for now.
DataSet* ds = datasetlist.AddSet( DataSet::GRID_FLT, dsname, "GRID" );
if (ds==0) return 1;
if (LoadGrid(fname.full(), *ds)) {
// Load failed. Erase grid data set.
datasetlist.RemoveSet( ds );
return 1;
}
return 0;
}
/* main function in embree namespace */
int main(int argc, char** argv)
{
/* create stream for parsing */
Ref<ParseStream> stream = new ParseStream(new CommandLineStream(argc, argv));
/* parse command line */
parseCommandLine(stream, FileName());
if (g_numThreads)
g_rtcore += ",threads=" + std::stringOf(g_numThreads);
if (g_numBenchmarkFrames)
g_rtcore += ",benchmark=1";
/* load scene */
if (filename.str() != "")
loadOBJ(filename,one,g_obj_scene);
/* initialize ray tracing core */
init(g_rtcore.c_str());
/* send model */
set_scene(&g_obj_scene);
/* benchmark mode */
if (g_numBenchmarkFrames)
renderBenchmark(outFilename);
/* render to disk */
if (outFilename.str() != "")
renderToFile(outFilename);
/* interactive mode */
if (g_interactive) {
initWindowState(argc,argv,tutorialName, g_width, g_height, g_fullscreen);
enterWindowRunLoop();
}
return 0;
}
///
/// Returns all arguments
/// That is: possbile subpath
/// spec
/// config arguemnts
/// moreArguments
/// user arguments
QString QMakeStep::allArguments(bool shorted)
{
QmakeBuildConfiguration *bc = qmakeBuildConfiguration();
QStringList arguments;
if (bc->subNodeBuild())
arguments << QDir::toNativeSeparators(bc->subNodeBuild()->path());
else if (shorted)
arguments << QDir::toNativeSeparators(QFileInfo(project()->projectFilePath()).fileName());
else
arguments << QDir::toNativeSeparators(project()->projectFilePath());
arguments << QLatin1String("-r");
bool userProvidedMkspec = false;
for (QtcProcess::ConstArgIterator ait(m_userArgs); ait.next(); ) {
if (ait.value() == QLatin1String("-spec")) {
if (ait.next()) {
userProvidedMkspec = true;
break;
}
}
}
FileName specArg = mkspec();
if (!userProvidedMkspec && !specArg.isEmpty())
arguments << QLatin1String("-spec") << specArg.toUserOutput();
// Find out what flags we pass on to qmake
arguments << bc->configCommandLineArguments();
arguments << deducedArguments();
QString args = QtcProcess::joinArgs(arguments);
// User arguments
QtcProcess::addArgs(&args, m_userArgs);
// moreArgumentsAfter
foreach (const QString &arg, deducedArgumentsAfter())
QtcProcess::addArg(&args, arg);
return args;
}
SubversionResponse SubversionPlugin::runSvn(const QString &workingDir,
const QStringList &arguments, int timeOut,
unsigned flags, QTextCodec *outputCodec) const
{
const FileName executable = m_settings.binaryPath();
SubversionResponse response;
if (executable.isEmpty()) {
response.error = true;
response.message =tr("No subversion executable specified.");
return response;
}
const SynchronousProcessResponse sp_resp =
VcsBasePlugin::runVcs(workingDir, executable, arguments, timeOut,
flags, outputCodec);
response.error = sp_resp.result != SynchronousProcessResponse::Finished;
if (response.error)
response.message = sp_resp.exitMessage(executable.toString(), timeOut);
response.stdErr = sp_resp.stdErr;
response.stdOut = sp_resp.stdOut;
return response;
}
void TestProject::checkCurrent()
{
Project* project = SessionManager::startupProject ();
CustomRunConfiguration* configuration = parse (project);
if (configuration == NULL)
{
return;
}
IDocument* document = EditorManager::currentDocument ();
if (document == NULL)
{
return;
}
FileName file = document->filePath();
QStringList files = project->files (Project::ExcludeGeneratedFiles);
if (!files.contains (file.toString ()))
{
return;
}
runTestsForFiles (FileNameList () << file, configuration);
}
/*! store an EXR file to disk */
void storeExr(const Ref<Image>& img, const FileName& filename)
{
Imf::Array2D<Imf::Rgba> pixels(img->height,img->width);
for (size_t y=0; y<img->height; y++) {
for (size_t x=0; x<img->width; x++) {
const Color4 c = img->get(x,y);
pixels[y][x] = Imf::Rgba(c.r,c.g,c.b,c.a);
}
}
Imf::RgbaOutputFile file(filename.c_str(), img->width, img->height, Imf::WRITE_RGBA);
file.setFrameBuffer(&pixels[0][0], 1, img->width);
file.writePixels(img->height);
}
bool IOMapOTMM::loadMap(Map& map, const FileName& identifier, bool showdialog) {
if(showdialog) gui.CreateLoadBar(wxT("Loading OTMM map..."));
DiskNodeFileReadHandle f(nstr(identifier.GetFullPath()));
if(f.isOk() == false) {
error(wxT("Couldn't open file for reading\nThe error reported was: ") + wxstr(f.getErrorMessage()));
return false;
}
bool ret = loadMap(map, f, identifier, showdialog);
if(showdialog) gui.DestroyLoadBar();
return ret;
}
bool Materials::unserializeMaterials(const FileName& filename, pugi::xml_node node, wxString& error, wxArrayString& warnings)
{
wxString warning;
pugi::xml_attribute attribute;
for(pugi::xml_node childNode = node.first_child(); childNode; childNode = childNode.next_sibling()) {
const std::string& childName = as_lower_str(childNode.name());
if(childName == "include") {
if(!(attribute = childNode.attribute("file"))) {
continue;
}
FileName includeName;
includeName.SetPath(filename.GetPath());
includeName.SetFullName(wxString(attribute.as_string(), wxConvUTF8));
wxString subError;
if(!loadMaterials(includeName, subError, warnings)) {
warnings.push_back("Error while loading file \"" + includeName.GetFullName() + "\": " + subError);
}
} else if(childName == "metaitem") {
g_items.loadMetaItem(childNode);
} else if(childName == "border") {
g_brushes.unserializeBorder(childNode, warnings);
if(warning.size()) {
warnings.push_back("materials.xml: " + warning);
}
} else if(childName == "brush") {
g_brushes.unserializeBrush(childNode, warnings);
if(warning.size()) {
warnings.push_back("materials.xml: " + warning);
}
} else if(childName == "tileset") {
unserializeTileset(childNode, warnings);
}
}
return true;
}
bool ConverterCache::copy(FileName const & orig_from, string const & to_format,
FileName const & dest) const
{
if (!lyxrc.use_converter_cache || orig_from.empty() || dest.empty())
return false;
LYXERR(Debug::FILES, orig_from << ' ' << to_format << ' ' << dest);
// FIXME: Should not hardcode this (see bug 3819 for details)
if (to_format == "pstex") {
FileName const dest_eps(changeExtension(dest.absFileName(), "eps"));
if (!copy(orig_from, "eps", dest_eps))
return false;
} else if (to_format == "pdftex") {
FileName const dest_pdf(changeExtension(dest.absFileName(), "pdf"));
if (!copy(orig_from, "pdf", dest_pdf))
return false;
}
CacheItem * const item = pimpl_->find(orig_from, to_format);
LASSERT(item, /**/);
Mover const & mover = getMover(to_format);
return mover.copy(item->cache_name, dest,
onlyFileName(dest.absFileName()));
}
void QtVersionManager::extensionsInitialized()
{
bool success = restoreQtVersions();
m_instance->updateFromInstaller(false);
if (!success) {
// We did neither restore our settings or upgraded
// in that case figure out if there's a qt in path
// and add it to the Qt versions
findSystemQt();
}
emit m_instance->qtVersionsLoaded();
emit m_instance->qtVersionsChanged(m_versions.keys(), QList<int>(), QList<int>());
saveQtVersions();
const FileName configFileName = globalSettingsFileName();
if (configFileName.toFileInfo().exists()) {
m_configFileWatcher = new FileSystemWatcher(m_instance);
connect(m_configFileWatcher, SIGNAL(fileChanged(QString)),
m_fileWatcherTimer, SLOT(start()));
m_configFileWatcher->addFile(configFileName.toString(),
FileSystemWatcher::WatchModifiedDate);
} // exists
}
int MetaDataTable::read(const FileName &filename, const std::string &name, std::vector<EMDLabel> *desiredLabels)
{
// Clear current table
clear();
std::ifstream in(filename.data(), std::ios_base::in);
if (in.fail())
REPORT_ERROR( (std::string) "MetaDataTable::read: File " + filename + " does not exists" );
FileName ext = filename.getFileFormat();
if (ext =="star")
{
//REPORT_ERROR("readSTAR not implemented yet...");
return readStar(in, name, desiredLabels);
}
else
{
REPORT_ERROR("MetaDataTable::read ERROR: metadatatable should have .star extension");
}
in.close();
}
///
/// Returns all arguments
/// That is: possbile subpath
/// spec
/// config arguemnts
/// moreArguments
/// user arguments
QString QMakeStep::allArguments(const BaseQtVersion *v, bool shorted) const
{
QmakeBuildConfiguration *bc = qmakeBuildConfiguration();
QStringList arguments;
if (bc->subNodeBuild())
arguments << bc->subNodeBuild()->filePath().toUserOutput();
else if (shorted)
arguments << project()->projectFilePath().fileName();
else
arguments << project()->projectFilePath().toUserOutput();
if (v->qtVersion() < QtVersionNumber(5, 0, 0))
arguments << QLatin1String("-r");
bool userProvidedMkspec = false;
for (QtcProcess::ConstArgIterator ait(m_userArgs); ait.next(); ) {
if (ait.value() == QLatin1String("-spec")) {
if (ait.next()) {
userProvidedMkspec = true;
break;
}
}
}
FileName specArg = mkspec();
if (!userProvidedMkspec && !specArg.isEmpty())
arguments << QLatin1String("-spec") << specArg.toUserOutput();
// Find out what flags we pass on to qmake
arguments << bc->configCommandLineArguments();
arguments << deducedArguments().toArguments();
QString args = QtcProcess::joinArgs(arguments);
// User arguments
QtcProcess::addArgs(&args, m_userArgs);
return args;
}
AbstractFSProvider::status_t ZIPProvider::dir(const FileName & url, std::list<
FileName> & result, uint8_t flags) {
std::lock_guard<std::mutex> lock(handlesMutex);
std::string archiveFileName;
FileName localPath;
decomposeURL(url, archiveFileName, localPath);
ZIPHandle * handle = getZIPHandle(archiveFileName);
if (handle == nullptr) {
return FAILURE;
}
// Make sure all data has been written.
if (handle->isChanged()) {
delete handle;
openHandles.erase(archiveFileName);
handle = getZIPHandle(archiveFileName);
}
if (handle == nullptr) {
return OK;
}
return handle->dir(localPath.getDir(), result, flags);
}
AbstractFSProvider::status_t ZIPProvider::ZIPHandle::readFile(const FileName & file, std::vector<uint8_t> & data) {
if (file.getFile().empty()) {
return FAILURE;
}
const size_t size = fileSize(file);
if (size == 0) {
return FAILURE;
}
zip_file * fileHandle = zip_fopen(handle, file.getPath().c_str(), 0);
if (fileHandle == nullptr) {
WARN(zip_strerror(handle));
return FAILURE;
}
data.resize(size);
const int bytesRead = zip_fread(fileHandle, data.data(), data.size());
if (bytesRead == -1) {
WARN(zip_strerror(handle));
zip_fclose(fileHandle);
return FAILURE;
}
if (static_cast<size_t>(bytesRead) != size) {
WARN("Sizes differ during read.");
zip_fclose(fileHandle);
return FAILURE;
}
if (zip_fclose(fileHandle) == -1) {
WARN(zip_strerror(handle));
return FAILURE;
}
return OK;
}
// -----------------------------------------------------------------------------
File::NameArray File::ExpandToFilenames(std::string const& fnameArg) {
NameArray fnames;
#ifdef _WIN32
fnames.push_back( fnameArg );
#else
if (fnameArg.empty()) return fnames;
wordexp_t expanded;
int err = wordexp( fnameArg.c_str(), &expanded, WRDE_NOCMD );
WexpErr( err );
if ( err == 0 ) {
for (unsigned int i = 0; i != expanded.we_wordc; i++) {
if (expanded.we_wordv[i] == 0)
mprinterr("Internal Error: Bad expansion at %i\n", i);
else {
FileName fn;
fn.SetFileName_NoExpansion( expanded.we_wordv[i] );
fnames.push_back( fn );
}
}
wordfree( &expanded );
}
#endif /* _WIN32 */
return fnames;
}
/**
* Opens and loads the list of files from a file.
*
* @param list Name of the file to open that contains the list of files.
*
* @throws Isis::iException::Io - Cannot open file
*/
void FileList::read(FileName listFile) {
// Open the file
ifstream istm;
istm.open(listFile.toString().toAscii().data(), std::ios::in);
if(!istm) {
QString message = Isis::Message::FileOpen(listFile.toString());
throw IException(IException::Io, message, _FILEINFO_);
}
// Internalize
try {
read(istm);
// Close the file
istm.close();
}
catch (IException &e) {
printf("debugB\n");
istm.close();
QString msg = "File [" + listFile.toString() + "] contains no data";
throw IException(IException::User, msg, _FILEINFO_);
}
}
//-----------------------------------------------------------------------------
// ExtractorApp::GetInputFiles
//-----------------------------------------------------------------------------
void ExtractorApp::GetInputFiles(std::set<String> *psetSources)
{
FileName fnPathArg;
for( int i = 0; i < CommandLine::ArgCount(); i++ )
{
String strPattern;
bool bDoEnum = false;
// Reads next argument
fnPathArg.Set(CommandLine::Arg(i));
if( fnPathArg.IsPathName() )
// Consider full directory content
bDoEnum = true;
else if( fnPathArg.NameExt().find_first_of("*?") != string::npos )
{
// Consider only file whose name match the given pattern
bDoEnum = true;
strPattern = fnPathArg.NameExt();
}
if( bDoEnum )
{ // Directory enumeration
FileEnum feDir(fnPathArg.Path(), FileEnum::ENUM_FILE);
while( feDir.Find() )
{
if( strPattern.empty() || feDir.NameExt().Match(PSZ(strPattern)) )
psetSources->insert(feDir.FullName());
}
}
else
{
if( fnPathArg.FileExists() )
psetSources->insert(fnPathArg.FullName());
else
cerr << "Input file '" << fnPathArg.FullName() << " not found." << endl;
}
}
}
bool State::parseFile(const FileName& fileName)
{
FILE* f = fopen(fileName.c_str(),"r");
if (f == nullptr) return false;
Ref<Stream<int> > file = new FileStream(f,fileName);
std::vector<std::string> syms;
for (size_t i=0; i<sizeof(symbols)/sizeof(void*); i++)
syms.push_back(symbols[i]);
Ref<TokenStream> cin = new TokenStream(new LineCommentFilter(file,"#"),
TokenStream::alpha+TokenStream::ALPHA+TokenStream::numbers+"_.",
TokenStream::separators,syms);
parse(cin);
return true;
}
bool File::openStream(const FileName &fileName, FILE_MODE mode)
{
this->fileName = fileName;
const char *pszMode = getModeString(mode);
stream = fopen(fileName.c_str(), pszMode);
if(stream==0 || ferror(stream))
{
// Failed to open file stream
return false;
}
return true;
}
FileName FileName::addExtension(const QString &newExtension) const {
FileName result = *this;
if (result.extension() != newExtension) {
QString attributesStr = result.attributes();
if (attributesStr == "")
result = FileName(result.originalPath() + "/" + result.name() + "." + newExtension);
else
result = FileName(result.originalPath() + "/" + result.name() + "." + newExtension
+ "+" + attributesStr);
}
return result;
}
QString AndroidToolChain::makeCommand(const Environment &env) const
{
QStringList extraDirectories = AndroidConfigurations::currentConfig().makeExtraSearchDirectories();
if (HostOsInfo::isWindowsHost()) {
FileName tmp = env.searchInPath(QLatin1String("ma-make.exe"), extraDirectories);
if (!tmp.isEmpty())
return QString();
tmp = env.searchInPath(QLatin1String("mingw32-make"), extraDirectories);
return tmp.isEmpty() ? QLatin1String("mingw32-make") : tmp.toString();
}
QString make = QLatin1String("make");
FileName tmp = env.searchInPath(make, extraDirectories);
return tmp.isEmpty() ? make : tmp.toString();
}
FileName IosRunConfiguration::bundleDirectory() const
{
FileName res;
Core::Id devType = DeviceTypeKitInformation::deviceTypeId(target()->kit());
bool isDevice = (devType == Constants::IOS_DEVICE_TYPE);
if (!isDevice && devType != Constants::IOS_SIMULATOR_TYPE) {
qCWarning(iosLog) << "unexpected device type in bundleDirForTarget: " << devType.toString();
return res;
}
QmakeBuildConfiguration *bc =
qobject_cast<QmakeBuildConfiguration *>(target()->activeBuildConfiguration());
if (bc) {
QmakeProject *pro = qobject_cast<QmakeProject *>(target()->project());
const QmakeProFileNode *node = 0;
if (pro)
node = pro->rootProjectNode();
if (node)
node = node->findProFileFor(profilePath());
if (node) {
TargetInformation ti = node->targetInformation();
if (ti.valid)
res = FileName::fromString(ti.buildDir);
}
if (res.isEmpty())
res = bc->buildDirectory();
switch (bc->buildType()) {
case BuildConfiguration::Debug :
case BuildConfiguration::Unknown :
if (isDevice)
res.appendPath(QLatin1String("Debug-iphoneos"));
else
res.appendPath(QLatin1String("Debug-iphonesimulator"));
break;
case BuildConfiguration::Profile :
case BuildConfiguration::Release :
if (isDevice)
res.appendPath(QLatin1String("Release-iphoneos"));
else
res.appendPath(QLatin1String("Release-iphonesimulator"));
break;
default:
qCWarning(iosLog) << "IosBuildStep had an unknown buildType "
<< target()->activeBuildConfiguration()->buildType();
}
}
res.appendPath(applicationName() + QLatin1String(".app"));
return res;
}
bool Materials::unserializeMaterials(const FileName& filename, xmlNodePtr root, wxString& error, wxArrayString& warnings)
{
xmlNodePtr materialNode = root->children;
wxString warning;
while(materialNode)
{
warning = wxT("");
if(xmlStrcmp(materialNode->name,(const xmlChar*)"include") == 0)
{
std::string include_file;
if(readXMLValue(materialNode, "file", include_file))
{
FileName include_name;
include_name.SetPath(filename.GetPath());
include_name.SetFullName(wxstr(include_file));
wxString suberror;
bool success = loadMaterials(include_name, suberror, warnings);
if(!success)
warnings.push_back(wxT("Error while loading file \"") + wxstr(include_file) + wxT("\": ") + suberror);
}
}
else if(xmlStrcmp(materialNode->name,(const xmlChar*)"metaitem") == 0)
{
item_db.loadMetaItem(materialNode);
}
else if(xmlStrcmp(materialNode->name,(const xmlChar*)"border") == 0)
{
brushes.unserializeBorder(materialNode, warnings);
if(warning.size()) warnings.push_back(wxT("materials.xml: ") + warning);
}
else if(xmlStrcmp(materialNode->name,(const xmlChar*)"brush") == 0)
{
brushes.unserializeBrush(materialNode, warnings);
if(warning.size()) warnings.push_back(wxT("materials.xml: ") + warning);
}
else if(xmlStrcmp(materialNode->name,(const xmlChar*)"tileset") == 0)
{
unserializeTileset(materialNode, warnings);
}
materialNode = materialNode->next;
}
return true;
}
//-------------------------------------------------------------------------
void XList::save(const FileName& f, const Config& c) const
{
std::ofstream ff(f.c_str(), std::ios::out);
if (!ff)
throw IOException("Cannot open file", __FILE__, __LINE__, f);
for (unsigned long i=0; i<getLineCount(); i++)
{
XLine& line = _vector.getObject(i);
unsigned long count = line.getElementCount();
for (unsigned long j=0; j<count; j++)
{
ff << line.getElement(j, false); // false = does not change current seg
if (j+1<count)
ff << " ";
}
ff << std::endl;
}
}
/*!
\class CMakeProject
*/
CMakeProject::CMakeProject(CMakeManager *manager, const FileName &fileName)
: m_manager(manager),
m_activeTarget(0),
m_fileName(fileName),
m_rootNode(new CMakeProjectNode(fileName)),
m_watcher(new QFileSystemWatcher(this))
{
setId(Constants::CMAKEPROJECT_ID);
setProjectContext(Core::Context(CMakeProjectManager::Constants::PROJECTCONTEXT));
setProjectLanguages(Core::Context(ProjectExplorer::Constants::LANG_CXX));
m_rootNode->setDisplayName(fileName.parentDir().fileName());
m_file = new CMakeFile(this, fileName);
connect(this, &CMakeProject::buildTargetsChanged, this, &CMakeProject::updateRunConfigurations);
connect(m_watcher, &QFileSystemWatcher::fileChanged, this, &CMakeProject::fileChanged);
}
Ref<Image> loadMagick(const FileName& fileName)
{
Magick::Image image(fileName.c_str());
Image* out = new Image4uc(image.columns(),image.rows(),fileName);
float rcpMaxRGB = 1.0f/float(MaxRGB);
Magick::Pixels pixel_cache(image);
Magick::PixelPacket* pixels = pixel_cache.get(0,0,out->width,out->height);
switch (image.orientation())
{
case UndefinedOrientation:
case TopLeftOrientation: {
for (size_t y=0; y<out->height; y++) {
for (size_t x=0; x<out->width; x++) {
Color4 c;
c.r = float(pixels[y*out->width+x].red)*rcpMaxRGB;
c.g = float(pixels[y*out->width+x].green)*rcpMaxRGB;
c.b = float(pixels[y*out->width+x].blue)*rcpMaxRGB;
c.a = float(pixels[y*out->width+x].opacity)*rcpMaxRGB;
out->set(x,out->height-y-1,c);
}
}
break;
}
case BottomLeftOrientation: {
for (size_t y=0; y<out->height; y++) {
for (size_t x=0; x<out->width; x++) {
Color4 c;
c.r = float(pixels[y*out->width+x].red)*rcpMaxRGB;
c.g = float(pixels[y*out->width+x].green)*rcpMaxRGB;
c.b = float(pixels[y*out->width+x].blue)*rcpMaxRGB;
c.a = float(pixels[y*out->width+x].opacity)*rcpMaxRGB;
out->set(x,y,c);
}
}
break;
}
default: {
throw std::runtime_error("not supported image orientation");
}
}
return out;
}
int loadHairBin(const FileName& fileName, OBJScene::HairSet* hairset, Vec3fa& offset)
{
FILE* fin = fopen(fileName.c_str(),"rb");
if (!fin) THROW_RUNTIME_ERROR("could not open " + fileName.str());
int magick; fread(&magick,sizeof(int),1,fin);
if (magick != hair_bin_magick)
THROW_RUNTIME_ERROR("invalid binary hair file " + fileName.str());
int numHairs; fread(&numHairs,sizeof(int),1,fin);
int numPoints; fread(&numPoints,sizeof(int),1,fin);
int numSegments; fread(&numSegments,sizeof(int),1,fin);
hairset->v.resize(numPoints);
hairset->hairs.resize(numSegments);
if (numPoints) fread(&hairset->v[0],sizeof(Vec3fa),numPoints,fin);
if (numSegments) fread(&hairset->hairs[0],sizeof(OBJScene::Hair),numSegments,fin);
fclose(fin);
for (size_t i=0; i<numPoints; i++) {
hairset->v[i].x-=offset.x;
hairset->v[i].y-=offset.y;
hairset->v[i].z-=offset.z;
}
return numHairs;
}
//-------------------------------------------------------------------------
void ULongVector::load(const FileName& f) {
try {
ifstream inputVect(f.c_str(),ios::in|ios::binary);
if(!inputVect)
throw IOException("Cannot open file", __FILE__, __LINE__,f);
inputVect.read((char*)&_size,sizeof(_size));
if (_capacity != 0) delete[] _array;
_array = new unsigned long[_size];
if (!_array)
throw Exception("Memory allocation exception", __FILE__, __LINE__);
_capacity=_size;
inputVect.read((char*)_array,_size*sizeof(unsigned long));
inputVect.close();
}
catch (Exception& e) {cout << e.toString().c_str() << endl;}
}
