bool Image::initialize ( SDL_Surface* source )
{
// Discover the optimal pixel format using gathered device capabilities
RendererInfo caps = RenderWindow::caps( RenderWindow::context() );
if ( source == nullptr )
{
NOM_LOG_ERR ( NOM, "Could not initialize Image from existing surface: NULL" );
priv::FreeSurface ( source );
return false;
}
this->image_.reset ( SDL_ConvertSurfaceFormat ( source, caps.optimal_texture_format(), 0 ), priv::FreeSurface );
if ( this->valid() == false )
{
NOM_LOG_ERR ( NOM, "Could not initialize Image from existing surface: " + std::string(SDL_GetError()) );
priv::FreeSurface ( source );
return false;
}
priv::FreeSurface ( source );
return true;
}
NP::Texture
SDL2Renderer::load(const char *filename, bool cache)
{
std::string fn(filename);
if (cache) {
// Cache lookup
for (auto &item: m_texture_cache) {
if (item.first == fn) {
return item.second;
}
}
}
std::string f = Config::findFile(filename);
SDL_Surface *img = IMG_Load(f.c_str());
SDL_Surface *tmp = SDL_ConvertSurfaceFormat(img, SDL_PIXELFORMAT_ABGR8888, 0);
SDL_FreeSurface(img);
NP::Texture result = GLRenderer::load((unsigned char *)tmp->pixels, img->w, img->h);
SDL_FreeSurface(tmp);
if (cache) {
// Store loaded image in cache
m_texture_cache[fn] = result;
}
return result;
}
// Routine for loading color keyed textures and doing all the stupid stuff that comes with it
SDL_Texture* Graphics::LoadTexture(const char* sprite_sheet)
{
// load the image
SDL_Surface *surface = SDL_LoadBMP(sprite_sheet);
if (!surface) {
return NULL;
}
// create a duplicate of the surface with the same pixel format as the window
SDL_Surface *newSurface = SDL_ConvertSurfaceFormat(surface, SDL_GetWindowPixelFormat(gWindow), 0);
// no longer need to hang on to the original image
SDL_FreeSurface(surface);
if (!newSurface) {
return NULL;
}
// set (255,0,255) as the transparent color
if (SDL_SetColorKey(newSurface, SDL_TRUE, SDL_MapRGB(newSurface->format, 255, 0, 255))) {
return NULL;
}
// create a renderable texture from the image
SDL_Texture *texture = SDL_CreateTextureFromSurface(gRenderer, newSurface);
// no longer need to hang on to the converted image
SDL_FreeSurface(newSurface);
return texture;
}
bool DataStream::loadMedia()
{
bool success = true;
for (int i = 0; i < 4; ++i)
{
char path[64] = "";
sprintf_s(path, "42_texture_streaming/foo_walk_%d.png", i);
SDL_Surface* loadedSurface = IMG_Load(path);
if (loadedSurface == NULL)
{
printf("Unable to load %s! SDL_image error: %s\n", path, IMG_GetError());
success = false;
}
else
{
mImages[i] = SDL_ConvertSurfaceFormat(loadedSurface, SDL_PIXELFORMAT_RGBA8888, NULL);
}
SDL_FreeSurface(loadedSurface);
}
return success;
}
static SDL_Surface* CopySurface(SDL_Surface* surface)
{
return SDL_ConvertSurfaceFormat(
surface,
PixelFormat,
0);
}
void* BaseManager::loadImage(int& _width, int& _height, MyGUI::PixelFormat& _format, const std::string& _filename)
{
std::string fullname = MyGUI::OpenGLESDataManager::getInstance().getDataPath(_filename);
void* result = nullptr;
SDL_Surface *image = nullptr;
SDL_Surface *cvtImage = nullptr; // converted surface with RGBA/RGB pixel format
image = IMG_Load(fullname.c_str());
MYGUI_ASSERT(image != nullptr, "Failed to load image: " + fullname);
_width = image->w;
_height = image->h;
int bpp = image->format->BytesPerPixel;
if (bpp < 3)
{
result = convertPixelData(image, _format);
}
else
{
Uint32 pixelFmt = bpp == 3 ? SDL_PIXELFORMAT_BGR24 : SDL_PIXELFORMAT_ARGB8888;
cvtImage = SDL_ConvertSurfaceFormat(image, pixelFmt, 0);
result = convertPixelData(cvtImage, _format);
SDL_FreeSurface(cvtImage);
}
SDL_FreeSurface(image);
return result;
}
SDL_Surface* Image::clone ( void ) const
{
// Find the optimal pixel format
RendererInfo caps = RenderWindow::caps( RenderWindow::context() );
return SDL_ConvertSurfaceFormat ( this->image(), caps.optimal_texture_format(), 0 );
}
bool NXFont::InitChars(TTF_Font *font, uint32_t color)
{
SDL_Color fgcolor;
SDL_Surface *letter;
fgcolor.r = (uint8_t)(color >> 16);
fgcolor.g = (uint8_t)(color >> 8);
fgcolor.b = (uint8_t)(color);
char str[2];
str[1] = 0;
for(int i=1;i<NUM_LETTERS_RENDERED;i++)
{
str[0] = i;
letter = TTF_RenderText_Solid(font, str, fgcolor);
if (!letter)
{
staterr("InitChars: failed to render character %d: %s", i, TTF_GetError());
return 1;
}
Uint32 format = screen->Format()->format;
letters[i] = SDL_ConvertSurfaceFormat(letter, format, SDL_RLEACCEL);
SDL_FreeSurface(letter);
}
return 0;
}
int Pygame_SDL2_SaveJPEG(SDL_Surface *surface, const char *file) {
SDL_Surface *rgb_surf;
JSAMPROW *samples;
int i, rv;
rgb_surf = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_RGB24, 0);
if (! rgb_surf) {
return -1;
}
samples = (JSAMPROW *) malloc (sizeof(JSAMPROW) * rgb_surf->h);
if (!samples) {
SDL_FreeSurface(rgb_surf);
return -1;
}
/* copy pointers to the scanlines... since they might not be packed.
*/
for (i = 0; i < rgb_surf->h; i++) {
samples[i] = ((unsigned char*)rgb_surf->pixels) + i * rgb_surf->pitch;
}
rv = write_jpeg (file, samples, surface->w, surface->h, 90);
free(samples);
SDL_FreeSurface(rgb_surf);
return rv;
}
int PL_Texture_BlitSurface(int textureRefID, SDL_Surface *surface, const SDL_Rect *rect) {
TextureRef *textureref = (TextureRef*)PL_Handle_GetData(textureRefID, DXHANDLE_TEXTURE);
SDL_Texture *texture;
if (textureref == NULL || textureref->texture == NULL) {
return -1;
}
texture = textureref->texture;
/* Convert to target format if different. */
if (textureref->format != surface->format->format) {
SDL_Surface *tempSurface = SDL_ConvertSurfaceFormat(surface, textureref->format, 0);
if (SDL_MUSTLOCK(tempSurface)) {
SDL_LockSurface(tempSurface);
SDL_UpdateTexture(texture, rect, tempSurface->pixels, tempSurface->pitch);
SDL_UnlockSurface(tempSurface);
} else {
SDL_UpdateTexture(texture, rect, tempSurface->pixels, tempSurface->pitch);
}
SDL_FreeSurface(tempSurface);
} else {
if (SDL_MUSTLOCK(surface)) {
SDL_LockSurface(surface);
SDL_UpdateTexture(texture, rect, surface->pixels, surface->pitch);
SDL_UnlockSurface(surface);
} else {
SDL_UpdateTexture(texture, rect, surface->pixels, surface->pitch);
}
}
return 0;
}
static bool sdl2_gfx_read_viewport(void *data, uint8_t *buffer)
{
SDL_Surface *surf = NULL, *bgr24 = NULL;
sdl2_video_t *vid = (sdl2_video_t*)data;
RARCH_PERFORMANCE_INIT(sdl2_gfx_read_viewport);
RARCH_PERFORMANCE_START(sdl2_gfx_read_viewport);
video_driver_cached_frame();
surf = SDL_GetWindowSurface(vid->window);
bgr24 = SDL_ConvertSurfaceFormat(surf, SDL_PIXELFORMAT_BGR24, 0);
if (!bgr24)
{
RARCH_WARN("Failed to convert viewport data to BGR24: %s", SDL_GetError());
return false;
}
memcpy(buffer, bgr24->pixels, bgr24->h * bgr24->pitch);
RARCH_PERFORMANCE_STOP(sdl2_gfx_read_viewport);
return true;
}
void loadPicture(std::string file, GLuint tex){
if(file.find(".png")!=string::npos){
loadPNG(file.c_str(),tex);
cout<<"Loaded: "<<file<<endl;
}
if(file.find(".bmp")==string::npos)
return;
cout<<"Loading: "<<file<<endl;
SDL_Surface *image;
SDL_Surface *fixed;
image = SDL_LoadBMP(file.c_str());
if(!image){
cerr<<"error loading:"<<file;
return;
//system("pause");
}
fixed=SDL_ConvertSurfaceFormat(image,SDL_PIXELFORMAT_ABGR8888,0);
//SDL_SetColorKey(fixed,SDL_TRUE,0xFF00FF);
if(!fixed){
cerr<<"error loading:"<<file;
return;
//system("pause");
}
//if(!(is2Pwr(image->w)&&is2Pwr(image->h)))
// cerr<<"image is not power of 2 it may load incorrectly"<<endl;
// handle error
glBindTexture(GL_TEXTURE_2D,tex);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
//if(alpha)
//glTexImage2D( GL_TEXTURE_2D, 0, 4, image->w, image->h, 0,GL_BGRA, GL_UNSIGNED_BYTE, image->pixels );
//else
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, image->w, image->h, 0,GL_RGBA, GL_UNSIGNED_BYTE, fixed->pixels );
if ( image ) {
SDL_FreeSurface( image );
}
}
void
WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
HICON hicon = NULL;
BYTE *icon_bmp;
int icon_len;
SDL_RWops *dst;
SDL_Surface *surface;
/* Create temporary bitmap buffer */
icon_len = 40 + icon->h * icon->w * 4;
icon_bmp = SDL_stack_alloc(BYTE, icon_len);
dst = SDL_RWFromMem(icon_bmp, icon_len);
if (!dst) {
SDL_stack_free(icon_bmp);
return;
}
/* Write the BITMAPINFO header */
SDL_WriteLE32(dst, 40);
SDL_WriteLE32(dst, icon->w);
SDL_WriteLE32(dst, icon->h * 2);
SDL_WriteLE16(dst, 1);
SDL_WriteLE16(dst, 32);
SDL_WriteLE32(dst, BI_RGB);
SDL_WriteLE32(dst, icon->h * icon->w * 4);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
/* Convert the icon to a 32-bit surface with alpha channel */
surface = SDL_ConvertSurfaceFormat(icon, SDL_PIXELFORMAT_ARGB8888, 0);
if (surface) {
/* Write the pixels upside down into the bitmap buffer */
int y = surface->h;
while (y--) {
Uint8 *src = (Uint8 *) surface->pixels + y * surface->pitch;
SDL_RWwrite(dst, src, surface->pitch, 1);
}
SDL_FreeSurface(surface);
/* TODO: create the icon in WinCE (CreateIconFromResource isn't available) */
#ifndef _WIN32_WCE
hicon = CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000);
#endif
}
SDL_RWclose(dst);
SDL_stack_free(icon_bmp);
/* Set the icon for the window */
SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM) hicon);
/* Set the icon in the task manager (should we do this?) */
SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM) hicon);
}
static void ensureFormat(SDL_Surface *&surf, Uint32 format)
{
if (surf->format->format == format)
return;
SDL_Surface *surfConv = SDL_ConvertSurfaceFormat(surf, format, 0);
SDL_FreeSurface(surf);
surf = surfConv;
}
void Texture::LoadTexture_fromMemoryPage(const MemoryPage& input_page, const ScreenVideo& makerVideo) throw(Error){
this->Clean();
if(makerVideo.m_renderer==nullptr)
throw Error("Texture","LoadTexture_fromMemoryPage","Impossibile caricare una texture con uno specifico renderer nullo!");
if(makerVideo.m_renderer!=m_render) m_render = makerVideo.m_renderer;
if(input_page.GetSize()==0) return;
if(m_render==nullptr)
throw Error("Texture","LoadTexture_fromMemoryPage","Impossibile caricare la texture richiesta!\nRenderer non inizializzato!");
SDL_RWops* data_access = SDL_RWFromConstMem(input_page.Get_PtrMemory(),input_page.GetSize());
if(data_access==nullptr){
throw Error("Texture","LoadTexture_fromMemoryPage","Pagina di memoria corrotta!\n%s",SDL_GetError());
}else{
SDL_Surface* image_load = IMG_Load_RW(data_access,1);
if(image_load==nullptr){
throw Error("Texture","LoadTexture_fromMemoryPage","Impossibile caricare correttamente la texture richiesta\n%s",SDL_GetError());
}else{
SDL_Surface* image_opt = SDL_ConvertSurfaceFormat(image_load,SDL_PIXELFORMAT_RGBA8888,0);
SDL_FreeSurface(image_load);
image_load=nullptr;
if(image_opt==nullptr){
throw Error("Texture","LoadTexture_fromMemoryPage","Impossibile ottimizzare correttamente la texture richiesta\n%s",SDL_GetError());
}
this->m_texture = SDL_CreateTexture(m_render,SDL_PIXELFORMAT_RGBA8888,SDL_TEXTUREACCESS_STREAMING,image_opt->w,image_opt->h);
if(this->m_texture==nullptr){
SDL_FreeSurface(image_opt);
throw Error("Texture","LoadTexture_fromMemoryPage","Impossibile creare una texture grafica!\n%s",SDL_GetError());
}
void* data_pixel_texture;
int pitch_pixel_texture;
if(SDL_LockTexture(m_texture,NULL,&data_pixel_texture,&pitch_pixel_texture)!=0){
SDL_FreeSurface(image_opt);
SDL_DestroyTexture(m_texture);
throw Error("Texture","LoadTexture_fromMemoryPage","Impossibile scrivere la texture grafica!\n%s",SDL_GetError());
}
memcpy(data_pixel_texture,image_opt->pixels,image_opt->pitch * image_opt->h);
SDL_UnlockTexture(m_texture);
data_pixel_texture=nullptr;
m_w_size = image_opt->w;
m_h_size = image_opt->h;
m_w_size_scaled = image_opt->w;
m_h_size_scaled = image_opt->h;
m_drawnable_area.Set_AllComponent(0,0,image_opt->w,image_opt->h);
m_alpha_mod = SDL_ALPHA_OPAQUE;
SDL_FreeSurface(image_opt);
image_opt=nullptr;
SDL_SetTextureBlendMode(m_texture,SDL_BLENDMODE_BLEND);
}
}
}
TextureLoaderSDLSurfaceImpl::TextureLoaderSDLSurfaceImpl(SDL_Surface * surface):
m_surface(nullptr)
{
auto format = surface->format->format;
switch (format)
{
case SDL_PIXELFORMAT_RGB888:
m_surface = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_RGB888, 0);
break;
case SDL_PIXELFORMAT_RGBA8888:
case SDL_PIXELFORMAT_ARGB8888:
case SDL_PIXELFORMAT_ABGR8888:
m_surface = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_RGBA8888, 0);
break;
default:
Fail(std::string("Yet unsupported SDL Format: ") + SDL_GetPixelFormatName(format));
}
}
void convert()
{
SDL_Surface *convertedSurface =
SDL_ConvertSurfaceFormat(surface_,
SDL_PIXELFORMAT_ABGR8888, 0);
if (convertedSurface == 0) {
throw std::runtime_error(std::string("Failed to convert image to RGBA format: ") +
SDL_GetError());
}
SDL_FreeSurface(surface_);
surface_ = convertedSurface;
}
TexturePtr
TextureManager::create_image_texture_raw(const std::string& filename, const Rect& rect)
{
SDL_Surface *image = nullptr;
Surfaces::iterator i = m_surfaces.find(filename);
if (i != m_surfaces.end())
{
image = i->second;
}
else
{
image = IMG_Load_RW(get_physfs_SDLRWops(filename), 1);
if (!image)
{
std::ostringstream msg;
msg << "Couldn't load image '" << filename << "' :" << SDL_GetError();
throw std::runtime_error(msg.str());
}
m_surfaces[filename] = image;
}
SDL_PixelFormat* format = image->format;
if(format->Rmask == 0 && format->Gmask == 0 && format->Bmask == 0 && format->Amask == 0) {
log_debug << "Wrong surface format for image " << filename << ". Compensating." << std::endl;
image = SDL_ConvertSurfaceFormat(image, SDL_PIXELFORMAT_RGBA8888, 0);
}
SDLSurfacePtr subimage(SDL_CreateRGBSurfaceFrom(static_cast<uint8_t*>(image->pixels) +
rect.top * image->pitch +
rect.left * image->format->BytesPerPixel,
rect.get_width(), rect.get_height(),
image->format->BitsPerPixel,
image->pitch,
image->format->Rmask,
image->format->Gmask,
image->format->Bmask,
image->format->Amask));
if (!subimage)
{
throw std::runtime_error("SDL_CreateRGBSurfaceFrom() call failed");
}
#ifdef OLD_SDL
if (image->format->palette)
{ // copy the image palette to subimage if present
SDL_SetSurfacePalette(subimage.get(), image->format->palette->colors);
}
#endif
return VideoSystem::current()->new_texture(subimage.get());
}
OpenGLImage::OpenGLImage(SDL_Surface *surface)
: Image(std::string()), tex(genTexture(true)), w(surface->w), h(surface->h) {
int texture_format;
bool colorNoAlpha = (surface->format->BitsPerPixel == 24 && surface->format->BytesPerPixel==3);
bool colorAlpha = (surface->format->BitsPerPixel == 32 && surface->format->BytesPerPixel==4);
uint32_t v255shift24 = 255;
v255shift24 <<= 24;
if (colorNoAlpha && surface->format->Rmask == 255 && surface->format->Gmask == (255 << 8) && surface->format->Bmask == (255 << 16)) {
texture_format = GL_RGB;
#ifndef USE_GLES
} else if (colorNoAlpha && surface->format->Bmask == 255 && surface->format->Gmask == (255 << 8) && surface->format->Rmask == (255 << 16)) {
texture_format = GL_BGR;
} else if (colorAlpha && surface->format->Bmask == 255 && surface->format->Gmask == (255 << 8) && surface->format->Rmask == (255 << 16) && surface->format->Amask == v255shift24) {
texture_format = GL_BGRA;
#endif
} else if (colorAlpha && surface->format->Rmask == 255 && surface->format->Gmask == (255 << 8) && surface->format->Bmask == (255 << 16) && surface->format->Amask == v255shift24) {
texture_format = GL_RGBA;
} else {
#ifdef USE_SDL2
SDL_Surface *newSurf = SDL_ConvertSurfaceFormat(
surface, SDL_PIXELFORMAT_ABGR8888, 0);
#else
SDL_Surface *newSurf = SDL_CreateRGBSurface(
SDL_SWSURFACE, surface->w, surface->h, 32,
255, (255 << 8), (255 << 16), v255shift24);
SDL_Rect r;
r.x = 0;
r.y = 0;
r.w = surface->w;
r.h = surface->h;
if ( (surface->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
surface->flags &= ~SDL_SRCALPHA;
}
SDL_LowerBlit(surface, &r, newSurf, &r);
#endif
SDL_FreeSurface(surface);
surface = newSurf;
texture_format = GL_RGBA;
colorNoAlpha = false;
colorAlpha = true;
}
if (!SDL_LockSurface(surface)) {
glTexImage2D( GL_TEXTURE_2D, 0, colorAlpha ? GL_RGBA : GL_RGB, w, h, 0,
texture_format, GL_UNSIGNED_BYTE, surface->pixels);
stage = COMPLETE;
#ifndef EMSCRIPTEN
SDL_UnlockSurface(surface);
#endif
}
SDL_FreeSurface(surface);
}
static SDL_Surface* load_sdl_surface_from_file(const std::string& Path) {
SDL_Surface* Surface = IMG_Load(Path.c_str());
if (!Surface) {
DEBUG(0, NE_WARNING, "Failed to load image. Surface is nullpointer. Error: " << IMG_GetError());
return nullptr;
}
SDL_Surface *ARGBSurface = SDL_ConvertSurfaceFormat(Surface, SDL_PIXELFORMAT_ARGB8888, 0);
if (!ARGBSurface) {
DEBUG(0, NE_WARNING, "Failed call to SDL_ConvertSurfaceFormat. Nullpointer returned.");
}
SDL_FreeSurface(Surface);
return ARGBSurface;
}
/* implementation */
SDL_Surface* RenderManagerSDL::colorSurface(SDL_Surface *surface, Color color)
{
// Create new surface
SDL_Surface *newSurface = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ABGR8888, 0);
SDL_LockSurface(newSurface);
for (int p = 0; p < newSurface->w * newSurface->h; ++p)
{
SDL_Color* pixel = &(((SDL_Color*)newSurface->pixels)[p]);
int rr = (int(pixel->r) * int(color.r)) >> 8;
int rg = (int(pixel->g) * int(color.g)) >> 8;
int rb = (int(pixel->b) * int(color.b)) >> 8;
int fak = int(pixel->r) * 5 - 4 * 256 - 138;
bool colorkey = !(pixel->r | pixel->g | pixel->b);
if (colorkey)
{
pixel->r = 0;
pixel->g = 0;
pixel->b = 0;
pixel->a = 0;
continue;
}
if (fak > 0)
{
rr += fak;
rg += fak;
rb += fak;
}
rr = rr < 255 ? rr : 255;
rg = rg < 255 ? rg : 255;
rb = rb < 255 ? rb : 255;
// This is clamped to 1 because dark colors may would be
// colorkeyed otherwise
pixel->r = rr > 0 ? rr : 1;
pixel->g = rg > 0 ? rg : 1;
pixel->b = rb > 0 ? rb : 1;
}
SDL_UnlockSurface(newSurface);
// Use a black colorkey
SDL_SetColorKey(newSurface, SDL_TRUE,
SDL_MapRGB(newSurface->format, 0, 0, 0));
return newSurface;
}
Texture::Texture(SDL_Surface &surface, GLenum texUnit) {
GLint intFormat;
GLenum format, type;
bool recognised;
_refCount = 0;
glGenTextures(1, &_GLtexture);
Logger::logprintf(Logger::LOG_VERBOSEINFO, Logger::LOG_TEXTURES, "Loading SDL Surface 0x%X (Pixel Format %s) to OpenGL name %i and Texture Unit GL_TEXTURE%i\n", &surface,SDL_GetPixelFormatName(surface.format->format), _GLtexture, texUnit - GL_TEXTURE0);
switch(surface.format->format) {
case SDL_PIXELFORMAT_ABGR8888:
intFormat = GL_RGBA8;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
recognised = true;
break;
case SDL_PIXELFORMAT_ARGB8888:
intFormat = GL_RGBA8;
format = GL_BGRA;
type = GL_UNSIGNED_BYTE;
recognised = true;
break;
default:
Logger::logprintf(Logger::LOG_WARN, Logger::LOG_TEXTURES, "No mapped GL format for SDL pixel format %s, will be reformatted internally\n", SDL_GetPixelFormatName(surface.format->format));
recognised = false;
break;
}
glActiveTexture(texUnit);
glBindTexture( GL_TEXTURE_2D, _GLtexture);
_loaded = checkGLError("glBindTexture failed: %s\n", Logger::LOG_ERROR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
if ( recognised ) {
glTexImage2D( GL_TEXTURE_2D, 0, intFormat, surface.w, surface.h
, 0, format, type, surface.pixels );
} else {
SDL_Surface *surface_bgra;
Logger::logprintf(Logger::LOG_INFO, Logger::LOG_TEXTURES, "Converting source SDL pixel format %s to SDL_PIXELFORMAT_ABGR8888\n", SDL_GetPixelFormatName(surface.format->format));
surface_bgra = SDL_ConvertSurfaceFormat(&surface, SDL_PIXELFORMAT_ABGR8888, 0);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, surface_bgra->w, surface_bgra->h
, 0, GL_RGBA, GL_UNSIGNED_BYTE, surface_bgra->pixels );
SDL_FreeSurface(surface_bgra);
}
_loaded &= checkGLError("Failed to load texture from SDL Surface: %s\n", Logger::LOG_ERROR);
}
/**
* @brief Convert The Surface to match Texture Pixel Format
* @return
*/
bool convert()
{
if (!m_is_converted)
{
m_surface = SDL_ConvertSurfaceFormat(m_surface, SDL_PIXELFORMAT_ARGB8888, 0);
if(!m_surface)
{
SDL_Log("Unable to Convert Surface");
return false;
}
m_is_converted = true;
}
return true;
}
SDL_Surface* Surface::OnLoad(const char* File) {
SDL_Surface* Surf_Temp = NULL;
SDL_Surface* Surf_Return = NULL;
if ((Surf_Temp = SDL_LoadBMP(File)) == NULL) {
GameError(SDL_GetError());
return NULL;
}
Surf_Return = SDL_ConvertSurfaceFormat(Surf_Temp, SDL_PIXELFORMAT_RGB888, 0);
//Surf_Return = SDL_DisplayFormat(Surf_Temp);
SDL_FreeSurface(Surf_Temp);
return Surf_Return;
}
Sprite* SpriteManager::CreateSprite(const std::string& filename, int x, int y, int w, int h)
{
// first we search for if the texture is already loaded
auto it = m_textures.find(filename);
if (it == m_textures.end())
{
// if not, we create a new one
SDL_Surface* surface = IMG_Load(filename.c_str());
SDL_Surface* optimizedSurface;
if (surface != nullptr)
{
optimizedSurface = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ABGR4444, 0);
SDL_FreeSurface(surface);
SDL_Texture* texture = SDL_CreateTextureFromSurface(m_renderer, optimizedSurface);
// we save the texture in the map for later reuse
m_textures.insert(std::pair<std::string, SDL_Texture*>(filename, texture));
// we can destroy the surface
// since we now have a texture
// that we use instead
if (optimizedSurface != nullptr)
{
SDL_FreeSurface(optimizedSurface);
}
else
{
const char* error = SDL_GetError();
}
// now we get the texture so we can return it with a sprite
it = m_textures.find(filename);
}
}
// then we create a new sprite
// with the texture associated
Sprite* sprite = new Sprite(it->second);
sprite->GetRegion()->x = x;
sprite->GetRegion()->y = y;
sprite->GetRegion()->w = w;
sprite->GetRegion()->h = h;
m_sprites.push_back(sprite);
// return the newly newed sprite
return sprite;
}
/* Adds background image to the console, x and y based on consoles x and y */
int CON_Background(ConsoleInformation *console, const char *image, int x, int y, SDL_Surface* displayScreen) {
SDL_Surface *temp;
SDL_Rect backgroundsrc, backgrounddest;
if(!console)
return 1;
/* Free the background from the console */
if(image == NULL) {
if(console->BackgroundImage ==NULL)
SDL_FreeSurface(console->BackgroundImage);
console->BackgroundImage = NULL;
SDL_FillRect(console->InputBackground, NULL, SDL_MapRGBA(console->ConsoleSurface->format, 0, 0, 0, SDL_ALPHA_OPAQUE));
return 0;
}
/* Load a new background */
#ifdef HAVE_SDLIMAGE
temp = IMG_Load(image);
#else
temp = SDL_LoadBMP(image);
#endif
if(!temp) {
CON_Out(console, "Cannot load background %s.", image);
return 1;
}
//console->BackgroundImage = SDL_DisplayFormat(temp);
console->BackgroundImage = SDL_ConvertSurfaceFormat(temp, displayScreen->format->format, displayScreen->flags);
SDL_FreeSurface(temp);
console->BackX = x;
console->BackY = y;
backgroundsrc.x = 0;
backgroundsrc.y = console->ConsoleSurface->h - console->FontHeight - console->BackY;
backgroundsrc.w = console->BackgroundImage->w;
backgroundsrc.h = console->InputBackground->h;
backgrounddest.x = console->BackX;
backgrounddest.y = 0;
backgrounddest.w = console->BackgroundImage->w;
backgrounddest.h = console->FontHeight;
SDL_FillRect(console->InputBackground, NULL, SDL_MapRGBA(console->ConsoleSurface->format, 0, 0, 0, SDL_ALPHA_OPAQUE));
SDL_BlitSurface(console->BackgroundImage, &backgroundsrc, console->InputBackground, &backgrounddest);
CON_UpdateConsole(console);
return 0;
}
bool Image::load_bmp ( const std::string& filename, uint32 pixel_format )
{
SDL_Surface *buffer = IMG_Load ( filename.c_str() );
if ( buffer == nullptr )
{
NOM_LOG_ERR ( NOM, IMG_GetError() );
priv::FreeSurface ( buffer );
return false;
}
this->image_.reset ( SDL_ConvertSurfaceFormat ( buffer, pixel_format, 0 ), priv::FreeSurface );
priv::FreeSurface ( buffer );
return true;
}
virtual Bitmap *Load(IStream *stream) {
SPADES_MARK_FUNCTION();
// read all
std::string data = stream->ReadAllBytes();
auto deleter = [](SDL_Surface *s) { SDL_FreeSurface(s); };
// copy to buffer
std::unique_ptr<SDL_Surface, decltype(deleter)> imgraw(LoadSdlImage(data), deleter);
if (imgraw == nullptr) {
SPRaise("SDL surface was not loaded.");
}
std::unique_ptr<SDL_Surface, decltype(deleter)> img(
SDL_ConvertSurfaceFormat(imgraw.get(), SDL_PIXELFORMAT_ABGR8888, 0), deleter);
if (img == nullptr) {
SPRaise("SDL surface was loaded, but format conversion failed.");
}
const unsigned char *inPixels = (const unsigned char *)img->pixels;
int width = img->w;
int height = img->h;
int pitch = img->pitch;
Handle<Bitmap> bmp;
bmp.Set(new Bitmap(width, height), false);
try {
unsigned char *outPixels = (unsigned char *)bmp->GetPixels();
if (pitch == width * 4) {
// if the pitch matches the requirement of Bitmap,
// just use it
memcpy(outPixels, inPixels, pitch * height);
} else {
// convert
for (int y = 0; y < height; y++) {
memcpy(outPixels, inPixels, width * 4);
outPixels += width * 4;
inPixels += pitch;
}
}
return bmp.Unmanage();
} catch (...) {
throw;
}
}
/** Create a copy of an SDL surface using a bit format that can be fed straight
* to libpng. This will create a surface in 24 bit R, G, B or 32bit R, G, B, A
* so that libpng can process it directly, avoiding the need for on-the-fly
* format conversion shenanigans.
*
* \param surf The surface to convert.
* \param alpha True if the converted surface should have an alpha channel.
* \return A pointer to a copy of the surface in the usable format. The caller must
* free this surface when done with it.
*/
static SDL_Surface *make_usable_format(SDL_Surface *surf, int alpha)
{
// Yes, it's probably horrible to just straight up declare these two, but ffs
// it takes up all of 80 bytes of stack space for these...
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
Uint32 f24 = SDL_PIXELFORMAT_BGR24;
Uint32 f32 = SDL_PIXELFORMAT_ABGR8888;
#else
Uint32 f24 = SDL_PIXELFORMAT_RGB24;
Uint32 f32 = SDL_PIXELFORMAT_RGBA8888;
#endif
// Make a copy of our errant surface
SDL_Surface *rgb_surf = SDL_ConvertSurfaceFormat(surf, alpha > 0 ? f32 : f24, 0);
return rgb_surf;
}
void Button::setSource(const string& file)
{
SDL_Surface* loaded = NULL;
string ext = file.substr(file.size() - 4);
if (ext == ".bmp")
loaded = SDL_LoadBMP(file.c_str());
else if (ext == ".png")
loaded = IMG_Load(file.c_str());
else
printf("Unsupported format!\n");
if (loaded != NULL)
{
source = SDL_ConvertSurfaceFormat(loaded, surface->getSurface()->format->format,
surface->getSurface()->flags);
SDL_FreeSurface(loaded);
}
}
