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());
}
