/*----------------------------------------------------------------------------*/
bool Texture1d::reload() {
if (fileName_) { // not a render texture
GLsizei width, height, pixelSize;
GLint format;
GLenum srcDataFormat, srcDataType;
void *srcData = loadRawData(fileName_, &width, &height, &pixelSize, &format, &srcDataFormat, &srcDataType);
if (!srcData)
return false;
// (re) upload to texture object:
bind(); // must ensure texture is bound for upload operation!
// use SRGB if necessary:
if (checkOptionMask(TEX_SRGB)) {
if (format == GL_RGB)
format = GL_SRGB;
else if (format == GL_SRGB_ALPHA)
format = GL_SRGB_ALPHA;
}
/*if (!proxy(format, width, height, checkOptionMask(TEX_MIPMAP))) {
oogl::logEvent("Error: could not create texture %ux%u %s", width, height, oogl::getEnumString(format));
freeRawData(srcData);
return false;
}*/
image(0, format, width, srcDataFormat, srcDataType, srcData);
freeRawData(srcData);
if (checkOptionMask(TEX_MIPMAP))
generateMipmap();
}
return true;
}
util::Array2D<loaders::pixel_t> loaders::loadBitmap(const std::string& filename) {
std::vector<char> data = loadRawData(filename);
BmpFileHeader fh = newFileHeader((unsigned char*)data.data(), data.size());
BmpDib dib = loadBitmapDib((unsigned char*)data.data()+14, data.size()-14);
return loadBmp(((unsigned char*)data.data())+fh.pixelOffset, dib);
}
void GL2TextureManager::makeLoadFullResource(ResourceMeta* meta, GL2Texture* texture)
{
texture->m_loaded = GL2Texture::TextureLoadState::LOADING;
ResourceLoader::RawResourceTask rawDataTask = loadRawData(loader, meta);
TaskPtr textureLoader = std::make_shared<RawTextureLoader>(this, texture, rawDataTask);
textureLoader->addDependency(rawDataTask);
loader->getEngine()->getTaskManager()->addTask(textureLoader);
}
static bool loadImage(file_t fp, img_t ** image)
{
U16 u16Temp;
size_t pixelCount, colorCount;
resource_pic_t dataTemp;
img_t * imgTemp;
void * vp;
bool success;
imgTemp = sysmem_push(sizeof(*imgTemp));
*image = imgTemp;
if (!imgTemp)
{
return false;
}
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
memcpy(&u16Temp, dataTemp.width, sizeof(U16));
imgTemp->width = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.height, sizeof(U16));
imgTemp->height = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.xPos, sizeof(U16));
imgTemp->xPos = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.yPos, sizeof(U16));
imgTemp->yPos = letoh16(u16Temp);
vp = imgTemp->colors;
success = loadRawData(fp, &vp, sizeof(*imgTemp->colors), &colorCount);
imgTemp->ncolors = colorCount;
imgTemp->colors = vp;
if (!success)
{
return false;
}
pixelCount = (imgTemp->width * imgTemp->height); /*we use 8b per pixel*/
imgTemp->pixels = sysmem_push(pixelCount * sizeof(U8));
if (!imgTemp->pixels)
{
return false;
}
if (sysfile_read(fp, imgTemp->pixels, sizeof(U8), pixelCount) != (int)pixelCount)
{
return false;
}
return true;
}
static bool readFile(const unsigned id)
{
bool success;
file_t fp;
void * vp;
switch (id)
{
#ifndef GFXST
case Resource_PICHAF: /* fallthrough */
case Resource_PICCONGRATS: /* fallthrough */
case Resource_PICSPLASH: return true;
#endif /* ndef GFXST */
#ifndef GFXPC
case Resource_IMAINHOFT: /* fallthrough */
case Resource_IMAINRDT: /* fallthrough */
case Resource_IMAINCDC: /* fallthrough */
case Resource_SCREENCONGRATS: return true;
#endif /* ndef GFXPC */
default: break;
}
if (resourceFiles[id] == NULL)
{
sys_error("(resources) resource ID %d not available", id);
return false;
}
if (!checkCrc32(id))
{
return false;
}
fp = sysfile_open(resourceFiles[id]);
if (fp == NULL)
{
sys_error("(resources) unable to open \"%s\"", resourceFiles[id]);
return false;
}
success = readHeader(fp, id);
if (success)
{
switch (id)
{
case Resource_FILELIST: success = loadResourceFilelist(fp); break;
case Resource_PALETTE:
{
vp = game_colors;
success = loadRawData(fp, &vp, sizeof(*game_colors), &game_color_count);
game_colors = vp;
break;
}
case Resource_ENTDATA: success = loadResourceEntdata(fp); break;
case Resource_SPRSEQ:
{
vp = ent_sprseq;
success = loadRawData(fp, &vp, sizeof(*ent_sprseq), &ent_nbr_sprseq);
ent_sprseq = vp;
break;
}
case Resource_MVSTEP:
{
vp = ent_mvstep;
success = loadRawData(fp, &vp, sizeof(*ent_mvstep), &ent_nbr_mvstep);
ent_mvstep = vp;
break;
}
case Resource_MAPS: success = loadResourceMaps(fp); break;
case Resource_SUBMAPS: success = loadResourceSubmaps(fp); break;
case Resource_CONNECT:
{
vp = map_connect;
success = loadRawData(fp, &vp, sizeof(*map_connect), &map_nbr_connect);
map_connect = vp;
break;
}
case Resource_BNUMS:
{
vp = map_bnums;
success = loadRawData(fp, &vp, sizeof(*map_bnums), &map_nbr_bnums);
map_bnums = vp;
break;
}
case Resource_BLOCKS:
{
vp = map_blocks;
success = loadRawData(fp, &vp, sizeof(*map_blocks), &map_nbr_blocks);
map_blocks = vp;
break;
}
case Resource_MARKS:
{
vp = map_marks;
success = loadRawData(fp, &vp, sizeof(*map_marks), &map_nbr_marks);
map_marks = vp;
break;
}
case Resource_EFLGC:
{
vp = map_eflg_c;
success = loadRawData(fp, &vp, sizeof(*map_eflg_c), &map_nbr_eflgc);
map_eflg_c = vp;
break;
}
case Resource_IMAPSL:
{
vp = screen_imapsl;
success = loadRawData(fp, &vp, sizeof(*screen_imapsl), &screen_nbr_imapsl);
screen_imapsl = vp;
break;
}
case Resource_IMAPSTEPS: success = loadResourceImapsteps(fp); break;
case Resource_IMAPSOFS:
{
vp = screen_imapsofs;
success = loadRawData(fp, &vp, sizeof(*screen_imapsofs), &screen_nbr_imapsofs);
screen_imapsofs = vp;
break;
}
case Resource_IMAPTEXT: success = loadResourceImaptext(fp); break;
case Resource_GAMEOVERTXT: success = loadString(fp, (char **)(&screen_gameovertxt), 0xFE); break;
case Resource_PAUSEDTXT: success = loadString(fp, (char **)(&screen_pausedtxt), 0xFE); break;
case Resource_SPRITESDATA: success = loadResourceSpritesData(fp); break;
case Resource_TILESDATA: success = loadResourceTilesData(fp); break;
case Resource_HIGHSCORES: success = loadResourceHighScores(fp); break;
case Resource_IMGSPLASH: success = loadImage(fp, &img_splash); break;
#ifdef GFXST
case Resource_PICHAF: success = loadPicture(fp, &pic_haf); break;
case Resource_PICCONGRATS: success = loadPicture(fp, &pic_congrats); break;
case Resource_PICSPLASH: success = loadPicture(fp, &pic_splash); break;
#endif /* GFXST */
#ifdef GFXPC
case Resource_IMAINHOFT: success = loadString(fp, (char **)(&screen_imainhoft), 0xFE); break;
case Resource_IMAINRDT: success = loadString(fp, (char **)(&screen_imainrdt), 0xFE); break;
case Resource_IMAINCDC: success = loadString(fp, (char **)(&screen_imaincdc), 0xFE); break;
case Resource_SCREENCONGRATS: success = loadString(fp, (char **)(&screen_congrats), 0xFE); break;
#endif /* GFXPC */
default: success = false; break;
}
}
if (!success)
{
sys_error("(resources) error when parsing \"%s\"", resourceFiles[id]);
}
sysfile_close(fp);
return success;
}
