int main(int argc, char * argv[]) { //Load the config and apply //Load the configs of screen win_w = cfg.Load(KEY_WINWIDTH); win_h = cfg.Load(KEY_WINHEIGHT); //Load the volumn and apply snd.ApplyCfg(BGMCN, cfg.Load(BGMCN)); snd.ApplyCfg(SECN, cfg.Load(SECN)); snd.ApplyCfg(VCECN, cfg.Load(VCECN)); //Init SDL_Init(SDL_INIT_EVENTS); win = SDL_CreateWindow("MaikazeSekai", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, win_w, win_h, SDL_WINDOW_OPENGL); ren = SDL_CreateRenderer(win, -1, 0); SDL_RenderSetLogicalSize(ren, 1280, 720); blk = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, win_w, win_h); //sent the renderer to Class Image as a stage and init them with the FileMgr img.Init(ren, &file); snd.Init(&file); auto *rw = SDL_RWFromFile("z:/star.png", "r"); auto sur = IMG_Load_RW(rw, AUTOFREE); auto tex = SDL_CreateTextureFromSurface(ren, sur); SDL_FreeSurface(sur); SDL_Rect rt = { 0, 0, 2362, 7087 }; SDL_RenderCopy(ren, tex, NULL, &rt); SDL_RenderPresent(ren); SDL_DestroyTexture(tex); auto *rw2 = SDL_RWFromFile("z:/1.png", "r"); auto sur2 = IMG_Load_RW(rw2, AUTOFREE); auto tex2 = SDL_CreateTextureFromSurface(ren, sur2); SDL_FreeSurface(sur2); SDL_Rect rt2 = { 0, 0, 800, 900 }; SDL_RenderCopy(ren, tex2, NULL, &rt2); SDL_RenderPresent(ren); //SDL_DestroyTexture(tex); // BGM("yui.wav", 1, 0); BG("sample.png"); img.OnDraw(); //Refresh the textures on renderer SDL_RenderPresent(ren); UnLoadBG(); //SDL_DestroyTexture() //Logo(); //Title(); SDL_Quit(); return 0; }
surface get_no_cache(const std::string& key) { std::string fname = path + key; #if defined(__ANDROID__) if(fname[0] == '.' && fname[1] == '/') { fname = fname.substr(2); } SDL_RWops *rw = sys::read_sdl_rw_from_asset(module::map_file(fname).c_str()); surface surf; if(rw) { surf = surface(IMG_Load_RW(rw,1)); } else { surf = surface(IMG_Load(module::map_file(fname).c_str())); } #else surface surf = surface(IMG_Load(module::map_file(fname).c_str())); #endif // ANDROID //std::cerr << "loading image '" << fname << "'\n"; if(surf.get() == false || surf->w == 0) { std::cerr << "failed to load image '" << key << "'\n"; throw load_image_error(); } //std::cerr << "IMAGE SIZE: " << (surf->w*surf->h) << "\n"; return surf; }
/** * @brief Needs Debug * @param file_name name of the image file to load, relative to the base directory specified * @param base_directory the base directory to use */ Surface::Surface(const std::string& file_name, ImageDirectory base_directory): Drawable(), internal_surface_created(true) { std::string prefix = ""; bool language_specific = false; if(base_directory == DIR_SPRITES) { prefix = "sprites/"; } std::string prefixed_file_name = prefix + file_name; std::cout << prefixed_file_name << std::endl; size_t size; char* buffer; FileTools::data_file_open_buffer(prefixed_file_name, &buffer, &size); SDL_RWops* rw = SDL_RWFromMem(buffer, int(size)); if(rw == NULL) std::cout << "rw didn't load\n"; this->internal_surface = IMG_Load_RW(rw, 0); if(!internal_surface) { printf( "IMG_Load: %s\n", IMG_GetError()); return; } FileTools::data_file_close_buffer(buffer); SDL_RWclose(rw); //Debug assertion }
Image::Image(const char *filename) { SDL_RWops *image = SDL_RWFromFile(filename, "rb"); m_surface = IMG_Load_RW(image, 1); if(!m_surface) { fprintf(stderr, "Failed to load image \"%s\": %s\n", filename, IMG_GetError()); exit(EXIT_FAILURE); } m_width = m_surface->w; m_height = m_surface->h; m_texture = SDL_CreateTextureFromSurface(Window::main->renderer(), m_surface); if(!m_texture) { fprintf(stderr, "Failed to create texture from image: %s", SDL_GetError()); exit(EXIT_FAILURE); } m_clipRect.x = 0; m_clipRect.y = 0; m_clipRect.w = m_width; m_clipRect.h = m_height; m_posRect.x = 0; m_posRect.y = 0; m_posRect.w = m_width; m_posRect.h = m_height; }
gcn::Image* InfraellyImageLoader::load(unsigned char *buffer, long bufferLength, bool convertToDisplayFormat){ //make rWop out of character buffer SDL_RWops *source_Rwop = SDL_RWFromMem(buffer, bufferLength); //load the rWop into a SDL Surface SDL_Surface *loadedSurface = IMG_Load_RW(source_Rwop, 1); if (loadedSurface == NULL) { throw GCN_EXCEPTION( std::string("Unable to load image file: ") ); } SDL_Surface *surface = convertToStandardFormat(loadedSurface); SDL_FreeSurface(loadedSurface); if (surface == NULL) { throw GCN_EXCEPTION( std::string("Not enough memory to load: ") ); } gcn::Image *image = new gcn::SDLImage(surface, true); if (convertToDisplayFormat) { image->convertToDisplayFormat(); } return image; }
gSurface *gLoadImage(const char *name) { gSurface *ret; SDL_RWops *ops; if(!PHYSFS_exists(name)) { gSetError("gLoadImage was unable to load the image %s", name); return NULL; } ops = PHYSFSRWOPS_openRead(name); if(!ops) { gSetError("gLoadImage was unable to load the image %s: failed _openRead", name); return NULL; } if(!(ret = IMG_Load_RW(ops, true))) { gSetError("gLoadImage was unable to load the image %s: %s", name, SDL_GetError()); return NULL; } return ret; }
void SetWindowIcon(photon_window &window, const std::string &filename){ if(PHYSFS_exists(filename.c_str())){ auto fp = PHYSFS_openRead(filename.c_str()); intmax_t length = PHYSFS_fileLength(fp); if(length > 0){ uint8_t *buffer = new uint8_t[length]; PHYSFS_read(fp, buffer, 1, length); PHYSFS_close(fp); SDL_RWops *rw = SDL_RWFromMem(buffer, length); SDL_Surface *icon = IMG_Load_RW(rw, 1); if(icon == nullptr){ PrintToLog("ERROR: icon loading failed! %s", IMG_GetError()); } SDL_SetWindowIcon(window.window_SDL, icon); SDL_FreeSurface(icon); delete[] buffer; }else{ PrintToLog("ERROR: Unable to open image file \"%s\"!"); } }else{ PrintToLog("ERROR: Image file \"%s\" does not exist!", filename.c_str()); } }
SDL_Surface *WadImageCache::image_from_desc(WadImageDescriptor& desc) { SDL_Surface *surface = NULL; OpenedFile wad_file; if (open_wad_file_for_reading(desc.file, wad_file)) { struct wad_header header; if (read_wad_header(wad_file, &header)) { struct wad_data *wad; wad = read_indexed_wad_from_file(wad_file, &header, desc.index, true); if (wad) { void *data; size_t length; data = extract_type_from_wad(wad, desc.tag, &length); if (data && length) { SDL_RWops *rwops = SDL_RWFromConstMem(data, length); #ifdef HAVE_SDL_IMAGE surface = IMG_Load_RW(rwops, 1); #else surface = SDL_LoadBMP_RW(rwops, 1); #endif } free_wad(wad); } } close_wad_file(wad_file); } clear_game_error(); return surface; }
int img_read(char *filein) { SDL_PixelFormat *fmt; // we need that to determine which BPP SDL_RWops *rw; if (g_statics.debug) { printf("Reading from %s\n", filein); fflush(stdout); } if (!strcmp(filein, "-")) { // stdin as input. Shouldn't work but we try anyways rw = SDL_RWFromFP(stdin, 0); } else { // a regular file name rw = SDL_RWFromFile(filein, "rb"); } g_statics.image_in = IMG_Load_RW(rw, 0); if (g_statics.image_in == NULL) { fprintf(stderr, "ERROR: %s\n", SDL_GetError()); SDL_FreeRW(rw); return(-1); } // check if image is in 8bpp format fmt = g_statics.image_in->format; if (fmt->BitsPerPixel != 8) { fprintf(stderr, "ERROR: the image file is not in 8 bpp. Please convert it.\n"); SDL_FreeSurface(g_statics.image_in); SDL_FreeRW(rw); return(-1); } if (g_statics.image_in->w != 192 || g_statics.image_in->h != 192) { fprintf(stderr, "ERROR: The image file is not 192x192 pixels. Please modify it.\n"); SDL_FreeSurface(g_statics.image_in); SDL_FreeRW(rw); return(-1); } if (g_statics.debug > 1) { printf("The image file uses %d colours\n", fmt->palette->ncolors); fflush(stdout); } if ((g_variables.image_out = SDL_CreateRGBSurfaceFrom(g_statics.image_in->pixels, g_statics.image_in->w, g_statics.image_in->h, g_statics.image_in->pitch, g_statics.image_in->format->BitsPerPixel, 0, 0, 0, 0)) == NULL) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return(-1); } // need to convert the image using proper values for format, since there is a strong likelyhood to have more colours in the palette than for image_in. // algo: create proper palette, retrieve number of colours // update image_in->format->palette with new info // launch SDL_ConvertSurface g_variables.image_out = SDL_ConvertSurface(g_variables.image_out, g_statics.image_in->format, SDL_SWSURFACE); // a bit of clean up SDL_FreeRW(rw); return(0); }
// // TextureResourceLoader::VLoadResource - Chapter 14, page 492 // bool TextureResourceLoader::VLoadResource( char *rawBuffer, unsigned int rawSize, shared_ptr<ResHandle> handle ) { Renderer renderer = EngineApp::GetRendererImpl(); if ( renderer == Renderer::Renderer_OpenGL ) { SDL_RWops* p_RWops = SDL_RWFromMem( rawBuffer, rawSize ); if( !p_RWops ) { ENG_ERROR( SDL_GetError() ); return false; } SDL_Surface* p_Surface = IMG_Load_RW( p_RWops, 0 ); if( SDL_RWclose( p_RWops ) ) { ENG_WARNING( SDL_GetError() ); } if( !p_Surface ) { ENG_ERROR( SDL_GetError() ); return false; } shared_ptr<SDLTextureResourceExtraData> extra = shared_ptr<SDLTextureResourceExtraData>( ENG_NEW SDLTextureResourceExtraData() ); extra->m_pSurface = p_Surface; handle->SetExtraData( extra ); handle->SetSize( extra->m_pSurface->w * extra->m_pSurface->h * extra->m_pSurface->format->BytesPerPixel ); } return true; }
gcn::Image* InfraellyImageLoader::load(SDL_RWops *source_Rwop, bool freeRWOP, bool convertToDisplayFormat){ //load the rWop into a SDL Surface SDL_Surface *loadedSurface = IMG_Load_RW(source_Rwop, freeRWOP); if (loadedSurface == NULL) { throw GCN_EXCEPTION( std::string("Unable to load image file: ") ); } SDL_Surface *surface = convertToStandardFormat(loadedSurface); SDL_FreeSurface(loadedSurface); if (surface == NULL) { throw GCN_EXCEPTION( std::string("Not enough memory to load: ") ); } gcn::Image *image = new gcn::SDLImage(surface, true); if (convertToDisplayFormat) { image->convertToDisplayFormat(); } return image; }
SDL_Texture* LoadTextureFromFile(const String &file, SDL_Renderer *renderer) { SDL_Texture *texture = nullptr; SDL_Surface *loadedImage = nullptr; //android #if defined(__ANDROID__) SDL_RWops *f = SDL_RWFromFile(file.c_str(), "rb"); loadedImage = IMG_Load_RW(f , 1); if(f > 0) __android_log_write(ANDROID_LOG_INFO, "Chain Drop", "File Loaded"); #elif defined(_WIN32) loadedImage = IMG_Load(file.c_str()); #endif //If the loading went ok, convert to texture and return the texture if (loadedImage != nullptr) { texture = SDL_CreateTextureFromSurface(renderer, loadedImage); SDL_FreeSurface(loadedImage); //Make sure converting went ok too if (texture == nullptr) logSDLError(std::cout, "LoadTextureFromFile"); } else logSDLError(std::cout, "LoadTextureFromFile"); return texture; }
void ResourceFile::load(std::string source) { std::ifstream is(source.c_str(), std::ifstream::binary); ResourceMarker marker = ResourceMarker(); while(!is.eof()) { is.read( (char*) &marker, sizeof(ResourceMarker) ); int rlength = marker.length; std::string rname = marker.name; char * buffer = new char[rlength]; is.read(buffer, rlength); SDL_RWops *rw = SDL_RWFromMem(buffer, rlength); SDL_Surface *sdlSurface = IMG_Load_RW(rw, 1); Surface *surface = new Surface(sdlSurface); surface->setReleaseSurface(true); std::cout << IMG_GetError() << std::endl; //some error handling to do here delete buffer; resources.insert(std::make_pair(rname, surface)); } is.close(); }
/**\brief Load image from buffer */ bool Image::Load( char *buf, int bufSize ) { SDL_RWops *rw; SDL_Surface *s = NULL; rw = SDL_RWFromMem( buf, bufSize ); if( !rw ) { LogMsg(WARN, "Image loading failed. Could not create RWops" ); return( false ); } s = IMG_Load_RW( rw, 0 ); SDL_FreeRW(rw); if( !s ) { LogMsg(WARN, "Image loading failed. Could not load image from RWops" ); return( false ); } w = s->w; h = s->h; if( ConvertToTexture( s ) == false ) { LogMsg(WARN, "Failed to load image from buffer" ); SDL_FreeSurface( s ); return( false ); } return( true ); }
GLuint Graphic::LoadTexture( const char* src, GLfloat *texcoord, Uint32* width, Uint32* height) { static std::pair<GLuint, TexCoordArray> dat; tex_iter iter = texMap.find(src); GLuint texture; if (iter != texMap.end()) { texture = iter->second.first; memcpy(texcoord, iter->second.second.data, 4 * sizeof(GLfloat)); *width = iter->second.second.w; *height = iter->second.second.h; } else { SDL_Surface *surface = IMG_Load_RW(Storage::GetInstance()->OpenIFile(src), 1); if (!surface) { char buf[256]; snprintf(buf, sizeof(buf), "Load file failed: %s", src); throw Exception(buf); } texture = SDL_GL_LoadTexture(surface, texcoord); if (texture == 0) { throw Exception("failed create texture."); } dat.first = texture; memcpy(dat.second.data, texcoord, 4*sizeof(GLfloat)); dat.second.w = *width = surface->w; dat.second.h = *height = surface->h; texMap[src] = dat; SDL_FreeSurface(surface); } return texture; }
int PLEXT_Window_SetIconImageFile(const DXCHAR *filename) { SDL_Surface *surface; SDL_RWops *file; file = PL_File_OpenStream(filename); if (file == NULL) { return -1; } surface = IMG_Load_RW(file, SDL_TRUE); if (surface == NULL) { return -1; } if (s_windowIcon != NULL) { SDL_FreeSurface(s_windowIcon); } s_windowIcon = surface; if (s_initialized == DXTRUE) { SDL_SetWindowIcon(s_window, s_windowIcon); } return 0; }
surface surface::load(std::streambuf* buf,string type) { surface surface; SDL_RWops* wop = build_rwops_stream(buf); struct noname { SDL_RWops* woop; ~noname() { if(woop!=NULL) SDL_RWclose(woop); } } destroyer; destroyer.woop = wop; if(type=="auto") surface.build(IMG_Load_RW(wop,false)); else surface.build(IMG_LoadTyped_RW(wop,false,(char*)type.c_str())); return surface; /*int beg = strea.tellg(); strea.seekg(0,ios::end); int size = ((int)strea.tellg())-beg; strea.seekg(beg,ios::beg); vector<char> vec(size); strea.read(&vec[0],size); SDL_RWops* wop = SDL_RWFromConstMem(&vec[0],size); if(wop == NULL) throw exception_sdl(); if(type=="auto") surface.build(IMG_Load_RW(wop,true)); else surface.build(IMG_LoadTyped_RW(wop,true,(char*)type.c_str())); return surface;*/ }
/** * \brief Creates a surface from the specified image file name. * * An assertion error occurs if the file cannot be loaded. * * \param file_name Name of the image file to load, relative to the base directory specified. * \param base_directory The base directory to use. */ Surface::Surface(const std::string& file_name, ImageDirectory base_directory): Drawable(), internal_surface(NULL), owns_internal_surface(true), with_colorkey(false), colorkey(0) { std::string prefix = ""; bool language_specific = false; if (base_directory == DIR_SPRITES) { prefix = "sprites/"; } else if (base_directory == DIR_LANGUAGE) { language_specific = true; prefix = "images/"; } std::string prefixed_file_name = prefix + file_name; size_t size; char* buffer; FileTools::data_file_open_buffer(prefixed_file_name, &buffer, &size, language_specific); SDL_RWops* rw = SDL_RWFromMem(buffer, int(size)); this->internal_surface = IMG_Load_RW(rw, 0); FileTools::data_file_close_buffer(buffer); SDL_RWclose(rw); Debug::check_assertion(internal_surface != NULL, StringConcat() << "Cannot load image '" << prefixed_file_name << "'"); with_colorkey = SDL_GetColorKey(internal_surface, &colorkey) == 0; }
SDL_Texture* LoadData::LoadImages(char *filename) { SDL_RWops* RW_src = NULL; SDL_Texture* ret = NULL; //RW_src = LoadFile_RW(filename); RW_src = loadFile_PHYSFS(filename); if (RW_src != NULL) { SDL_Surface* toLoadSurface = IMG_Load_RW(RW_src, 1); if (toLoadSurface == NULL) { LOG("Failed to load IMG from RW! ERROR: %s", IMG_GetError()); } else { //ret = SDL_CreateTextureFromSurface(App->render->renderer, toLoadSurface); //App->tex->textures.add(ret); ret = App->tex->LoadSurface(toLoadSurface); SDL_FreeSurface(toLoadSurface); if (ret == NULL) { LOG("Failed to load IMG from RW! ERROR: %s", IMG_GetError()); } } } return ret; }
static SDL_Surface* IMG_Load_istream(std::istream* stream, int freesrc) { SDL_RWops* irwops = reinterpret_cast<SDL_RWops*>(malloc(sizeof SDL_RWops)); SimKit::construct_istream_rwops_adapter(irwops, i); SDL_Surface* out = IMG_Load_RW(irwops, freesrc); if (freesrc == 0) free(irwops); return out; };
SDL_Surface* Texture::loadImage(unsigned dsize, const char* data, const char *extension, const char *mimeType) { SDL_RWops* rw = SDL_RWFromMem((void *)data,dsize); SDL_Surface* s=IMG_Load_RW(rw,true); if (!s) JGACHINE_FATAL("Could not load image"); return s; };
void ImageLoader::load(IResource* res) { VFS* vfs = VFS::instance(); Image* img = dynamic_cast<Image*>(res); //Have to save the images x and y shift or it gets lost when it's //loaded again. int32_t xShiftSave = img->getXShift(); int32_t yShiftSave = img->getYShift(); if(!img->isSharedImage()) { const std::string& filename = img->getName(); boost::scoped_ptr<RawData> data (vfs->open(filename)); size_t datalen = data->getDataLength(); boost::scoped_array<uint8_t> darray(new uint8_t[datalen]); data->readInto(darray.get(), datalen); SDL_RWops* rwops = SDL_RWFromConstMem(darray.get(), static_cast<int>(datalen)); SDL_Surface* surface = IMG_Load_RW(rwops, false); if (!surface) { throw SDLException(std::string("Fatal Error when loading image into a SDL_Surface: ") + SDL_GetError()); } RenderBackend* rb = RenderBackend::instance(); // in case of SDL we don't need to convert the surface if (rb->getName() == "SDL") { img->setSurface(surface); // in case of OpenGL we need a 32bit surface } else { SDL_PixelFormat dst_format = rb->getPixelFormat(); SDL_PixelFormat src_format = *surface->format; uint8_t dstbits = dst_format.BitsPerPixel; uint8_t srcbits = src_format.BitsPerPixel; if (srcbits != 32 || dst_format.Rmask != src_format.Rmask || dst_format.Gmask != src_format.Gmask || dst_format.Bmask != src_format.Bmask || dst_format.Amask != src_format.Amask) { dst_format.BitsPerPixel = 32; SDL_Surface* conv = SDL_ConvertSurface(surface, &dst_format, 0); dst_format.BitsPerPixel = dstbits; if (!conv) { throw SDLException(std::string("Fatal Error when converting surface to the screen format: ") + SDL_GetError()); } img->setSurface(conv); SDL_FreeSurface(surface); } else { img->setSurface(surface); } } SDL_FreeRW(rwops); } //restore saved x and y shifts img->setXShift(xShiftSave); img->setYShift(yShiftSave); }
boost::intrusive_ptr<Image> loadImage(Stream *stream) { SDL_Surface *surface = IMG_Load_RW(stream->rwops(), 0); if (surface == 0) { throw std::runtime_error(std::string("Failed to load image: ") + SDL_GetError()); } return adoptImage(surface); }
void PictureBank::loadArchive(const std::string &filename) { std::cout << "reading image archive: " << filename << std::endl; struct archive *a; struct archive_entry *entry; int rc; a = archive_read_new(); archive_read_support_compression_all(a); archive_read_support_format_all(a); rc = archive_read_open_filename(a, filename.c_str(), 16384); // block size if (rc != ARCHIVE_OK) { THROW("Cannot open archive " << filename); } SDL_Surface *surface; SDL_RWops *rw; const Uint32 bufferSize = 10000000; // allocated buffer std::auto_ptr< Uint8 > buffer( new Uint8[ bufferSize ] ); if( buffer.get() == 0 ) THROW("Memory error, cannot allocate buffer size " << bufferSize); std::string entryname; while( archive_read_next_header(a, &entry) == ARCHIVE_OK ) { // for all entries in archive entryname = archive_entry_pathname(entry); if ((archive_entry_stat(entry)->st_mode & S_IFREG) == 0) { // not a regular file (maybe a directory). skip it. continue; } if (archive_entry_stat(entry)->st_size >= bufferSize) { THROW("Cannot load archive: file is too big " << entryname << " in archive " << filename); } int size = archive_read_data(a, buffer.get(), bufferSize); // read data into buffer rw = SDL_RWFromMem(buffer.get(), size); surface = IMG_Load_RW(rw, 0); SDL_SetAlpha( surface, 0, 0 ); setPicture(entryname, *surface); SDL_FreeRW(rw); } rc = archive_read_finish(a); if (rc != ARCHIVE_OK) { THROW("Error while reading archive " << filename); } }
std::shared_ptr<SDL_Surface> ImageLoader_SDL_image::load(vfs_FILE *file) const { SDL_Surface *surface = IMG_Load_RW(vfs_openRWops(file, false), 1); if (!surface) { return nullptr; } return std::shared_ptr<SDL_Surface>(surface, [](SDL_Surface *surface) { SDL_FreeSurface(surface); }); }
void TileDescription::load(TileFactory* factory) { if (debug) std::cout << "Loading tiles: " << filename << std::endl; SDL_Surface* 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()); } else { try { int num_tiles = width * height; //(image->w/TILE_RESOLUTION) * (image->h/TILE_RESOLUTION); if (int(colmap.size()) != num_tiles) { std::ostringstream str; str << "'colmap' information and num_tiles mismatch (" << colmap.size() << " != " << num_tiles << ") for image '" << filename << "'"; throw std::runtime_error(str.str()); } if (int(ids.size()) != num_tiles) { std::ostringstream str; str << "'ids' information and num_tiles mismatch (" << ids.size() << " != " << num_tiles << ") for image '" << filename << "'"; throw std::runtime_error(str.str()); } int i = 0; for (int y = 0; y < height*TILE_RESOLUTION; y += TILE_RESOLUTION) { for (int x = 0; x < width*TILE_RESOLUTION; x += TILE_RESOLUTION) { if(ids[i] != -1) { factory->pack(ids[i], colmap[i], image, Rect(x, y, x+TILE_RESOLUTION, y+TILE_RESOLUTION)); } i += 1; } } } catch(...) { SDL_FreeSurface(image); throw; } SDL_FreeSurface(image); } }
GraphicsPrivate(RGSSThreadData *rtData) : scRes(DEF_SCREEN_W, DEF_SCREEN_H), scSize(scRes), winSize(rtData->config.defScreenW, rtData->config.defScreenH), screen(scRes.x, scRes.y), threadData(rtData), glCtx(SDL_GL_GetCurrentContext()), frameRate(DEF_FRAMERATE), frameCount(0), brightness(255), fpsLimiter(frameRate), frozen(false) { recalculateScreenSize(rtData); updateScreenResoRatio(rtData); TEXFBO::init(frozenScene); TEXFBO::allocEmpty(frozenScene, scRes.x, scRes.y); TEXFBO::linkFBO(frozenScene); TEXFBO::init(currentScene); TEXFBO::allocEmpty(currentScene, scRes.x, scRes.y); TEXFBO::linkFBO(currentScene); FloatRect screenRect(0, 0, scRes.x, scRes.y); screenQuad.setTexPosRect(screenRect, screenRect); TEXFBO::init(transBuffer); TEXFBO::allocEmpty(transBuffer, scRes.x, scRes.y); TEXFBO::linkFBO(transBuffer); fpsLimiter.resetFrameAdjust(); const std::string &olImage = rtData->config.touchOverlay.image; if (!olImage.empty()) { SDL_RWops *ops = SDL_RWFromFile(olImage.c_str(), "rb"); SDL_Surface *surf = IMG_Load_RW(ops, 1); if (surf) { overlayTex = TEX::gen(); TEX::bind(overlayTex); TEX::setRepeat(false); TEX::setSmooth(true); TEX::uploadImage(surf->w, surf->h, surf->pixels, GL_RGBA); overlayTexSize = Vec2i(surf->w, surf->h); } else { Debug() << "failed to load overlay image:" << SDL_GetError(); } } }
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); } } }
surface get_no_cache(data_blob_ptr blob) { ASSERT_LOG(blob != NULL, "Invalid data_blob in surface::get_no_cache"); surface surf = surface(IMG_Load_RW(blob->get_rw_ops(), 0)); if(surf.get() == false || surf->w == 0) { std::cerr << "failed to load image '" << (*blob)() << "'\n"; throw load_image_error(); } return surf; }
static void LoadArchivePics( PicManager *pm, const char *archive, const char *dirname) { char *buf = NULL; char path[CDOGS_PATH_MAX]; sprintf(path, "%s/%s", archive, dirname); tinydir_dir dir; if (tinydir_open(&dir, path) != 0) { LOG(LM_MAP, LL_DEBUG, "no pic dir(%s): %s", path, strerror(errno)); goto bail; } while (dir.has_next) { tinydir_file file; if (tinydir_readfile(&dir, &file) != 0) { LOG(LM_MAP, LL_WARN, "cannot read file: %s", strerror(errno)); break; } if (!file.is_reg) goto nextFile; long len; buf = ReadFileIntoBuf(file.path, "rb", &len); if (buf == NULL) goto nextFile; SDL_RWops *rwops = SDL_RWFromMem(buf, len); bool isPng = IMG_isPNG(rwops); if (isPng) { SDL_Surface *data = IMG_Load_RW(rwops, 0); if (data != NULL) { char nameBuf[CDOGS_FILENAME_MAX]; PathGetBasenameWithoutExtension(nameBuf, file.path); PicManagerAdd(&pm->customPics, &pm->customSprites, nameBuf, data); } } rwops->close(rwops); nextFile: CFREE(buf); buf = NULL; if (tinydir_next(&dir) != 0) { printf( "Could not go to next file in dir %s: %s\n", path, strerror(errno)); goto bail; } } bail: CFREE(buf); tinydir_close(&dir); }