bool SpriteLoaderPNG::LoadSprite(SpriteLoader::Sprite *sprite, uint8 file_slot, size_t file_pos, SpriteType sprite_type)
{
const char *filename = FioGetFilename(file_slot);
if (!LoadPNG(sprite, filename, (uint32)file_pos, false)) return false;
if (!LoadPNG(sprite, filename, (uint32)file_pos, true)) return false;
return true;
}
/*!
* \brief
* Load image file (8-bit BMP or PNG)
*
* \param filename
* File name with the image
*
* \returns
* Handler to the loaded image or NULL if error
*
* \see
* TLN_DeleteBitmap()
*/
TLN_Bitmap TLN_LoadBitmap (char *filename)
{
TLN_Bitmap bitmap;
if (!CheckFile (filename))
{
TLN_SetLastError (TLN_ERR_FILE_NOT_FOUND);
return NULL;
}
/* try png, else bmp*/
bitmap = LoadPNG (filename);
if (bitmap == NULL)
bitmap = LoadBMP (filename);
/* bitmap loaded */
if (bitmap)
{
/* accept only 8 bpp */
int bpp = TLN_GetBitmapDepth (bitmap);
if (bpp == 8)
TLN_SetLastError (TLN_ERR_OK);
else
{
TLN_DeleteBitmap (bitmap);
bitmap = NULL;
}
}
if (!bitmap)
TLN_SetLastError (TLN_ERR_WRONG_FORMAT);
return bitmap;
}
TTexture * LoadTexture(const std::string & parImg)
{
TImgType::Type typeImg = GetImgType(parImg);
TTexture * texture = NULL;
switch (typeImg)
{
case TImgType::PNG:
texture = LoadPNG(parImg.c_str());
break;
case TImgType::JPG:
texture = LoadJPG(parImg.c_str());
break;
case TImgType::BMP:
texture = LoadBMP(parImg.c_str());
break;
case TImgType::TGA:
texture = NULL;
break;
default:
ASSERT_FAIL_MSG("Unhandled type "<<parImg);
};
return texture;
}
BOOL ReadImage(CImage* pcImage, char* szFilename, EImageType eType)
{
if (eType == IT_Unknown)
{
eType = GuessImageType(szFilename);
}
//Oi! Check to make sure none of the below expect an initialised image.
switch (eType)
{
case IT_BMP:
case IT_EMF:
case IT_GIF:
case IT_ICO:
case IT_JPG:
case IT_WMF:
// uses OLE and IPicture to load these image formats.
return (LoadPictureIPicture(pcImage, szFilename));
case IT_TGA:
return (LoadTGA(pcImage, szFilename)); // uses NeHe TGA routines.
case IT_PNG:
return (LoadPNG(pcImage, szFilename));
case IT_RAD:
return (LoadRAD(pcImage, szFilename)); // uses a text-format RAW descriptor (RAD) file to load a raw file.
case IT_RAW:
return (LoadRAW(pcImage, szFilename)); // special case assuming an initialised image.
}
return FALSE;
}
void
UnitSymbol::Load(ResourceId id)
{
#ifdef USE_MEMORY_CANVAS
assert(IsScreenInitialized());
assert(buffer.data == nullptr);
ResourceLoader::Data data = ResourceLoader::Load(id);
assert(!data.IsNull());
const UncompressedImage uncompressed = LoadPNG(data.data, data.size);
assert(uncompressed.GetFormat() == UncompressedImage::Format::GRAY);
const size_t size = uncompressed.GetPitch() * uncompressed.GetHeight();
buffer.data = new Luminosity8[size];
memcpy(buffer.data, uncompressed.GetData(), size);
buffer.pitch = uncompressed.GetPitch();
buffer.width = uncompressed.GetWidth();
buffer.height = uncompressed.GetHeight();
#else
bitmap.Load(id, Bitmap::Type::MONO);
size = bitmap.GetSize();
#endif
}
void convertAndSaveFont()
{
int fontCharCount = 32 * 3;
LoadPNG((globalWorkingDirPrefix + "gamefont.png").c_str());
FILE *out = fopen((globalOutputDirPrefix + "gamefont.bin").c_str(),"wb");
for (int i = 0; i < fontCharCount; ++i)
{
int xi = i % 32;
int yi = i / 32;
for (int y = 0; y < 8; ++y)
{
unsigned char c = 0;
for (int x = 0; x < 8; ++x)
{
int pix = pictureS[(x+xi*8)+(y+yi*8)*pictureWidth];
if ((pix & 255) > 100)
c |= 1 << (7-x);
}
fwrite(&c,1,1,out);
}
}
fclose(out);
}
int LoadTexturePNG(char * filename, int index)
{
texture_pointer2 = texture_pointer + index * 1024 * 1024; // 4 MB reserved for PNG index
// here you can add more textures using 'texture_pointer'. It is returned aligned to 16 bytes
LoadPNG(&Png_datas[index], filename);
free(Png_datas[index].png_in);
Png_offset[index] = 0;
if(Png_datas[index].bmp_out) {
memcpy(texture_pointer2, Png_datas[index].bmp_out, Png_datas[index].wpitch * Png_datas[index].height);
free(Png_datas[index].bmp_out);
Png_datas[index].bmp_out= texture_pointer2;
Png_offset[index] = tiny3d_TextureOffset(Png_datas[index].bmp_out); // get the offset (RSX use offset instead address)
return 0;
}
return -1;
}
void *ReplaceImageItem(void *pItem, int Type, const char *pImgName, const char *pImgFile, CMapItemImage *pNewImgItem)
{
if(Type != MAPITEMTYPE_IMAGE)
return pItem;
CMapItemImage *pImgItem = (CMapItemImage *)pItem;
char *pName = (char *)g_DataReader.GetData(pImgItem->m_ImageName);
if(str_comp(pImgName, pName) != 0)
return pItem;
dbg_msg("map_replace_image", "found image '%s'", pImgName);
CImageInfo ImgInfo;
if(!LoadPNG(&ImgInfo, pImgFile))
return 0;
*pNewImgItem = *pImgItem;
pNewImgItem->m_Width = ImgInfo.m_Width;
pNewImgItem->m_Height = ImgInfo.m_Height;
int PixelSize = ImgInfo.m_Format == CImageInfo::FORMAT_RGB ? 3 : 4;
g_NewNameID = pImgItem->m_ImageName;
IStorage::StripPathAndExtension(pImgFile, g_aNewName, sizeof(g_aNewName));
g_NewDataID = pImgItem->m_ImageData;
g_pNewData = ImgInfo.m_pData;
g_NewDataSize = ImgInfo.m_Width * ImgInfo.m_Height * PixelSize;
return (void *)pNewImgItem;
}
/**
* ファイルロード[拡張子自動判別]
* @param filepath ファイルフルパス
* @retval true 成功
* @retval false 失敗
*/
bool Load(const char* filename)
{
bool result = false;
m_image.Clear();
std::string path(filename);
std::string::size_type pos = path.rfind('.');
if (pos != std::string::npos)
{
const std::string ext = make_lowercase(path.substr(pos+1));
if (ext == "png")
{
result = LoadPNG(path);
}
else if (ext == "jpg" || ext == "jpeg")
{
result = LoadJPG(path);
}
else if (ext == "tga")
{
result = LoadTGA(path);
}
else if (ext == "hdr")
{
result = LoadHDR(path);
}
else if (ext == "exr" || ext == "EXR")
{
result = LoadEXR(path);
}
}
return result;
}
//
// Load a new image from an image file (PPM, JPEG
// and PNG formats are supported).
// Returns NULL on failure.
//
STImage::STImage(const std::string& filename)
: mWidth(-1)
, mHeight(-1)
, mPixels(NULL)
{
// Determine the right routine based on the file's extension.
// The format-specific subroutines are each implemented in
// a different file.
std::string ext = STGetExtension( filename );
if (ext.compare("PPM") == 0) {
LoadPPM(filename);
}
else if (ext.compare("PNG") == 0) {
LoadPNG(filename);
}
else if (ext.compare("JPG") == 0 || ext.compare("JPEG") == 0) {
LoadJPG(filename);
}
else {
fprintf(stderr,
"STImage::STImage() - Unknown image file type \"%s\".\n",
filename.c_str());
throw new std::runtime_error("Error creating STImage");
}
}
bool CGLImageData::LoadTexture(const char *filename)
{
if (!LoadBMP(filename))
if(!LoadPNG(filename))
{
sLog(DEFAULT_LOG_NAME, LOG_WARNING_EV, "Can't load image->");
return false;
}
else
{
if (!MakeTexture())
{
sLog(DEFAULT_LOG_NAME, LOG_WARNING_EV, "Can't load texture in video adapter.");
return false;
}
}
else
{
if(!MakeRGBA())
{
sLog(DEFAULT_LOG_NAME, LOG_WARNING_EV, "Can't load texture.");
return false;
}
if (!MakeTexture())
{
sLog(DEFAULT_LOG_NAME, LOG_WARNING_EV, "Can't load texture in video memory.");
return false;
}
}
{
delete [] data;
data = NULL;
}
return true;
}
bool Texture::Load(const char *filename) {
// hook for generated textures
if (!memcmp(filename, "gen:", 4)) {
// TODO
// return false;
tex_ = (LPVOID)generateTexture(filename);
if (tex_) {
this->filename_ = filename;
}
return true;
}
filename_ = filename;
// Currently contains many Rollerball-specific workarounds.
// They shouldn't really hurt anything else very much though.
int len = strlen(filename);
char fn[256];
strcpy(fn, filename);
bool zim = false;
if (!strcmp("dds", &filename[len-3])) {
strcpy(&fn[len-3], "zim");
zim = true;
}
if (!strcmp("6TX", &filename[len-3]) || !strcmp("6tx", &filename[len-3])) {
ILOG("Detected 6TX %s", filename);
strcpy(&fn[len-3], "zim");
zim = true;
}
for (int i = 0; i < (int)strlen(fn); i++) {
if (fn[i] == '\\') fn[i] = '/';
}
if (fn[0] == 'm') fn[0] = 'M';
const char *name = fn;
if (zim && 0 == memcmp(name, "Media/textures/", strlen("Media/textures"))) name += strlen("Media/textures/");
len = strlen(name);
#if !defined(USING_GLES2)
if (!strcmp("png", &name[len-3]) ||
!strcmp("PNG", &name[len-3])) {
if (!LoadPNG(fn)) {
LoadXOR();
return false;
} else {
return true;
}
} else
#endif
if (!strcmp("zim", &name[len-3])) {
if (!LoadZIM(name)) {
LoadXOR();
return false;
} else {
return true;
}
}
LoadXOR();
return false;
}
UncompressedImage
LoadPNG(Path path)
{
FileMapping map(path);
if (map.error())
return UncompressedImage();
return LoadPNG(map.data(), map.size());
}
Bitmap::Bitmap(ConstBuffer<void> _buffer)
:
#ifdef ENABLE_OPENGL
#ifdef ANDROID
id(0),
#endif
texture(nullptr), interpolation(false)
#else
buffer(WritableImageBuffer<BitmapPixelTraits>::Empty())
#endif
{
Load(_buffer);
}
bool
Bitmap::Load(ConstBuffer<void> buffer, Type type)
{
const UncompressedImage uncompressed = LoadPNG(buffer.data, buffer.size);
return Load(uncompressed, type);
}
static UncompressedImage
DecompressImageFile(Path path)
{
#ifdef USE_LIBTIFF
if (path.MatchesExtension(_T(".tif")) || path.MatchesExtension(_T(".tiff")))
return LoadTiff(path);
#endif
if (path.MatchesExtension(_T(".png")))
return LoadPNG(path);
return LoadJPEGFile(path);
}
bool
Bitmap::LoadFile(Path path)
{
const UncompressedImage uncompressed = DecompressImageFile(path);
return uncompressed.IsVisible() && Load(uncompressed);
}
void Load_PNG()
{
// datas for PNG from memory
png1.png_in = (void *) picture_png_bin;
png1.png_size = sizeof (picture_png_bin);
// load PNG from memory
LoadPNG(&png1, NULL);
}
BitmapPNG* LoadPNG(char const *pFilename)
{
int length;
uchar* data = gEngfuncs.COM_LoadFile((char*)pFilename, 5, &length);
if( !data ) { return NULL; }
MemoryInputStream stream(data,length);
BitmapPNG* pRet = LoadPNG(stream);
gEngfuncs.COM_FreeFile(data);
return pRet;
}
Bitmap::Bitmap(std::string& filepath)
{
_bitmapData = NULL;
setTransparency(true);
if(LoadPNG(filepath))
{
_loaded = true;
}
else
{
printf("Error: failed to load bitmap at path %s", filepath.c_str());
}
}
void CPicture::Load( const char* extension, CDataStream& dataStream )
{
if ( strcmp( extension, "dds" ) == 0 )
{
LoadDDS( dataStream );
}
if ( strcmp( extension, "png" ) == 0 )
{
LoadPNG( dataStream );
}
else
{
// WbLog( "Default", "Unsupported texture format : %s\n", extension );
}
}
/*!
* \brief
* Load image file (8-bit BMP or PNG)
*
* \param filename
* File name with the image
*
* \returns
* Handler to the loaded image or NULL if error
*
* \see
* TLN_DeleteBitmap()
*/
TLN_Bitmap TLN_LoadBitmap (char *filename)
{
char* ext;
ext = strchr(filename, '.');
if (ext)
{
if (!strcmp (ext, ".png"))
return LoadPNG (filename);
if (!strcmp (ext, ".bmp"))
return LoadBMP (filename);
}
return NULL;
}
hdTexture* hdTextureManager::FindTexture(const char* name, texturetype_t type)
{
hdTexture *tex;
unsigned char *data;
unsigned short width, height;
unsigned short bytes;
if (name == NULL) return NULL;
if (strlen(name) == 0) return NULL;
for (int i = 0; i < m_textures->GetItemCount(); i++)
{
if (strncmp(m_textures->GetItems()[i]->name, name, kMaxTexturePathSize) == 0)
{
return (hdTexture*)m_textures->GetItems()[i];
}
}
hdPrintf("[hdTextureManager] Looking for texture file: %s\n", name);
if (std::string(name).find(std::string(".tga")) != std::string::npos)
{
LoadTGA( name, &data, &width, &height, &bytes );
if ( data ) {
tex = this->LoadTexture( name, data, width, height, type, bytes );
free( data );
return tex;
}
}
if (std::string(name).find(std::string(".png")) != std::string::npos)
{
LoadPNG( name, &data, &width, &height, &bytes );
if ( data ) {
tex = this->LoadTexture( name, data, width, height, type, bytes );
#if TARGET_OS_IPHONE == 1 || TARGET_IPHONE_SIMULATOR == 1
tex->isPremultipliedAlpha = true;
#endif
free( data );
return tex;
}
}
hdPrintf("[hdTextureManager] ERROR: could not find texture file: %s\n", name);
return m_nullTexture;
}
TTexturePtr LoadFromMemory(TFilePtr& aFile, const char* aLogdata)
{
LOG_PARAMS(aLogdata);
if (!ValidateFileHeader(aFile)) {
LOG_ERROR("Could not load image %s: Invalid file header", aLogdata);
return TTexturePtr();
}
png_structp pngPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (pngPtr == nullptr) {
LOG_ERROR("Could not initialize png read struct for %s", aLogdata);
return TTexturePtr();
}
TTexturePtr result = LoadPNG(aFile, aLogdata, pngPtr);
png_destroy_read_struct(&pngPtr, nullptr, nullptr);
return result;
}
/*****************************************************************************
* CreateFilter: allocates logo video filter
*****************************************************************************/
static int CreateFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
vlc_value_t val;
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
if( p_sys == NULL )
{
msg_Err( p_filter, "out of memory" );
return VLC_ENOMEM;
}
var_Create( p_this, "logo-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_this, "logo-position", &val );
p_sys->pos = val.i_int;
var_Create( p_this, "logo-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_this, "logo-x", &val );
p_sys->posx = val.i_int;
var_Create( p_this, "logo-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_this, "logo-y", &val );
p_sys->posy = val.i_int;
p_sys->b_absolute = VLC_TRUE;
if( p_sys->posx < 0 || p_sys->posy < 0 )
{
p_sys->b_absolute = VLC_FALSE;
p_sys->posx = 0; p_sys->posy = 0;
}
p_sys->p_pic = LoadPNG( p_this );
if( !p_sys->p_pic )
{
free( p_sys );
return VLC_EGENERIC;
}
p_sys->i_width = p_sys->p_pic->p[Y_PLANE].i_visible_pitch;
p_sys->i_height = p_sys->p_pic->p[Y_PLANE].i_visible_lines;
p_sys->i_last_date = 0;
/* Misc init */
p_filter->pf_sub_filter = Filter;
return VLC_SUCCESS;
}
int CNkImage::Load(char* lpszFileName,int width,int height)
{
SAFE_RELEASE(m_pdds);
SAFE_DELETE(m_pdds);
if(m_szFileName != lpszFileName)
strcpy(m_szFileName,lpszFileName);
LoadPNG(lpszFileName);
if(width > 0)
m_width = width;
else
m_width = m_bmpWidth;
if(height > 0)
m_height = height;
else
m_height = m_bmpHeight;
return 1;
}
static void Load() {
twister = LoadILBMCustom("twister.ilbm", BM_DISPLAYABLE);
texture = LoadPNG("twister-texture.png", PM_RGB12, MEMF_PUBLIC);
gradient = LoadPalette("twister-gradient.ilbm");
{
BitmapT *_left = LoadILBMCustom("twister-left.ilbm", 0);
BitmapT *_right = LoadILBMCustom("twister-right.ilbm", 0);
left[0] = NewSpriteFromBitmap(256, _left, 0, 0);
left[1] = NewSpriteFromBitmap(256, _left, 16, 0);
right[0] = NewSpriteFromBitmap(256, _right, 0, 0);
right[1] = NewSpriteFromBitmap(256, _right, 16, 0);
DeleteBitmap(_right);
DeleteBitmap(_left);
}
}
UncompressedImage
LoadPNG(const void *data, size_t size)
{
png_structp png_ptr =
png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
if (png_ptr == nullptr)
return UncompressedImage::Invalid();
png_infop info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == nullptr) {
png_destroy_read_struct(&png_ptr, nullptr, nullptr);
return UncompressedImage::Invalid();
}
UncompressedImage result = LoadPNG(png_ptr, info_ptr, data, size);
png_destroy_read_struct(&png_ptr, &info_ptr, nullptr);
return result;
}
/*****************************************************************************
* Create: allocates logo video thread output method
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
vout_sys_t *p_sys;
vlc_value_t val;
/* Allocate structure */
p_sys = p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
if( p_sys == NULL )
{
msg_Err( p_vout, "out of memory" );
return VLC_ENOMEM;
}
p_vout->pf_init = Init;
p_vout->pf_end = End;
p_vout->pf_manage = NULL;
p_vout->pf_render = Render;
p_vout->pf_display = NULL;
p_vout->pf_control = Control;
var_Create( p_this, "logo-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_this, "logo-position", &val );
p_sys->pos = val.i_int;
var_Create( p_this, "logo-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_this, "logo-x", &val );
p_sys->posx = val.i_int;
var_Create( p_this, "logo-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_this, "logo-y", &val );
p_sys->posy = val.i_int;
p_sys->p_pic = LoadPNG( p_this );
if( !p_sys->p_pic )
{
free( p_sys );
return VLC_EGENERIC;
}
p_sys->i_width = p_sys->p_pic->p[Y_PLANE].i_visible_pitch;
p_sys->i_height = p_sys->p_pic->p[Y_PLANE].i_visible_lines;
return VLC_SUCCESS;
}
// simple uncompressed RGBA loaders
int CGraphics_OpenGL::LoadTexture(const char *pFilename, int StorageType, int StoreFormat, int Flags)
{
int l = str_length(pFilename);
int ID;
CImageInfo Img;
if(l < 3)
return -1;
if(LoadPNG(&Img, pFilename, StorageType))
{
if (StoreFormat == CImageInfo::FORMAT_AUTO)
StoreFormat = Img.m_Format;
ID = LoadTextureRaw(Img.m_Width, Img.m_Height, Img.m_Format, Img.m_pData, StoreFormat, Flags);
mem_free(Img.m_pData);
return ID;
}
return m_InvalidTexture;
}
Texture LoadTexture( string name )
{
Log("Want to load an image file");
string ext = split(name, ".", "")[1];
boost::to_upper(ext);
Log("Loading an image file of type " + ext);
if (ext == "BMP")
{
return LoadBMP(name);
}
else if (ext == "JPEG" || ext == "JPG")
{
return LoadJPEG(name);
}
else if (ext == "PNG")
{
Log("About to load a png");
return LoadPNG(name);
}
}
void loadBlockTexture()
{
pic_data PNGData;
if (LoadPNG("Texture\\BlockTexture.png",&PNGData))
{
TextureList.resize(TextureList.size() + 1);
glGenTextures(1, &TextureList[TextureList.size()-1]);
glBindTexture(GL_TEXTURE_2D, TextureList[TextureList.size() - 1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PNGData.width, PNGData.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, PNGData.rgba);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
free(PNGData.rgba);
}
}
void
UnitSymbol::Load(unsigned id)
{
assert(IsScreenInitialized());
assert(buffer.data == nullptr);
ResourceLoader::Data data = ResourceLoader::Load(id);
assert(data.first != nullptr);
const UncompressedImage uncompressed = LoadPNG(data.first, data.second);
assert(uncompressed.GetFormat() == UncompressedImage::Format::GRAY);
const size_t size = uncompressed.GetPitch() * uncompressed.GetHeight();
buffer.data = new Luminosity8[size];
memcpy(buffer.data, uncompressed.GetData(), size);
buffer.pitch = uncompressed.GetPitch();
buffer.width = uncompressed.GetWidth();
buffer.height = uncompressed.GetHeight();
}
