2020-01-01 21:29:24 +01:00
|
|
|
#include "GraphicsResources.h"
|
2020-07-19 21:43:29 +02:00
|
|
|
|
2022-12-01 07:30:16 +01:00
|
|
|
#include "Alloc.h"
|
2020-07-19 21:43:29 +02:00
|
|
|
#include "FileSystemUtils.h"
|
2023-01-07 19:28:07 +01:00
|
|
|
#include "GraphicsUtil.h"
|
2021-02-24 00:21:29 +01:00
|
|
|
#include "Vlogging.h"
|
2023-01-07 19:28:07 +01:00
|
|
|
#include "Screen.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
|
|
|
}
|
|
|
|
|
2023-01-07 19:28:07 +01:00
|
|
|
static SDL_Surface* LoadImageRaw(const char* filename, unsigned char** data)
|
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;
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2021-09-07 03:56:39 +02:00
|
|
|
unsigned int width, height;
|
2021-11-14 23:02:51 +01:00
|
|
|
unsigned int error;
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2023-01-07 19:28:07 +01:00
|
|
|
unsigned char* fileIn;
|
2021-09-07 03:56:39 +02:00
|
|
|
size_t length;
|
|
|
|
FILESYSTEM_loadAssetToMemory(filename, &fileIn, &length, false);
|
|
|
|
if (fileIn == NULL)
|
|
|
|
{
|
|
|
|
SDL_assert(0 && "Image file missing!");
|
|
|
|
return NULL;
|
|
|
|
}
|
2023-01-07 19:28:07 +01:00
|
|
|
error = lodepng_decode32(data, &width, &height, fileIn, length);
|
2022-12-01 07:30:16 +01:00
|
|
|
VVV_free(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(
|
2023-01-07 19:28:07 +01:00
|
|
|
*data,
|
2021-09-07 03:56:39 +02:00
|
|
|
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
|
|
|
|
2023-01-07 19:28:07 +01:00
|
|
|
return loadedImage;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDL_Surface* LoadSurfaceFromRaw(SDL_Surface* loadedImage)
|
|
|
|
{
|
|
|
|
SDL_Surface* optimizedImage = SDL_ConvertSurfaceFormat(
|
|
|
|
loadedImage,
|
|
|
|
SDL_PIXELFORMAT_ARGB8888,
|
|
|
|
0
|
|
|
|
);
|
|
|
|
SDL_SetSurfaceBlendMode(optimizedImage, SDL_BLENDMODE_BLEND);
|
|
|
|
return optimizedImage;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Can't be static, used in Screen.h */
|
|
|
|
SDL_Surface* LoadImageSurface(const char* filename)
|
|
|
|
{
|
|
|
|
unsigned char* data;
|
|
|
|
|
|
|
|
SDL_Surface* loadedImage = LoadImageRaw(filename, &data);
|
|
|
|
|
|
|
|
SDL_Surface* optimizedImage = LoadSurfaceFromRaw(loadedImage);
|
2021-09-07 03:56:39 +02:00
|
|
|
if (loadedImage != NULL)
|
|
|
|
{
|
2022-12-01 07:30:16 +01:00
|
|
|
VVV_freefunc(SDL_FreeSurface, loadedImage);
|
2021-09-07 03:56:39 +02:00
|
|
|
}
|
2023-01-07 19:28:07 +01:00
|
|
|
|
|
|
|
VVV_free(data);
|
|
|
|
|
|
|
|
if (optimizedImage == NULL)
|
2021-09-07 03:56:39 +02:00
|
|
|
{
|
2022-12-01 07:30:16 +01:00
|
|
|
VVV_free(data);
|
2021-09-07 03:56:39 +02:00
|
|
|
vlog_error("Image not found: %s", filename);
|
|
|
|
SDL_assert(0 && "Image not found! See stderr.");
|
2023-01-07 19:28:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return optimizedImage;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDL_Texture* LoadTextureFromRaw(const char* filename, SDL_Surface* loadedImage, const TextureLoadType loadtype)
|
|
|
|
{
|
|
|
|
if (loadedImage == NULL)
|
|
|
|
{
|
2021-09-07 03:56:39 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2023-01-07 19:28:07 +01:00
|
|
|
|
|
|
|
// Modify the surface with the load type.
|
|
|
|
// This could be done in LoadImageRaw, however currently, surfaces are only used for
|
|
|
|
// pixel perfect collision (which will be changed later) and the window icon.
|
|
|
|
|
|
|
|
switch (loadtype)
|
|
|
|
{
|
|
|
|
case TEX_WHITE:
|
|
|
|
SDL_LockSurface(loadedImage);
|
|
|
|
for (int y = 0; y < loadedImage->h; y++)
|
|
|
|
{
|
|
|
|
for (int x = 0; x < loadedImage->w; x++)
|
|
|
|
{
|
|
|
|
SDL_Color color = ReadPixel(loadedImage, x, y);
|
|
|
|
color.r = 255;
|
|
|
|
color.g = 255;
|
|
|
|
color.b = 255;
|
|
|
|
DrawPixel(loadedImage, x, y, color);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SDL_UnlockSurface(loadedImage);
|
|
|
|
break;
|
|
|
|
case TEX_GRAYSCALE:
|
|
|
|
SDL_LockSurface(loadedImage);
|
|
|
|
for (int y = 0; y < loadedImage->h; y++)
|
|
|
|
{
|
|
|
|
for (int x = 0; x < loadedImage->w; x++)
|
|
|
|
{
|
|
|
|
SDL_Color color = ReadPixel(loadedImage, x, y);
|
|
|
|
|
|
|
|
// Magic numbers used for grayscaling (eyes perceive certain colors brighter than others)
|
|
|
|
Uint8 r = color.r * 0.299;
|
|
|
|
Uint8 g = color.g * 0.587;
|
|
|
|
Uint8 b = color.b * 0.114;
|
|
|
|
|
|
|
|
const double gray = SDL_floor(r + g + b + 0.5);
|
|
|
|
|
|
|
|
color.r = gray;
|
|
|
|
color.g = gray;
|
|
|
|
color.b = gray;
|
|
|
|
|
|
|
|
DrawPixel(loadedImage, x, y, color);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SDL_UnlockSurface(loadedImage);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Create texture from surface pixels
|
|
|
|
SDL_Texture* texture = SDL_CreateTextureFromSurface(gameScreen.m_renderer, loadedImage);
|
|
|
|
if (texture == NULL)
|
|
|
|
{
|
|
|
|
vlog_error("Failed creating texture: %s. SDL error: %s\n", filename, SDL_GetError());
|
|
|
|
}
|
|
|
|
|
|
|
|
return texture;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDL_Texture* LoadImage(const char *filename, const TextureLoadType loadtype)
|
|
|
|
{
|
|
|
|
unsigned char* data;
|
|
|
|
|
|
|
|
SDL_Surface* loadedImage = LoadImageRaw(filename, &data);
|
|
|
|
|
|
|
|
SDL_Texture* texture = LoadTextureFromRaw(filename, loadedImage, loadtype);
|
|
|
|
|
|
|
|
if (loadedImage != NULL)
|
|
|
|
{
|
|
|
|
VVV_freefunc(SDL_FreeSurface, loadedImage);
|
|
|
|
}
|
|
|
|
|
|
|
|
VVV_free(data);
|
|
|
|
|
|
|
|
if (texture == NULL)
|
|
|
|
{
|
|
|
|
vlog_error("Image not found: %s", filename);
|
|
|
|
SDL_assert(0 && "Image not found! See stderr.");
|
|
|
|
}
|
|
|
|
|
|
|
|
return texture;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDL_Texture* LoadImage(const char* filename)
|
|
|
|
{
|
|
|
|
return LoadImage(filename, TEX_COLOR);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Any unneeded variants can be NULL */
|
|
|
|
static void LoadVariants(const char* filename, SDL_Texture** colored, SDL_Texture** white, SDL_Texture** grayscale)
|
|
|
|
{
|
|
|
|
unsigned char* data;
|
|
|
|
SDL_Surface* loadedImage = LoadImageRaw(filename, &data);
|
|
|
|
|
|
|
|
if (colored != NULL)
|
|
|
|
{
|
|
|
|
*colored = LoadTextureFromRaw(filename, loadedImage, TEX_COLOR);
|
|
|
|
if (*colored == NULL)
|
|
|
|
{
|
|
|
|
vlog_error("Image not found: %s", filename);
|
|
|
|
SDL_assert(0 && "Image not found! See stderr.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (grayscale != NULL)
|
|
|
|
{
|
|
|
|
*grayscale = LoadTextureFromRaw(filename, loadedImage, TEX_GRAYSCALE);
|
|
|
|
if (*grayscale == NULL)
|
|
|
|
{
|
|
|
|
vlog_error("Image not found: %s", filename);
|
|
|
|
SDL_assert(0 && "Image not found! See stderr.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (white != NULL)
|
|
|
|
{
|
|
|
|
*white = LoadTextureFromRaw(filename, loadedImage, TEX_WHITE);
|
|
|
|
if (*white == NULL)
|
|
|
|
{
|
|
|
|
vlog_error("Image not found: %s", filename);
|
|
|
|
SDL_assert(0 && "Image not found! See stderr.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (loadedImage != NULL)
|
|
|
|
{
|
|
|
|
VVV_freefunc(SDL_FreeSurface, loadedImage);
|
|
|
|
}
|
|
|
|
|
|
|
|
VVV_free(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The pointers `texture` and `surface` cannot be NULL */
|
|
|
|
static void LoadSprites(const char* filename, SDL_Texture** texture, SDL_Surface** surface)
|
|
|
|
{
|
|
|
|
unsigned char* data;
|
|
|
|
SDL_Surface* loadedImage = LoadImageRaw(filename, &data);
|
|
|
|
|
|
|
|
*texture = LoadTextureFromRaw(filename, loadedImage, TEX_WHITE);
|
|
|
|
if (*texture == NULL)
|
|
|
|
{
|
|
|
|
vlog_error("Image not found: %s", filename);
|
|
|
|
SDL_assert(0 && "Image not found! See stderr.");
|
|
|
|
}
|
|
|
|
|
|
|
|
*surface = LoadSurfaceFromRaw(loadedImage);
|
|
|
|
if (*surface == NULL)
|
|
|
|
{
|
|
|
|
vlog_error("Image not found: %s", filename);
|
|
|
|
SDL_assert(0 && "Image not found! See stderr.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (loadedImage != NULL)
|
|
|
|
{
|
|
|
|
VVV_freefunc(SDL_FreeSurface, loadedImage);
|
|
|
|
}
|
|
|
|
|
|
|
|
VVV_free(data);
|
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
|
|
|
{
|
2023-01-07 19:28:07 +01:00
|
|
|
LoadVariants("graphics/tiles.png", &im_tiles, &im_tiles_white, &im_tiles_tint);
|
|
|
|
LoadVariants("graphics/tiles2.png", &im_tiles2, NULL, &im_tiles2_tint);
|
|
|
|
LoadVariants("graphics/entcolours.png", &im_entcolours, NULL, &im_entcolours_tint);
|
|
|
|
|
|
|
|
LoadSprites("graphics/sprites.png", &im_sprites, &im_sprites_surf);
|
|
|
|
LoadSprites("graphics/flipsprites.png", &im_flipsprites, &im_flipsprites_surf);
|
|
|
|
|
|
|
|
im_tiles3 = LoadImage("graphics/tiles3.png");
|
|
|
|
im_bfont = LoadImage("graphics/font.png", TEX_WHITE);
|
|
|
|
im_teleporter = LoadImage("graphics/teleporter.png", TEX_WHITE);
|
|
|
|
|
|
|
|
im_image0 = LoadImage("graphics/levelcomplete.png");
|
|
|
|
im_image1 = LoadImage("graphics/minimap.png");
|
|
|
|
im_image2 = LoadImage("graphics/covered.png");
|
|
|
|
im_image3 = LoadImage("graphics/elephant.png", TEX_WHITE);
|
|
|
|
im_image4 = LoadImage("graphics/gamecomplete.png");
|
|
|
|
im_image5 = LoadImage("graphics/fliplevelcomplete.png");
|
|
|
|
im_image6 = LoadImage("graphics/flipgamecomplete.png");
|
|
|
|
im_image7 = LoadImage("graphics/site.png", TEX_WHITE);
|
|
|
|
im_image8 = LoadImage("graphics/site2.png", TEX_WHITE);
|
|
|
|
im_image9 = LoadImage("graphics/site3.png", TEX_WHITE);
|
|
|
|
im_image10 = LoadImage("graphics/ending.png");
|
|
|
|
im_image11 = LoadImage("graphics/site4.png", TEX_WHITE);
|
|
|
|
|
|
|
|
im_image12 = SDL_CreateTexture(gameScreen.m_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, 240, 180);
|
|
|
|
|
|
|
|
if (im_image12 == NULL)
|
|
|
|
{
|
|
|
|
vlog_error("Failed to create minimap texture: %s", SDL_GetError());
|
|
|
|
SDL_assert(0 && "Failed to create minimap texture! See stderr.");
|
|
|
|
return;
|
|
|
|
}
|
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
|
|
|
{
|
2023-01-07 19:28:07 +01:00
|
|
|
#define CLEAR(img) VVV_freefunc(SDL_DestroyTexture, img)
|
2021-09-07 03:56:39 +02:00
|
|
|
CLEAR(im_tiles);
|
2023-01-07 19:28:07 +01:00
|
|
|
CLEAR(im_tiles_white);
|
|
|
|
CLEAR(im_tiles_tint);
|
2021-09-07 03:56:39 +02:00
|
|
|
CLEAR(im_tiles2);
|
2023-01-07 19:28:07 +01:00
|
|
|
CLEAR(im_tiles2_tint);
|
2021-09-07 03:56:39 +02:00
|
|
|
CLEAR(im_tiles3);
|
|
|
|
CLEAR(im_entcolours);
|
2023-01-07 19:28:07 +01:00
|
|
|
CLEAR(im_entcolours_tint);
|
2021-09-07 03:56:39 +02:00
|
|
|
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
|
2023-01-07 19:28:07 +01:00
|
|
|
|
|
|
|
VVV_freefunc(SDL_FreeSurface, im_sprites_surf);
|
|
|
|
VVV_freefunc(SDL_FreeSurface, im_flipsprites_surf);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|