void path::check() const { arx_assert_msg(pathstr.find('\\') == std::string::npos, "bad path: \"%s\"", pathstr.c_str()); size_t pos = 0; while(is_path_up(pathstr, pos)) { pos += 3; } while(pos < pathstr.length()) { size_t next = pathstr.find(dir_sep, pos); if(next == std::string::npos) { next = pathstr.length(); } else { arx_assert_msg(next + 1 != pathstr.length(), "bad path: \"%s\"", pathstr.c_str()); } arx_assert_msg(next > pos, "bad path: \"%s\"", pathstr.c_str()); arx_assert_msg(next - pos > 1 || pathstr[pos] != '.', "bad path: \"%s\"", pathstr.c_str()); if(next - pos == 2) { arx_assert_msg(pathstr[pos] != '.' || pathstr[pos + 1] != '.', "bad path: \"%s\"", pathstr.c_str()); } pos = next + 1; } }
static void test_parent(const fs::path & in, const std::string & out) { fs::path p = in.parent(); arx_assert_msg(p.string() == out, "\"%s\".parent() -> \"%s\" != \"%s\"", in.string().c_str(), p.string().c_str(), out.c_str()); fs::path temp = in; temp.up(); arx_assert_msg(temp.string() == out, "\"%s\".up() ->\"%s\" != \"%s\"", in.string().c_str(), temp.string().c_str(), out.c_str()); }
static void test_resolve(const fs::path & left, const fs::path & right, const std::string & out) { fs::path result = left / right; arx_assert_msg(result.string() == out, "\"%s\" / \"%s\" -> \"%s\" != \"%s\"", left.string().c_str(), right.string().c_str(), result.string().c_str(), out.c_str()); fs::path temp = left; temp /= right; arx_assert_msg(temp.string() == out, "\"%s\" /= \"%s\" -> \"%s\" != \"%s\"", left.string().c_str(), right.string().c_str(), temp.string().c_str(), out.c_str()); }
path & path::append(const std::string & str) { arx_assert_msg(str != "." && str != ".." && str.find(dir_sep) == std::string::npos, "cannot append: \"%s\"", str.c_str()); pathstr += str; return *this; }
FontCache::~FontCache() { arx_assert_msg(m_LoadedFonts.size() == 0, "Someone is probably leaking fonts!"); FT_Done_FreeType( g_FTLibrary ); g_FTLibrary = NULL; }
path & path::set_basename(const std::string & basename) { arx_assert_msg(!basename.empty() && basename != "." && basename != ".." && basename.find(dir_sep) == std::string::npos, "bad basename: \"%s\"", basename.c_str()); if(!has_info()) { return ((empty() ? pathstr = basename : (pathstr += dir_sep).append(basename)), *this); } size_t extpos = pathstr.find_last_of(dir_or_ext_sep); // handle paths without an extension. if(extpos == string::npos) { return (*this = basename); } else if(pathstr[extpos] != ext_sep) { pathstr.resize(extpos + 1 + basename.size()); std::copy(basename.begin(), basename.end(), pathstr.begin() + extpos + 1); return *this; } size_t dirpos = (extpos == 0) ? string::npos : pathstr.find_last_of(dir_sep, extpos - 1); if(dirpos == string::npos) { // no parent path pathstr = basename + pathstr.substr(extpos); } else { pathstr = pathstr.substr(0, dirpos + 1) + basename + pathstr.substr(extpos); } return *this; }
static mode_t dirstat(void * handle, void * entry) { arx_assert(entry != NULL); fs::path file = ITERATOR_HANDLE(handle)->path / reinterpret_cast<dirent *>(entry)->d_name; struct stat buf; int ret = stat(file.string().c_str(), &buf); arx_assert_msg(ret == 0, "stat failed: %d", ret); ARX_UNUSED(ret); return buf.st_mode; }
EntityManager::~EntityManager() { #ifdef ARX_DEBUG for(size_t i = 0; i < size(); i++) { arx_assert_msg(entries[i] == NULL, "object %lu not cleared", (unsigned long)i); } #endif delete m_impl; }
static mode_t dirstat(void * handle, void * entry) { arx_assert(entry != NULL); int fd = dirfd(DIR_HANDLE(handle)); arx_assert(fd != -1); const char * name = reinterpret_cast<dirent *>(entry)->d_name; struct stat buf; int ret = fstatat(fd, name, &buf, 0); arx_assert_msg(ret == 0, "fstatat failed: %d", ret); ARX_UNUSED(ret); return buf.st_mode; }
void EntityManager::remove(size_t index) { arx_assert_msg(index < size() && entries[index] != NULL, "double free or memory corruption detected: index=%lu", (unsigned long)index); m_impl->m_index.erase(entries[index]->idString()); if(index < m_impl->m_minfree) { m_impl->m_minfree = index; } entries[index] = NULL; }
path & path::set_filename(const std::string & filename) { arx_assert_msg(!filename.empty() && filename != "." && filename != ".." && filename.find(dir_sep) == std::string::npos, "bad filename: \"%s\"", filename.c_str()); if(!has_info()) { return ((empty() ? pathstr = filename : (pathstr += dir_sep).append(filename)), *this); } size_t dirpos = pathstr.find_last_of(dir_sep); if(dirpos == string::npos) { return (*this = filename); } else { pathstr.resize(dirpos + 1 + filename.size()); std::copy(filename.begin(), filename.end(), pathstr.begin() + dirpos + 1); return *this; } }
path & path::append_basename(const std::string & basename_part) { arx_assert_msg(basename_part != "." && basename_part != ".." && basename_part.find(dir_sep) == std::string::npos, "bad basename: \"%s\"", basename_part.c_str()); if(!has_info()) { return ((empty() ? pathstr = basename_part : (pathstr += dir_sep).append(basename_part)), *this); } size_t extpos = pathstr.find_last_of(dir_or_ext_sep); if(extpos == string::npos || pathstr[extpos] != ext_sep) { return (pathstr += basename_part, *this); } size_t len = pathstr.length(); pathstr.resize(pathstr.length() + basename_part.length()); std::copy_backward(pathstr.begin() + extpos, pathstr.begin() + len, pathstr.end()); std::copy(basename_part.begin(), basename_part.end(), pathstr.begin() + extpos); return *this; }
// Obtain the right savegame paths for the platform // XP is "%USERPROFILE%\My Documents\My Games" // Vista and up : "%USERPROFILE%\Saved Games" void defineSystemDirectories(const char * argv0) { ARX_UNUSED(argv0); std::string strPath; DWORD winver = GetVersion(); // Vista and up if((DWORD)(LOBYTE(LOWORD(winver))) >= 6) { // Don't hardlink with SHGetKnownFolderPath to allow the game to start on XP too! typedef HRESULT (WINAPI * PSHGetKnownFolderPath)(const GUID &rfid, DWORD dwFlags, HANDLE hToken, PWSTR* ppszPath); CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); PSHGetKnownFolderPath GetKnownFolderPath = (PSHGetKnownFolderPath)GetProcAddress(GetModuleHandleA("shell32.dll"), "SHGetKnownFolderPath"); const GUID FOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}}; LPWSTR wszPath = NULL; HRESULT hr = GetKnownFolderPath(FOLDERID_SavedGames, kfFlagCreate | kfFlagNoAlias, NULL, &wszPath); if(SUCCEEDED(hr)) { strPath = ws2s(wszPath); } CoTaskMemFree(wszPath); CoUninitialize(); } else if((DWORD)(LOBYTE(LOWORD(winver))) == 5) { // XP CHAR szPath[MAX_PATH]; HRESULT hr = SHGetFolderPathA(NULL, CSIDL_PERSONAL | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, szPath); if(SUCCEEDED(hr)) { strPath = szPath; strPath += "\\My Games"; } } else { arx_assert_msg(false, "Unsupported windows version (below WinXP)"); } if(!strPath.empty()) { SetEnvironmentVariable("FOLDERID_SavedGames", strPath.c_str()); } }
bool path::has_ext(const std::string & str) const { arx_assert_msg(str.empty() || (str[0] != dir_sep && str.find_first_of(dir_or_ext_sep, 1) == std::string::npos), "bad file ext: \"%s\"", str.c_str()); if(!has_info()) { return false; } size_t extpos = pathstr.find_last_of(dir_or_ext_sep); if(extpos == string::npos || pathstr[extpos] != ext_sep) { return false; } else if(str.empty()) { return true; } else if(str[0] == ext_sep) { return !pathstr.compare(extpos + 1, pathstr.length() - extpos - 1, str, 1, str.length() - 1); } else { return !pathstr.compare(extpos + 1, pathstr.length() - extpos - 1, str); } }
path & path::set_ext(const std::string & ext) { arx_assert_msg(ext.empty() || (ext[0] != dir_sep && ext.find_first_of(dir_or_ext_sep, 1) == std::string::npos), "bad file ext: \"%s\"", ext.c_str()); if(!has_info() && !empty()) { return *this; } size_t extpos = pathstr.find_last_of(dir_or_ext_sep); if(extpos == string::npos || pathstr[extpos] != ext_sep) { return (((ext.empty() || ext[0] != ext_sep) ? (pathstr += ext_sep) : pathstr).append(ext), *this); } else { if(ext.empty() || ext[0] != ext_sep) { pathstr.resize(extpos + 1 + ext.size()); std::copy(ext.begin(), ext.end(), pathstr.begin() + extpos + 1); } else { pathstr.resize(extpos + ext.size()); std::copy(ext.begin() + 1, ext.end(), pathstr.begin() + extpos + 1); } return *this; } }
directory_iterator::directory_iterator(const path & p) : buf(NULL) { handle = DIR_HANDLE_INIT(p, opendir(p.empty() ? "./" : p.string().c_str())); if(DIR_HANDLE(handle)) { // Allocate a large enough buffer for readdir_r. long name_max; #if ((defined(ARX_HAVE_DIRFD) && defined(ARX_HAVE_FPATHCONF)) || defined(ARX_HAVE_PATHCONF)) \ && defined(ARX_HAVE_PC_NAME_MAX) # if defined(ARX_HAVE_DIRFD) && defined(ARX_HAVE_FPATHCONF) name_max = fpathconf(dirfd(DIR_HANDLE(handle)), _PC_NAME_MAX); #else name_max = pathconf(p.string().c_str(), _PC_NAME_MAX); #endif if(name_max == -1) { # if defined(ARX_HAVE_NAME_MAX) name_max = std::max(NAME_MAX, 255); # else arx_assert_msg(false, "cannot determine maximum dirname size"); # endif } #elif defined(ARX_HAVE_NAME_MAX) name_max = std::max(NAME_MAX, 255); #else # error "buffer size for readdir_r cannot be determined" #endif size_t size = (size_t)offsetof(dirent, d_name) + name_max + 1; if(size < sizeof(dirent)) { size = sizeof(dirent); } buf = malloc(size); readdir(handle, buf); } };
bool GLTexture2D::Create() { arx_assert_msg(!tex, "leaking OpenGL texture"); glGenTextures(1, &tex); // Set our state to the default OpenGL state wrapMode = TextureStage::WrapRepeat; mipFilter = TextureStage::FilterLinear; minFilter = TextureStage::FilterNearest; magFilter = TextureStage::FilterLinear; #ifndef HAVE_GLES if(GLEW_ARB_texture_non_power_of_two) { storedSize = size; } else #endif { storedSize = Vec2i(GetNextPowerOf2(size.x), GetNextPowerOf2(size.y)); } CHECK_GL; return (tex != GL_NONE); }
void throw_exception(const std::exception & e) { arx_assert_msg(false, "Boost triggered an unhandled exception! %s", e.what()); ARX_UNUSED(e); }
bool SDLWindow::initializeFramework() { arx_assert_msg(mainWindow == NULL, "SDL only supports one window"); arx_assert(displayModes.empty()); const char * headerVersion = ARX_STR(SDL_MAJOR_VERSION) "." ARX_STR(SDL_MINOR_VERSION) "." ARX_STR(SDL_PATCHLEVEL); CrashHandler::setVariable("SDL version (headers)", headerVersion); if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0) { LogError << "Failed to initialize SDL: " << SDL_GetError(); return false; } const SDL_version * ver = SDL_Linked_Version(); std::ostringstream runtimeVersion; runtimeVersion << int(ver->major) << '.' << int(ver->minor) << '.' << int(ver->patch); CrashHandler::setVariable("SDL version", runtimeVersion.str()); LogInfo << "Using SDL " << runtimeVersion.str(); const SDL_VideoInfo * vid = SDL_GetVideoInfo(); desktopMode.resolution.x = vid->current_w; desktopMode.resolution.y = vid->current_h; desktopMode.depth = vid->vfmt->BitsPerPixel; u32 flags = SDL_FULLSCREEN | SDL_ANYFORMAT | SDL_OPENGL | SDL_HWSURFACE; SDL_Rect ** modes = SDL_ListModes(NULL, flags); if(modes == (SDL_Rect **)(-1)) { // Any mode is supported, add some standard modes. #define ADD_MODE(x, y) \ if(desktopMode.resolution != Vec2i(x, y)) { \ displayModes.push_back(DisplayMode(Vec2i(x, y), desktopMode.depth)); \ } // 4:3 ADD_MODE(640, 480) // VGA ADD_MODE(800, 600) // SVGA ADD_MODE(1024, 768) // XGA ADD_MODE(1280, 960) // SXGA- ADD_MODE(1600, 1200) // UXGA // 5:4 ADD_MODE(1280, 1024) // SXGA // 16:9 ADD_MODE(1280, 720) // 720p ADD_MODE(1600, 900) // 900p ADD_MODE(1920, 1080) // 1080p ADD_MODE(2048, 1152) // 2K ADD_MODE(4096, 2304) // 4K // 16:10 ADD_MODE(1024, 640) // laptops ADD_MODE(1280, 800) // WXGA ADD_MODE(1440, 900) // WXGA+ ADD_MODE(1920, 1200) // WUXGA #undef ADD_MODE displayModes.push_back(desktopMode); } else if(modes) { for(; *modes; modes++) { DisplayMode mode(Vec2i((*modes)->w, (*modes)->h), desktopMode.depth); displayModes.push_back(mode); } } else { return false; } std::sort(displayModes.begin(), displayModes.end()); mainWindow = this; return true; }
void GLTexture2D::Upload() { arx_assert(tex != GL_NONE); glBindTexture(GL_TEXTURE_2D, tex); renderer->GetTextureStage(0)->current = this; #ifdef HAVE_GLES #define GL_LUMINANCE8 GL_LUMINANCE #define GL_ALPHA8 GL_ALPHA #define GL_LUMINANCE8_ALPHA8 GL_LUMINANCE_ALPHA #define GL_RGB8 GL_RGB #define GL_BGR GL_RGB #define GL_RGBA8 GL_RGBA #endif GLint internal; GLenum format; if(mFormat == Image::Format_L8) { internal = GL_LUMINANCE8, format = GL_LUMINANCE; } else if(mFormat == Image::Format_A8) { internal = GL_ALPHA8, format = GL_ALPHA; } else if(mFormat == Image::Format_L8A8) { internal = GL_LUMINANCE8_ALPHA8, format = GL_LUMINANCE_ALPHA; } else if(mFormat == Image::Format_R8G8B8) { internal = GL_RGB8, format = GL_RGB; } else if(mFormat == Image::Format_B8G8R8) { #ifdef HAVE_GLES mImage.ConvertTo(Image::Format_R8G8B8); internal = GL_RGB8, format = GL_RGB; #else internal = GL_RGB8, format = GL_BGR; #endif } else if(mFormat == Image::Format_R8G8B8A8) { internal = GL_RGBA8, format = GL_RGBA; } else if(mFormat == Image::Format_B8G8R8A8) { #ifdef HAVE_GLES mImage.ConvertTo(Image::Format_R8G8B8A8); internal = GL_RGBA8, format = GL_RGBA; #else internal = GL_RGBA8, format = GL_BGRA; #endif } else { arx_assert_msg(false, "Unsupported image format"); return; } #if 0 printf("GLTexture2D::Upload (%ix%i), Mipmaps=%s, Format=%s\n", size.x, size.y, (hasMipmaps())?"yes":"no", (format==GL_LUMINANCE)?"GL_L":(format==GL_ALPHA)?"GL_A":(format==GL_LUMINANCE_ALPHA)?"GL_LA":(format==GL_RGB)?"GL_RGB":"GL_RGBA" ); #endif #ifdef PANDORA0 if(hasMipmaps() && ((format==GL_RGB) || (format==GL_RGBA))) { // more Gamma on the Pandora mImage.QuakeGamma(1.6); }; #endif #ifdef HAVE_GLES if(hasMipmaps() && ((size.x>32) || (size.y>32))) { // downscale this texture ! if (mImage.DownScale()) { size.x = mImage.GetWidth(); size.y = mImage.GetHeight(); storedSize = Vec2i(GetNextPowerOf2(size.x), GetNextPowerOf2(size.y)); } } #endif if(hasMipmaps()) { glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); } // TODO handle GL_MAX_TEXTURE_SIZE #ifdef HAVE_GLES // convert to 16 bits some textures if (internal==GL_RGB8) { // convert 24bits RGB to 16bits 565 RGB unsigned char *temp = new unsigned char[mImage.GetWidth()*mImage.GetHeight()*2]; unsigned short *p = (unsigned short*)temp; unsigned char *s = mImage.GetData(); for (unsigned int y=0; y<mImage.GetHeight(); y++) for (unsigned int x=0; x<mImage.GetWidth(); x++) { unsigned short r = s[0]>>3, g = s[1]>>2, b = s[2]>>3; *(p++) = r<<11 | g<<5 | b; s+=3; } if(storedSize != size) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, storedSize.x, storedSize.y, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size.x, size.y, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, temp); } else { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.x, size.y, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, temp); } delete[] temp; } else
static void test_path(const std::string & in, const std::string & out) { fs::path p(in); arx_assert_msg(p.string() == out, "\"%s\" -> \"%s\" != \"%s\"", in.c_str(), p.string().c_str(), out.c_str()); }