//-----------------------------------------------------------------------------
/// Copy a texture from a KMZ to a cache. Note that the texture filename is modified
void copySketchupTexture(const Torque::Path &path, String &textureFilename)
{
if (textureFilename.isEmpty())
return;
Torque::Path texturePath(textureFilename);
texturePath.setExtension(findTextureExtension(texturePath));
String cachedTexFilename = String::ToString("%s_%s.cached",
TSShapeLoader::getShapePath().getFileName().c_str(), texturePath.getFileName().c_str());
Torque::Path cachedTexPath;
cachedTexPath.setRoot(path.getRoot());
cachedTexPath.setPath(path.getPath());
cachedTexPath.setFileName(cachedTexFilename);
cachedTexPath.setExtension(texturePath.getExtension());
FileStream *source;
FileStream *dest;
if ((source = FileStream::createAndOpen(texturePath.getFullPath(), Torque::FS::File::Read)) == NULL)
return;
if ((dest = FileStream::createAndOpen(cachedTexPath.getFullPath(), Torque::FS::File::Write)) == NULL)
{
delete source;
return;
}
dest->copyFrom(source);
delete dest;
delete source;
// Update the filename in the material
cachedTexPath.setExtension("");
textureFilename = cachedTexPath.getFullPath();
}
static S32 buildFileList(const char* pattern, bool recurse, bool multiMatch)
{
static const String sSlash( "/" );
sgFindFilesResults.clear();
String sPattern(Torque::Path::CleanSeparators(pattern));
if(sPattern.isEmpty())
{
Con::errorf("findFirstFile() requires a search pattern");
return -1;
}
if(!Con::expandScriptFilename(sgScriptFilenameBuffer, sizeof(sgScriptFilenameBuffer), sPattern.c_str()))
{
Con::errorf("findFirstFile() given initial directory cannot be expanded: '%s'", pattern);
return -1;
}
sPattern = String::ToString(sgScriptFilenameBuffer);
String::SizeType slashPos = sPattern.find('/', 0, String::Right);
// if(slashPos == String::NPos)
// {
// Con::errorf("findFirstFile() missing search directory or expression: '%s'", sPattern.c_str());
// return -1;
// }
// Build the initial search path
Torque::Path givenPath(Torque::Path::CompressPath(sPattern));
givenPath.setFileName("*");
givenPath.setExtension("*");
if(givenPath.getPath().length() > 0 && givenPath.getPath().find('*', 0, String::Right) == givenPath.getPath().length()-1)
{
// Deal with legacy searches of the form '*/*.*'
String suspectPath = givenPath.getPath();
String::SizeType newLen = suspectPath.length()-1;
if(newLen > 0 && suspectPath.find('/', 0, String::Right) == suspectPath.length()-2)
{
--newLen;
}
givenPath.setPath(suspectPath.substr(0, newLen));
}
Torque::FS::FileSystemRef fs = Torque::FS::GetFileSystem(givenPath);
//Torque::Path path = fs->mapTo(givenPath);
Torque::Path path = givenPath;
// Make sure that we have a root so the correct file system can be determined when using zips
if(givenPath.isRelative())
path = Torque::Path::Join(Torque::FS::GetCwd(), '/', givenPath);
path.setFileName(String::EmptyString);
path.setExtension(String::EmptyString);
if(!Torque::FS::IsDirectory(path))
{
Con::errorf("findFirstFile() invalid initial search directory: '%s'", path.getFullPath().c_str());
return -1;
}
// Build the search expression
const String expression(slashPos != String::NPos ? sPattern.substr(slashPos+1) : sPattern);
if(expression.isEmpty())
{
Con::errorf("findFirstFile() requires a search expression: '%s'", sPattern.c_str());
return -1;
}
S32 results = Torque::FS::FindByPattern(path, expression, recurse, sgFindFilesResults, multiMatch );
if(givenPath.isRelative() && results > 0)
{
// Strip the CWD out of the returned paths
// MakeRelativePath() returns incorrect results (it adds a leading ..) so doing this the dirty way
const String cwd = Torque::FS::GetCwd().getFullPath();
for(S32 i = 0;i < sgFindFilesResults.size();++i)
{
String str = sgFindFilesResults[i];
if(str.compare(cwd, cwd.length(), String::NoCase) == 0)
str = str.substr(cwd.length());
sgFindFilesResults[i] = str;
}
}
return results;
}