/** \brief Create an SDL_Texture from a PNG file.
* \param path relative path
* \param res_w width of the PNG in pixels
* \param res_h height of the PNG in pixels
*/
SDL_Texture* video_import_png(char* path, int* res_w, int* res_h)
{
SDL_Texture *img_tex = NULL;
if (path == NULL) {
fprintf(stderr, "[~][display] Path not defined\n");
return NULL;
}
//Open in read mode, 'b' indicates it's a binary file
SDL_RWops *rwop = SDL_RWFromFile(path, "rb");
if (rwop == NULL) {
fprintf(stderr, "[~][display] Open file failed: %s\n", SDL_GetError());
return NULL;
}
SDL_Surface *img_surf = IMG_LoadPNG_RW(rwop);
if (img_surf == NULL) {
fprintf(stderr, "[~][display] Load PNG: %s\n", IMG_GetError());
SDL_RWclose(rwop);
return NULL;
}
img_tex = SDL_CreateTextureFromSurface(renderer, img_surf);
if (img_tex == NULL) {
fprintf(stderr, "[~][display] Create Texture failed: %s\n", SDL_GetError());
}
*res_w = img_surf->w;
*res_h = img_surf->h;
SDL_FreeSurface(img_surf);
SDL_RWclose(rwop);
return img_tex;
}
//Graphics
void Operation::avatar_set(ScenarioRunner* sr)
{
std::string avatar = sr->getString();
uint32_t x = sr->getDWORD();
sr->getDWORD(); //Unused variable
uint32_t size;
//Load avatar
char* buffer = sr->getResourceManager()->getFile("graphics",avatar,size);
if (buffer == nullptr)
{
LOG("Missing file '"+avatar+"'");
return;
}
SDL_RWops* rw = SDL_RWFromMem(buffer,size);
if (rw==0) ERROR("SDL_RWFromMem failed: "+std::string(SDL_GetError()));
Layer layer;
layer.surface = IMG_LoadPNG_RW(rw);
SDL_RWclose(rw);
delete[] buffer;
if (layer.surface==0) ERROR("IMG_LoadPNG_RW failed: "+std::string(SDL_GetError()));
//Avatar coordinates
layer.rect.x = 800-(x+layer.surface->w)+20;
layer.rect.y = layer.surface->h/2-25;
layer.rect.w = layer.surface->w;
layer.rect.h = layer.surface->h;
//Set avatar
sr->getWindow()->setLayerDirect(static_cast<uint32_t>(-1),layer);
}
gcn::Image* getThemeImage(enum ThemeImage img) {
SDL_RWops *rwop = SDL_RWFromMem(IMAGE_TABLE[img].data, IMAGE_TABLE[img].size);
SDL_Surface* loadedSurface = IMG_LoadPNG_RW(rwop);
gcn::Image* image = buildThemeGCNImageFrom(loadedSurface);
SDL_FreeSurface(loadedSurface);
SDL_FreeRW(rwop);
return image;
}
static SDL_Surface* loadPNGImage(const char* name) {
SDL_RWops* rwops = SDL_RWFromFile(name, "rb");
if(!rwops) {
LOG("Failed to load %s", name);
return 0;
}
SDL_Surface* surf = IMG_LoadPNG_RW(rwops);
SDL_RWclose(rwops);
//MYASSERT(surf, SDLERR_IMAGE_LOAD_FAILED);
return surf;
}
bool Image::LoadPNG_RW(SDL_RWops *src)
{
SDL_Surface *temp = IMG_LoadPNG_RW(src);
if(temp == NULL)
return false;
else
m_Surface = temp;
return true;
}
void SGL_ConvertPNGToIconArray(const char * imagePath, const char * fileName)
{
SDL_RWops* rwop = SDL_RWFromFile(imagePath, "rb");
if (rwop)
{
SDL_Surface* surf = IMG_LoadPNG_RW(rwop);
SDL_RWclose(rwop);
SDL_RWops *rw = SDL_RWFromFile(fileName, "w");
if (rw)
{
size_t len = surf->h*surf->w*surf->format->BytesPerPixel;
const char start[] = "unsigned char icon[] = { ";
SDL_RWwrite(rw, start, 1, SDL_strlen(start));
size_t i;
for (i = 0; i < len; i++)
{
char buffer[5];
SDL_snprintf(buffer, 5, "%u", *(((unsigned char*)surf->pixels) + i));
//sprintf(buffer, "%u", *(((unsigned char*)surf->pixels) + i));
size_t l;
for (l = 1; l < 4; l++)
{
if (buffer[l] == 0 && i + 1 < len)
{
buffer[l] = ',';
buffer[l + 1] = ' ';
SDL_RWwrite(rw, buffer, 1, l + 2);
break;
}
}
}
char buffer[7];
SDL_snprintf(buffer, 7,"%u", *(((unsigned char*)surf->pixels) + (len - 1)));
size_t l;
for (l = 1; l < 4; l++)
{
if (buffer[l] == 0)
{
buffer[l] = ' ';
buffer[l + 1] = '}';
buffer[l + 2] = ';';
SDL_RWwrite(rw, buffer, 1, l + 3);
break;
}
}
SDL_RWclose(rw);
}
}
}
SplashWindow():
window(nullptr),
surface(nullptr),
startupScreenRequested(false){
spades::MemoryStream stream(reinterpret_cast<const char*>(splashImage), sizeof(splashImage));
bmp.Set(spades::Bitmap::Load(&stream), false);
SDL_InitSubSystem(SDL_INIT_VIDEO|SDL_INIT_TIMER);
window = SDL_CreateWindow("OpenSpades Splash Window", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
bmp->GetWidth(), bmp->GetHeight(), SDL_WINDOW_BORDERLESS);
if(window == nullptr) {
SPLog("Creation of splash window failed.");
return;
}
surface = SDL_GetWindowSurface(window);
if(surface == nullptr) {
SPLog("Creation of splash window surface failed.");
SDL_DestroyWindow(window);
return;
}
#ifdef __APPLE__
#elif __unix
SDL_Surface *icon = nullptr;
SDL_RWops *icon_rw = nullptr;
icon_rw = SDL_RWFromConstMem(Icon, sizeof(Icon));
if (icon_rw != nullptr) {
icon = IMG_LoadPNG_RW(icon_rw);
SDL_FreeRW(icon_rw);
}
if(icon == nullptr) {
std::string msg = SDL_GetError();
SPLog("Failed to load icon: %s", msg.c_str());
} else {
SDL_SetWindowIcon(window, icon);
SDL_FreeSurface(icon);
}
#endif
// put splash image
auto *s = SDL_CreateRGBSurfaceFrom(bmp->GetPixels(), bmp->GetWidth(), bmp->GetHeight(),
32, bmp->GetWidth() * 4,
0xff, 0xff00, 0xff0000, 0);
SDL_BlitSurface(s, nullptr, surface, nullptr);
SDL_FreeSurface(s);
SDL_UpdateWindowSurface(window);
}
Badger::SpriteSheet::SpriteSheet(const char* filename) {
SDL_RWops *rwop;
SDL_Surface *image;
rwop = SDL_RWFromFile(filename, "rb");
image = IMG_LoadPNG_RW(rwop);
if (image == NULL) {
char* error = IMG_GetError();
fprintf(stderr, "IMG_LoadPNG_RW: %s\n", error);
}
// Create GL texture
glGenTextures(1, &_texture);
glBindTexture(GL_TEXTURE_2D, _texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GLint numColors = image->format->BytesPerPixel;
GLenum textureFormat;
if (numColors == 4) {
if (image->format->Rmask == 0x000000ff) {
textureFormat = GL_RGBA;
}
else {
textureFormat = GL_BGRA_EXT;
}
}
else if (numColors == 3) {
if (image->format->Rmask == 0x000000ff) {
textureFormat = GL_RGB;
}
else {
textureFormat = GL_BGR_EXT;
}
}
glTexImage2D(GL_TEXTURE_2D, 0, 4, image->w, image->h, 0,
textureFormat, GL_UNSIGNED_BYTE, image->pixels);
_width = image->w;
_height = image->h;
_loadStatSheet(filename);
SDL_FreeSurface(image);
}
SDL_Surface* Image::load_png(const std::string &path)
{
SDL_Surface* image = nullptr;
SDL_RWops* rwop = nullptr;
if (m_image_opened) {
rwop = SDL_RWFromFile(path.c_str(), "rb");
image = IMG_LoadPNG_RW(rwop);
if (image == nullptr) {
Debug::log_err("Failed to load the image! Due to: ", SDL_GetError());
}
}
return image;
}
/**
* Try to load a sprite image file.
*
* @param fname
* Sprite filename
* @param flag
* Flags
* @param rwop
* Pointer to memory for the image
* @return
* The sprite if success, NULL otherwise
*/
sprite_struct *
sprite_tryload_file (char *fname, uint32_t flag, SDL_RWops *rwop)
{
SDL_Surface *bitmap;
if (fname != NULL) {
bitmap = IMG_Load_wrapper(fname);
if (bitmap == NULL) {
return NULL;
}
} else {
bitmap = IMG_LoadPNG_RW(rwop);
}
sprite_struct *sprite = ecalloc(1, sizeof(*sprite));
if (sprite == NULL) {
return NULL;
}
uint32_t ckflags = SDL_SRCCOLORKEY | SDL_ANYFORMAT | SDL_RLEACCEL;
uint32_t ckey = 0;
if (bitmap->format->palette) {
ckey = bitmap->format->colorkey;
SDL_SetColorKey(bitmap, ckflags, ckey);
} else if (flag & SURFACE_FLAG_COLKEY_16M) {
/* Force a true color png to colorkey. Default ckey is black (0). */
SDL_SetColorKey(bitmap, ckflags, 0);
}
surface_borders_get(bitmap,
&sprite->border_up,
&sprite->border_down,
&sprite->border_left,
&sprite->border_right,
ckey);
sprite->bitmap = bitmap;
if (flag & SURFACE_FLAG_DISPLAYFORMATALPHA) {
sprite->bitmap = SDL_DisplayFormatAlpha(bitmap);
SDL_FreeSurface(bitmap);
} else if (flag & SURFACE_FLAG_DISPLAYFORMAT) {
sprite->bitmap = SDL_DisplayFormat(bitmap);
SDL_FreeSurface(bitmap);
}
return sprite;
}
int GLES2D_CreateParticle()
{
/* Load a particule texture */
particleTex = (GLES2D_Texture *) malloc( sizeof( GLES2D_Texture ) );
SDL_Surface *tmp;
tmpmem = SDL_RWFromMem( particle, PARTICLE_LEN );
tmp = IMG_LoadPNG_RW( tmpmem );
particleTex = GLES2D_CreateTextureFromSurface( tmp, 0 );
SDL_FreeSurface( tmp );
return 1;
}
int main()
{
auto engine = std::make_unique<yae::sdl_engine>();
auto window = engine->create_simple_window();
auto cv = yae::clipping_volume{ -8.0f, 8.0f, -6.0f, 6.0f, 1.0f, -1.0f };
window->close_when_keydown();
auto rwop = SDL_RWFromFile("smiley.png", "rb");
auto hero_image = IMG_LoadPNG_RW(rwop);
auto pixels = (GLubyte*)hero_image->pixels;
auto width = hero_image->w;
auto height = hero_image->h;
auto hero_texture = std::make_shared<yae::texture>(pixels, width, height);
yae::buffer_object_builder<float> b({ -50.0f, -50.0f, 50.0f, -50.0f, 50.0f, 50.0f, -50.0f, 50.0f });
auto multi_hero = std::make_shared<yae::geometry<float>>(b.get_size() / 2, 2, GL_QUADS);
multi_hero->set_vertex_positions(b.build());
multi_hero->set_vertex_tex_coords(b.build());
auto node = std::make_shared<yae::geometry_node<float>>(multi_hero);
auto root = std::make_shared<yae::group>();
root->add(node);
auto prog = yae::texture_program::create();
prog->set_texture(hero_texture);
auto scene = std::make_shared<yae::rendering_scene>();
auto cam = std::make_shared<yae::parallel_camera>(cv);
auto bg_color = yae::color4f{ 0.0f, 0.0f, 0.0f, 0.0f };
auto clear_viewport_cb = yae::clear_viewport_callback(bg_color, scene->get_viewport());
auto cre = std::make_shared<yae::custom_rendering_element>("clear_viewport", clear_viewport_cb);
auto nre = std::make_shared<yae::node_rendering_element>("smiley_canvas", root, prog, cam);
scene->add_element(cre);
scene->add_element(nre);
scene->associate_camera<yae::rendering_scene::fit_all_adapter>(cam, window.get(), yae::viewport_relative{ 0.0f, 0.0f, 1.0f, 1.0f });
window->set_render_callback([&](yae::rendering_context& ctx) {
cam->rotate_z(0.5);
});
window->add_scene(scene);
engine->run(window.get());
return 0;
}
void Map::loadFromFile(const std::string filename){
this->map = new Tmx::Map();
this->map->ParseFile(filename);
if(map->HasError() == true) { throw map->GetErrorText(); }
if(this->renderer == nullptr) { throw new ExNoRenderer(); }
// Load image files
const std::vector<Tmx::Tileset*>& tileSets = map->GetTilesets();
for(int i = 0; i < tileSets.size(); ++i) {
const Tmx::Tileset * tileSet = tileSets[i];
const Tmx::Image * image = tileSet->GetImage();
const std::string source = image->GetSource();
SDL_RWops * rwop = SDL_RWFromFile(source.c_str(),"r");
SDL_Surface * surf = IMG_LoadPNG_RW(rwop);
SDL_Texture * tex = SDL_CreateTextureFromSurface(this->renderer, surf);
this->images.push_back(tex);
}
}
//Graphics
void Operation::image_set(ScenarioRunner* sr)
{
uint32_t id = sr->getDWORD(),size=0;
char* buffer = sr->getResourceManager()->getFile("graphics",sr->getString(),size);
SDL_RWops* rw = SDL_RWFromMem(buffer,size);
if (rw==0) ERROR("SDL_RWFromMem failed: "+string(SDL_GetError()));
Layer layer;
layer.surface = IMG_LoadPNG_RW(rw);
if (layer.surface==0) ERROR("IMG_LoadPNG_RW failed: "+string(SDL_GetError()));
layer.rect.x = sr->getDWORD();
layer.rect.y = sr->getDWORD();
layer.rect.w = layer.surface->w;
layer.rect.h = layer.surface->h;
if (sr->getDWORD()) sr->getWindow()->setLayer(id,layer);
sr->getDWORD();
sr->getDWORD();
}
void Operation::layer_set(ScenarioRunner* sr)
{
uint32_t id = sr->getDWORD(),size;
std::string file = sr->getString();
char* buffer = sr->getResourceManager()->getFile("graphics",file,size);
if (buffer == nullptr)
{
LOG("Missing file '" + file + "'");
for (int i = 0; i < 5; i++) sr->getDWORD();
return;
}
SDL_RWops* rw = SDL_RWFromMem(buffer,size);
if (rw==0) ERROR("SDL_RWFromMem failed: "+std::string(SDL_GetError()));
Layer layer;
layer.surface = IMG_LoadPNG_RW(rw);
SDL_RWclose(rw);
delete[] buffer;
if (layer.surface==0) ERROR("IMG_LoadPNG_RW failed: "+std::string(SDL_GetError()));
//Layer coordinates
layer.rect.x = sr->getDWORD();
layer.rect.y = sr->getDWORD();
layer.rect.w = layer.surface->w;
layer.rect.h = layer.surface->h;
//Layer visibility
layer.visible = (sr->getDWORD() ? true : false);
sr->getWindow()->setLayer(id,layer);
sr->getDWORD(); //Unknown parameter
sr->getDWORD(); //Unknown parameter
}
int main(int argc, char* argv[])
{
SDL_Surface *screen = NULL;
SDL_Surface *image = NULL;
SDL_Surface *rot = NULL;
SDL_RWops *rw = NULL;
const SDL_VideoInfo *videoInfo = NULL;
FILE* file;
FILE* newFile;
double scale;
char buffer[256];
int value;
int prevValue;
/*-----------------------------------------------------------------*/
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
fprintf(stderr, "SDL_Init failed - %s\n", SDL_GetError());
return 1;
}
/*-----------------------------------------------------------------*/
videoInfo = SDL_GetVideoInfo();
if (videoInfo == 0)
{
fprintf(stderr, "SDL_GetVideoInfo failed - %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
/*-----------------------------------------------------------------*/
if((file = popen("adb shell \"screencap -p | busybox uuencode -\" | uudecode","r"))==NULL)
{
fprintf(stderr, "can't open dump.png\n");
return 0;
}
rw = SDL_RWFromFP(file, 0);
close(file);
image = IMG_LoadPNG_RW(rw);
SDL_FreeRW(rw);
//scale = (image->h)/(videoInfo->current_h);
scale = 0.5;
/*-----------------------------------------------------------------*/
screen = SDL_SetVideoMode((image->w)*scale,
(image->h)*scale,
videoInfo->vfmt->BitsPerPixel,
SDL_SWSURFACE|SDL_DOUBLEBUF);
if (!screen)
{
fprintf(stderr, "SetVideoMode failed - %s\n", SDL_GetError());
SDL_FreeSurface(image);
SDL_Quit();
return 1;
}
rot = rotozoomSurface( image, 0, scale, SMOOTHING_ON );
if (!image)
{
fprintf(stderr, "IMG_LoadBMP_RW failed - %s\n", IMG_GetError());
SDL_Quit();
return 1;
}
SDL_BlitSurface(rot, 0, screen, 0);
SDL_Flip(screen);
SDL_FreeSurface(rot);
SDL_FreeSurface(image);
/*-----------------------------------------------------------------*/
while(1){
if((file = popen("adb shell dumpsys window | grep cur= | awk -F cur= '{print $NF}' | awk -F ' ' '{print $1}' | awk -F 'x' '{print $NF}'", "r"))==NULL)
{
fprintf(stderr, "can't get size\n");
return 0;
}
while(fgets(buffer, sizeof(buffer), file) != 0)
{
value = atoi(buffer);
}
pclose(file);
if((file = popen("adb shell \"screencap -p | busybox uuencode -\" | uudecode","r"))==NULL)
{
fprintf(stderr, "can't open dump.png\n");
return 0;
}
rw = SDL_RWFromFP(file, 0);
close(file);
image = IMG_LoadPNG_RW(rw);
SDL_FreeRW(rw);
if (value != image->h) {
if (prevValue != image->h) {
screen = SDL_SetVideoMode((image->h)*scale,
(image->w)*scale,
videoInfo->vfmt->BitsPerPixel,
SDL_SWSURFACE|SDL_DOUBLEBUF);
}
rot = rotozoomSurface( image, 270, scale, SMOOTHING_ON );
}
if (value == image->h) {
if (prevValue != image->h) {
screen = SDL_SetVideoMode((image->w)*scale,
(image->h)*scale,
videoInfo->vfmt->BitsPerPixel,
SDL_SWSURFACE|SDL_DOUBLEBUF);
}
rot = rotozoomSurface( image, 0, scale, SMOOTHING_ON );
}
if (!image)
{
fprintf(stderr, "IMG_LoadBMP_RW failed - %s\n", IMG_GetError());
SDL_Quit();
return 1;
}
SDL_FreeSurface(image);
SDL_BlitSurface(rot, NULL, screen, 0);
SDL_Flip(screen);
SDL_FreeSurface(rot);
prevValue = value;
}
//SDL_Delay(5000);
SDL_Quit();
return 0;
}
int main(int argc, char* argv[])
{
SDL_Surface *screen = NULL;
SDL_Surface *image = NULL;
SDL_Surface *rot = NULL;
const SDL_VideoInfo *videoInfo = NULL;
FILE* file;
double scale;
int value;
int prevValue = 0;
int rc = 0;
void *status[2];
pthread_t thread[2];
pthread_mutex_init(&mutexRW, NULL);
pthread_create(&thread[0], NULL, run_thread, NULL);
/*-----------------------------------------------------------------*/
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
fprintf(stderr, "SDL_Init failed - %s\n", SDL_GetError());
return 1;
}
/*-----------------------------------------------------------------*/
videoInfo = SDL_GetVideoInfo();
if (videoInfo == 0)
{
fprintf(stderr, "SDL_GetVideoInfo failed - %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
/*-----------------------------------------------------------------*/
rc = pthread_join(thread[0], &status[0]);
//image = IMG_LoadPNG_RW(getImage());
image = IMG_LoadPNG_RW(rw);
//scale = (image->h)/(videoInfo->current_h);
scale = 0.5;
/*-----------------------------------------------------------------*/
while(1){
//pthread_mutex_init(&mutexRW, NULL);
pthread_create(&thread[0], NULL, run_thread, NULL);
value = getHeight();
//drawScreen(image, value, prevValue, scale, videoInfo);
if (value != image->h) {
//scale = (image->w)/(videoInfo->current_w);
scale = 0.5;
if (prevValue != image->h) {
screen = SDL_SetVideoMode((image->h)*scale,
(image->w)*scale,
videoInfo->vfmt->BitsPerPixel,
SDL_SWSURFACE|SDL_DOUBLEBUF);
}
rot = rotozoomSurface( image, 90, scale, SMOOTHING_ON );
}
if (value == image->h) {
//scale = (image->h)/(videoInfo->current_h);
scale = 0.5;
if (prevValue != image->h) {
screen = SDL_SetVideoMode((image->w)*scale,
(image->h)*scale,
videoInfo->vfmt->BitsPerPixel,
SDL_SWSURFACE|SDL_DOUBLEBUF);
}
rot = rotozoomSurface( image, 0, scale, SMOOTHING_ON );
}
SDL_FreeSurface(image);
/*if (!image)
{
fprintf(stderr, "IMG_LoadBMP_RW failed - %s\n", IMG_GetError());
SDL_Quit();
//return 1;
}*/
SDL_BlitSurface(rot, NULL, screen, 0);
SDL_Flip(screen);
SDL_FreeSurface(rot);
prevValue = value;
rc = pthread_join(thread[0], &status[0]);
//image = IMG_LoadPNG_RW(getImage());
image = IMG_LoadPNG_RW(rw);
//SDL_FreeSurface(rw);
}
//SDL_Delay(5000);
SDL_Quit();
return 0;
}
int main(int argc, char* argv[])
{
SDL_Surface *screen = NULL;
SDL_Surface *image = NULL;
const SDL_VideoInfo *videoInfo = NULL;
FILE* file;
/*-----------------------------------------------------------------*/
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
fprintf(stderr, "SDL_Init failed - %s\n", SDL_GetError());
return 1;
}
/*-----------------------------------------------------------------*/
videoInfo = SDL_GetVideoInfo();
if (videoInfo == 0)
{
fprintf(stderr, "SDL_GetVideoInfo failed - %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
/*-----------------------------------------------------------------*/
screen = SDL_SetVideoMode(image->w,
image->h,
videoInfo->vfmt->BitsPerPixel,
SDL_SWSURFACE);
if (!screen)
{
fprintf(stderr, "SetVideoMode failed - %s\n", SDL_GetError());
SDL_FreeSurface(image);
SDL_Quit();
return 1;
}
/*-----------------------------------------------------------------*/
while(1) {
if((file = popen("adb shell \"screencap -p | busybox uuencode -\" |uudecode","r"))==NULL)
{
fprintf(stderr, "can't open dump.png\n");
return 0;
}
SDL_RWops *rw = SDL_RWFromFP(file, 0);
image = IMG_LoadPNG_RW(rw);
SDL_FreeRW(rw);
close(file);
if (!image)
{
fprintf(stderr, "IMG_LoadBMP_RW failed - %s\n", IMG_GetError());
SDL_Quit();
return 1;
}
/*-----------------------------------------------------------------*/
SDL_BlitSurface(image, 0, screen, 0);
SDL_Flip(screen);
//SDL_Delay(5000);
SDL_FreeSurface(image);
}
SDL_Quit();
return 0;
}
