void AssetAtlas::init(sp<GraphicBuffer> buffer, int64_t* map, int count) {
if (mImage) {
return;
}
mImage = new Image(buffer);
if (mImage->getTexture()) {
Caches& caches = Caches::getInstance();
mTexture = new Texture(caches);
mTexture->id = mImage->getTexture();
mTexture->width = buffer->getWidth();
mTexture->height = buffer->getHeight();
createEntries(caches, map, count);
} else {
ALOGW("Could not create atlas image");
delete mImage;
mImage = NULL;
mTexture = NULL;
}
mGenerationId++;
}
IconImageStore::IconImageStore(const std::string& imagesetName)
: mImagesetName(imagesetName)
, mIconSize(64)
, mImageSize(256)
, mImageDataStream(OGRE_NEW Ogre::MemoryDataStream(mImageSize * mImageSize * 4, true))
, mCeguiTexture(nullptr)
{
createImageset();
createEntries();
}
/**
Constructor for when we already have a texture of the whole icon.
*/
IconImageStore::IconImageStore(const std::string& imagesetName, Ogre::TexturePtr texPtr)
: mImagesetName(imagesetName)
, mTexPtr(texPtr)
, mImageDataStream(nullptr)
, mCeguiTexture(nullptr)
{
mCeguiTexture = &GUIManager::getSingleton().createTexture(mTexPtr, imagesetName);
//we'll assume that height and width are the same
mImageSize = texPtr->getWidth();
mIconSize = mImageSize;
//this will only create one entry
createEntries();
}
void AssetAtlas::init(sp<GraphicBuffer> buffer, int64_t* map, int count) {
if (mImage) {
return;
}
ATRACE_NAME("AssetAtlas::init");
mImage = new Image(buffer);
if (mImage->getTexture()) {
if (!mTexture) {
Caches& caches = Caches::getInstance();
mTexture = new Texture(caches);
mTexture->wrap(mImage->getTexture(),
buffer->getWidth(), buffer->getHeight(), GL_RGBA);
createEntries(caches, map, count);
}
} else {
ALOGW("Could not create atlas image");
terminate();
}
}
static void createEntries(DIR *dir, lab_entry *entries, char *str_table, const char *dirname, uint32_t &offset) {
static uint32_t num_entry = 0;
static uint32_t name_offset = 0;
static char *str_offset = str_table;
struct dirent *dirfile;
while ((dirfile = readdir(dir))) {
if (!strcmp(dirfile->d_name, ".") || !strcmp(dirfile->d_name, ".."))
continue;
if (dirfile->d_type == S_IFDIR) {
char *d = appendPath(dirfile->d_name, dirname);
DIR *subdir = opendir(d);
createEntries(subdir, entries, str_table, d, offset);
free(d);
closedir(subdir);
} else {
lab_entry &entry = entries[num_entry++];
WRITE_LE_UINT32(&entry.fname_offset, name_offset);
WRITE_LE_UINT32(&entry.start, offset);
entry.reserved = 0; //What is this??
char *path = appendPath(dirfile->d_name, dirname);
char *name = strrchr(path, '/') + 1;
strcpy(str_offset, name);
str_offset[strlen(name)] = 0;
name_offset += strlen(name) + 1;
str_offset = str_table + name_offset;
struct stat st;
stat(path, &st);
// printf("entry of file %s, at offset %d and of size %d\n", path, offset, st.st_size);
free(path);
offset += st.st_size;
WRITE_LE_UINT32(&entry.size, st.st_size);
}
}
}
int main(int argc, char **argv) {
if (argc > 1 && !strcmp(argv[1], "--help")) {
help();
}
if (argc < 4) {
usage();
exit(1);
}
const char *type = argv[1];
const char *dirname = argv[2];
const char *out = argv[3];
uint8_t g_type;
if (!strcmp(type, "--grim")) {
g_type = GT_GRIM;
} else if (!strcmp(type, "--emi")) {
g_type = GT_EMI;
} else {
usage();
exit(1);
}
DIR *dir = opendir(dirname);
if (dir == 0) {
printf("Can not open source dir: %s\n", dirname);
exit(2);
}
lab_header head;
head.num_entries = 0;
head.string_table_size = 0;
countFiles(&head, dir, dirname, 0);
// printf("%d files, string table of size %d\n", head.num_entries, head.string_table_size);
lab_entry *entries = (lab_entry *)malloc(head.num_entries * sizeof(lab_entry));
char *str_table = (char *)malloc(head.string_table_size);
if (!str_table || !entries) {
printf("Could not allocate memory\n");
exit(3);
}
rewinddir(dir);
uint32_t offset = 16 + head.num_entries * sizeof(lab_entry) + head.string_table_size + 16;
createEntries(dir, entries, str_table, dirname, offset);
closedir(dir);
// Open the output file after we've finished with the dir, so that we're sure
// we don't include the lab into itself if it was asked to be created into the same dir.
FILE *outfile = fopen(out, "wb");
if (!outfile) {
printf("Could not open file %s for writing\n", out);
exit(2);
}
fwrite("LABN", 1, 4, outfile);
fwrite("\x00\x00\x01\x00", 1, 4, outfile); //version
writeUint32(outfile, head.num_entries);
writeUint32(outfile, head.string_table_size);
if (g_type == GT_GRIM) {
uint32_t s_offset = 0; // First entry of the table has offset 0 for Grim
fwrite(&s_offset, 1, 4, outfile);
fseek(outfile, -4, SEEK_CUR);
} else { // EMI has an offset instead.
writeUint32(outfile, 20 + head.num_entries * sizeof(lab_entry) + 0x13d0f);
}
fwrite(entries, 1, head.num_entries * sizeof(lab_entry), outfile);
if (g_type == GT_GRIM) {
fwrite(str_table, 1, head.string_table_size, outfile);
} else {
char *s = (char *)malloc(head.string_table_size);
memset(s, 0, head.string_table_size);
for (uint32_t j = 0; j < head.string_table_size; j++) {
if (str_table[j] != 0)
s[j] = str_table[j] ^ 0x96;
}
fwrite(s, 1, head.string_table_size, outfile);
free(s);
}
uint32_t bufsize = 1024*1024;
char *buf = (char *)malloc(bufsize);
for (uint32_t i = 0; i < head.num_entries; ++i) {
lab_entry &entry = entries[i];
const char *fname = str_table + READ_LE_UINT32(&entry.fname_offset);
char *path = appendPath(fname, dirname);
FILE *file = fopen(path, "rb");
free(path);
uint32_t offset = READ_LE_UINT32(&entry.start);
uint32_t size = READ_LE_UINT32(&entry.size);
if (size > bufsize) {
char *newbuf = (char *)realloc(buf, size);
if (!newbuf) {
free(buf);
printf("Could not allocate memory\n");
exit(3);
}
bufsize = size;
buf = newbuf;
}
// printf("writing file %s, at offset %d and of size %d\n", fname, offset, size);
fread(buf, 1, size, file);
fseek(outfile, offset, SEEK_SET);
fwrite(buf, 1, size, outfile);
fclose(file);
}
fclose(outfile);
free(buf);
free(entries);
free(str_table);
return 0;
}
