static void setTexture( const String &resolvedPath, const aiString &texPath, CPPCore::TArray<Texture*> &textures ) {
Texture *tex = new Texture;
textures.add( tex );
String texname;
texname += "file://";
texname += resolvedPath;
String temp( texPath.C_Str() ), temp1;
IO::Uri::normalizePath( temp, '\\', temp1 );
texname += temp1;
tex->m_loc = IO::Uri( texname );
String::size_type pos = texname.rfind( "/" );
if ( pos != String::npos ) {
texname = texname.substr( pos, texname.size() - pos );
}
if (IO::IOService::getInstance()->fileExists(tex->m_loc)) {
IO::AbstractFileSystem *fs = IO::IOService::getInstance()->getFileSystem("file");
IO::Stream *file = fs->open(tex->m_loc, IO::Stream::AccessMode::ReadAccess);
tex->m_size = file->getSize();
file->read(tex->m_data, tex->m_size);
fs->close(&file);
}
tex->m_textureName = texname;
tex->m_width = 0;
tex->m_height = 0;
tex->m_channels = 0;
tex->m_data = nullptr;
tex->m_size = 0;
}
// ------------------------------------------------------------------------------------------------
// Helper function to build a list of all file extensions supported by ASSIMP
void Importer::GetExtensionList(aiString& szOut) const
{
ASSIMP_BEGIN_EXCEPTION_REGION();
std::set<std::string> str;
for (std::vector<BaseImporter*>::const_iterator i = pimpl->mImporter.begin();i != pimpl->mImporter.end();++i) {
(*i)->GetExtensionList(str);
}
for (std::set<std::string>::const_iterator it = str.begin();; ) {
szOut.Append("*.");
szOut.Append((*it).c_str());
if (++it == str.end()) {
break;
}
szOut.Append(";");
}
ASSIMP_END_EXCEPTION_REGION(void);
}
std::string XFileExporter::toXFileString(aiString &name)
{
std::string str = std::string(name.C_Str());
std::replace(str.begin(), str.end(), '<', '_');
std::replace(str.begin(), str.end(), '>', '_');
std::replace(str.begin(), str.end(), '{', '_');
std::replace(str.begin(), str.end(), '}', '_');
std::replace(str.begin(), str.end(), '$', '_');
return str;
}
void Material::addTexture(aiString FILEPATH)
{
int width, height;
unsigned char* image = SOIL_load_image(FILEPATH.C_Str(), &width, &height, 0, SOIL_LOAD_RGBA);
p_images.push_back(image);
p_width.push_back(width);
p_height.push_back(height);
}
// -----------------------------------------------------------------------------------
// Convert a name to standard XML format
void ConvertName(aiString& out, const aiString& in)
{
out.length = 0;
for (unsigned int i = 0; i < in.length; ++i) {
switch (in.data[i]) {
case '<':
out.Append("<");break;
case '>':
out.Append(">");break;
case '&':
out.Append("&");break;
case '\"':
out.Append(""");break;
case '\'':
out.Append("'");break;
default:
out.data[out.length++] = in.data[i];
}
}
out.data[out.length] = 0;
}
String^ aiStringToString(aiString str)
{
// Assimp aiString underlying encoding is UTF-8
// Windows String underlying encoding is UTF-16
Encoding^ srcEncoding = Encoding::UTF8;
const char* pAiData = str.C_Str(); // pointer to the underlying data of he aiString
array<unsigned char>^ buffer = gcnew array<unsigned char>(str.length);
for(unsigned int i=0; i<str.length; ++i)
buffer[i] = pAiData[i];
return srcEncoding->GetString(buffer);
}
void XFileExporter::writePath(aiString path)
{
std::string str = std::string(path.C_Str());
BaseImporter::ConvertUTF8toISO8859_1(str);
while( str.find( "\\\\") != std::string::npos)
str.replace( str.find( "\\\\"), 2, "\\");
while( str.find( "\\") != std::string::npos)
str.replace( str.find( "\\"), 1, "/");
mOutput << str;
}
std::string XFileExporter::toXFileString(aiString &name)
{
std::string pref = ""; // node name prefix to prevent unexpected start of string
std::string str = pref + std::string(name.C_Str());
for (int i=0; i < (int) str.length(); ++i)
{
if ((str[i] >= '0' && str[i] <= '9') || // 0-9
(str[i] >= 'A' && str[i] <= 'Z') || // A-Z
(str[i] >= 'a' && str[i] <= 'z')) // a-z
continue;
str[i] = '_';
}
return str;
}
bool formatTexPath(const aiString& texName, Path& texPath)
{
if (texName.length == 0)
return false;
string name = texName.C_Str();
name = name.substr(0, name.find_last_of('.')).append(".image");
std::cout << name << std::endl;
texPath.composePath(name);
return true;
}
// TEXTURE2D
vgd::Shp< vgd::node::Texture2D > createTexture2D( const vgio::Media & media, const boost::filesystem::path pathFilename, const int index, const aiString aiImagePath,
const aiTextureMapMode mapU, const aiTextureMapMode mapV )
{
// Compute image path
std::string imagePathFilenameStr;
namespace bfs = boost::filesystem;
const bfs::path imagePathFilename = aiImagePath.C_Str();
if ( imagePathFilename.is_absolute() )
{
imagePathFilenameStr = imagePathFilename.string();
}
else // relative path
{
const bfs::path rootPath = pathFilename.parent_path();
imagePathFilenameStr = (rootPath / imagePathFilename).string();
}
// Texture node
using vgd::node::Texture2D;
vgd::Shp< Texture2D > texture = Texture2D::create( imagePathFilename.filename().string(), (int8)index );
// IMAGE
// Gathers the image from the cache.
vgd::Shp< vgd::basic::IImage > image;
image = vgio::ImageCache::load( media, imagePathFilenameStr );
texture->setImage( image );
// Default values
texture->setMipmap( true );
texture->setMinFilter( Texture2D::LINEAR_MIPMAP_LINEAR );
texture->setMagFilter( Texture2D::LINEAR );
// WRAPPING
texture->setWrapS( toEnum(mapU) );
texture->setWrapT( toEnum(mapV) );
// FUNCTION
texture->sethFunction( vgd::node::Texture2D::FUN_MODULATE ); // @todo
return texture;
}
bool operator()(const aiString& aiA, const aiString& aiB)const
{
std::string a = aiA.C_Str();
std::string b = aiB.C_Str();
return a < b;
}
string toString(const aiString& s) { return s.C_Str(); }
inline std::string assimpToCore( const aiString& string ) {
return std::string( string.C_Str() );
}
