2020-01-01 21:29:24 +01:00
|
|
|
#include "GraphicsResources.h"
|
2020-07-19 21:43:29 +02:00
|
|
|
|
|
|
|
#include "FileSystemUtils.h"
|
2021-02-24 00:21:29 +01:00
|
|
|
#include "Vlogging.h"
|
2020-07-19 21:43:29 +02:00
|
|
|
|
2020-01-01 21:29:24 +01:00
|
|
|
// Used to load PNG data
|
|
|
|
extern "C"
|
|
|
|
{
|
2021-09-07 03:56:39 +02:00
|
|
|
extern unsigned lodepng_decode32(
|
|
|
|
unsigned char** out,
|
|
|
|
unsigned* w,
|
|
|
|
unsigned* h,
|
|
|
|
const unsigned char* in,
|
|
|
|
size_t insize
|
|
|
|
);
|
2021-11-14 23:02:51 +01:00
|
|
|
extern const char* lodepng_error_text(unsigned code);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
|
Use `LoadImage` in `LoadIcon`
This de-duplicates the code, simplifying the codebase and reducing the
number of code paths that needs to be maintained. It also adds
robustness checks to LoadIcon that weren't there before (checking that
loading the file succeeded and that decoding the file also succeeded).
Now, you might think that loading the image with alpha will change
things in some way. But actually, I tested it, and I'm pretty sure it
doesn't. Since my window manager, i3, doesn't display icons, I've had to
resort to this hacky multi-liner
( https://unix.stackexchange.com/a/48866 ) to dump the icon to a PAM
file. I don't know what a PAM file is and all my various attempts to
convert it into something readable failed. But what I did instead was
just grab the icon of the game before this commit (on 2.3, just to be
extra sure), and `diff`ed it with the grabbed icon now, and they end up
being the exact same file. So there's literally no difference.
The only other consideration is that LoadImage needs to be exported,
since it's implemented in GraphicsResources.cpp. I just opted to
forward-declare it right before LoadIcon in Screen.cpp, since it's
really the only other time it's used. No need to create a new header
file for it or anything.
2021-12-25 10:27:33 +01:00
|
|
|
/* Don't declare `static`, this is used elsewhere */
|
|
|
|
SDL_Surface* LoadImage(const char *filename)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
2021-09-07 03:56:39 +02:00
|
|
|
//Temporary storage for the image that's loaded
|
|
|
|
SDL_Surface* loadedImage = NULL;
|
|
|
|
//The optimized image that will be used
|
|
|
|
SDL_Surface* optimizedImage = NULL;
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2021-09-07 03:56:39 +02:00
|
|
|
unsigned char *data;
|
|
|
|
unsigned int width, height;
|
2021-11-14 23:02:51 +01:00
|
|
|
unsigned int error;
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2021-09-07 03:56:39 +02:00
|
|
|
unsigned char *fileIn;
|
|
|
|
size_t length;
|
|
|
|
FILESYSTEM_loadAssetToMemory(filename, &fileIn, &length, false);
|
|
|
|
if (fileIn == NULL)
|
|
|
|
{
|
|
|
|
SDL_assert(0 && "Image file missing!");
|
|
|
|
return NULL;
|
|
|
|
}
|
2021-12-25 09:57:58 +01:00
|
|
|
error = lodepng_decode32(&data, &width, &height, fileIn, length);
|
2021-09-07 03:56:39 +02:00
|
|
|
FILESYSTEM_freeMemory(&fileIn);
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2021-11-14 23:02:51 +01:00
|
|
|
if (error != 0)
|
|
|
|
{
|
|
|
|
vlog_error("Could not load %s: %s", filename, lodepng_error_text(error));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-02-19 07:20:11 +01:00
|
|
|
loadedImage = SDL_CreateRGBSurfaceWithFormatFrom(
|
2021-09-07 03:56:39 +02:00
|
|
|
data,
|
|
|
|
width,
|
|
|
|
height,
|
2021-12-25 09:57:58 +01:00
|
|
|
32,
|
|
|
|
width * 4,
|
|
|
|
SDL_PIXELFORMAT_ABGR8888
|
2021-09-07 03:56:39 +02:00
|
|
|
);
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2021-09-07 03:56:39 +02:00
|
|
|
if (loadedImage != NULL)
|
|
|
|
{
|
|
|
|
optimizedImage = SDL_ConvertSurfaceFormat(
|
|
|
|
loadedImage,
|
2021-02-19 07:20:11 +01:00
|
|
|
SDL_PIXELFORMAT_ARGB8888,
|
2021-09-07 03:56:39 +02:00
|
|
|
0
|
|
|
|
);
|
|
|
|
SDL_FreeSurface( loadedImage );
|
|
|
|
SDL_free(data);
|
2021-12-25 09:51:27 +01:00
|
|
|
SDL_SetSurfaceBlendMode(optimizedImage, SDL_BLENDMODE_BLEND);
|
2021-09-07 03:56:39 +02:00
|
|
|
return optimizedImage;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SDL_free(data);
|
|
|
|
vlog_error("Image not found: %s", filename);
|
|
|
|
SDL_assert(0 && "Image not found! See stderr.");
|
|
|
|
return NULL;
|
|
|
|
}
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
|
Allow using help/graphics/music/game/key/map/obj everywhere
This commit makes `help`, `graphics`, `music`, `game`, `key`, `map`, and
`obj` essentially static global objects that can be used everywhere.
This is useful in case we ever need to add a new function in the future,
so we don't have to bother with passing a new argument in which means we
have to pass a new argument in to the function that calls that function
which means having to pass a new argument into the function that calls
THAT function, etc. which is a real headache when working on fan mods of
the source code.
Note that this changes NONE of the existing function signatures, it
merely just makes those variables accessible everywhere in the same way
`script` and `ed` are.
Also note that some classes had to be initialized after the filesystem
was initialized, but C++ would keep initializing them before the
filesystem got initialized, because I *had* to put them at the top of
`main.cpp`, or else they wouldn't be global variables.
The only way to work around this was to use entityclass's initialization
style (which I'm pretty sure entityclass of all things doesn't need to
be initialized this way), where you actually initialize the class in an
`init()` function, and so then you do `graphics.init()` after the
filesystem initialization, AFTER doing `Graphics graphics` up at the
top.
I've had to do this for `graphics` (but only because its child
GraphicsResources `grphx` needs to be initialized this way), `music`,
and `game`. I don't think this will affect anything. Other than that,
`help`, `key`, and `map` are still using the C++-intended method of
having ClassName::ClassName() functions.
2020-01-29 08:35:03 +01:00
|
|
|
void GraphicsResources::init(void)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
2021-09-07 03:56:39 +02:00
|
|
|
im_tiles = LoadImage("graphics/tiles.png");
|
|
|
|
im_tiles2 = LoadImage("graphics/tiles2.png");
|
|
|
|
im_tiles3 = LoadImage("graphics/tiles3.png");
|
|
|
|
im_entcolours = LoadImage("graphics/entcolours.png");
|
|
|
|
im_sprites = LoadImage("graphics/sprites.png");
|
|
|
|
im_flipsprites = LoadImage("graphics/flipsprites.png");
|
|
|
|
im_bfont = LoadImage("graphics/font.png");
|
|
|
|
im_teleporter = LoadImage("graphics/teleporter.png");
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2021-12-25 09:51:27 +01:00
|
|
|
im_image0 = LoadImage("graphics/levelcomplete.png");
|
2021-12-25 09:57:58 +01:00
|
|
|
im_image1 = LoadImage("graphics/minimap.png");
|
|
|
|
im_image2 = LoadImage("graphics/covered.png");
|
2021-09-07 03:56:39 +02:00
|
|
|
im_image3 = LoadImage("graphics/elephant.png");
|
2021-12-25 09:51:27 +01:00
|
|
|
im_image4 = LoadImage("graphics/gamecomplete.png");
|
|
|
|
im_image5 = LoadImage("graphics/fliplevelcomplete.png");
|
|
|
|
im_image6 = LoadImage("graphics/flipgamecomplete.png");
|
|
|
|
im_image7 = LoadImage("graphics/site.png");
|
2021-09-07 03:56:39 +02:00
|
|
|
im_image8 = LoadImage("graphics/site2.png");
|
|
|
|
im_image9 = LoadImage("graphics/site3.png");
|
|
|
|
im_image10 = LoadImage("graphics/ending.png");
|
|
|
|
im_image11 = LoadImage("graphics/site4.png");
|
|
|
|
im_image12 = LoadImage("graphics/minimap.png");
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-07 22:29:48 +02:00
|
|
|
void GraphicsResources::destroy(void)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
2020-07-06 22:04:34 +02:00
|
|
|
#define CLEAR(img) \
|
2021-09-07 03:56:39 +02:00
|
|
|
SDL_FreeSurface(img); \
|
|
|
|
img = NULL;
|
2020-01-30 16:04:03 +01:00
|
|
|
|
2021-09-07 03:56:39 +02:00
|
|
|
CLEAR(im_tiles);
|
|
|
|
CLEAR(im_tiles2);
|
|
|
|
CLEAR(im_tiles3);
|
|
|
|
CLEAR(im_entcolours);
|
|
|
|
CLEAR(im_sprites);
|
|
|
|
CLEAR(im_flipsprites);
|
|
|
|
CLEAR(im_bfont);
|
|
|
|
CLEAR(im_teleporter);
|
2020-07-06 22:04:34 +02:00
|
|
|
|
2021-09-07 03:56:39 +02:00
|
|
|
CLEAR(im_image0);
|
|
|
|
CLEAR(im_image1);
|
|
|
|
CLEAR(im_image2);
|
|
|
|
CLEAR(im_image3);
|
|
|
|
CLEAR(im_image4);
|
|
|
|
CLEAR(im_image5);
|
|
|
|
CLEAR(im_image6);
|
|
|
|
CLEAR(im_image7);
|
|
|
|
CLEAR(im_image8);
|
|
|
|
CLEAR(im_image9);
|
|
|
|
CLEAR(im_image10);
|
|
|
|
CLEAR(im_image11);
|
|
|
|
CLEAR(im_image12);
|
2020-07-06 22:04:34 +02:00
|
|
|
#undef CLEAR
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|