mpo/VVVVVV
1
0
Fork 0
mirror of https://github.com/TerryCavanagh/VVVVVV.git synced 2024-06-25 22:18:30 +02:00
Code Issues Releases Wiki Activity
19b2a317f1
VVVVVV/desktop_version/src/GraphicsResources.cpp

333 lines
9.0 KiB
C++
Raw Normal View History

Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "GraphicsResources.h"
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
#include "Alloc.h"
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
#include "FileSystemUtils.h"
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
#include "GraphicsUtil.h"
Replace all print calls with vlog calls This is pretty straight-forward to do.
2021-02-24 00:21:29 +01:00
#include "Vlogging.h"
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
#include "Screen.h"
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
// Used to load PNG data
extern "C"
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
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
);
`LoadImage`: Check LodePNG return value and print errors Dvoid from Discord just reported a crash when trying to load a custom tiles2.png that was encoded weirdly. The problem is that we don't check the return value from LodePNG, so LodePNG gives us a null pointer, and then SDL_CreateRGBSurfaceWithFormatFrom doesn't check this null pointer, which then propagates until we crash in SDL_ConvertSurfaceFormat (or rather, one of its sub-functions), and we would probably crash somewhere else anyway if it continued. After properly checking LodePNG's return value, along with printing the error, it turns out that Dvoid's custom tiles2.png had an "invalid CRC". I don't know what this means but it sounds worrying. `feh` can read the file correctly but it also reports a "CRC error".
2021-11-14 23:02:51 +01:00
extern const char* lodepng_error_text(unsigned code);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
static SDL_Surface* LoadImageRaw(const char* filename, unsigned char** data)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//Temporary storage for the image that's loaded
SDL_Surface* loadedImage = NULL;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
unsigned int width, height;
`LoadImage`: Check LodePNG return value and print errors Dvoid from Discord just reported a crash when trying to load a custom tiles2.png that was encoded weirdly. The problem is that we don't check the return value from LodePNG, so LodePNG gives us a null pointer, and then SDL_CreateRGBSurfaceWithFormatFrom doesn't check this null pointer, which then propagates until we crash in SDL_ConvertSurfaceFormat (or rather, one of its sub-functions), and we would probably crash somewhere else anyway if it continued. After properly checking LodePNG's return value, along with printing the error, it turns out that Dvoid's custom tiles2.png had an "invalid CRC". I don't know what this means but it sounds worrying. `feh` can read the file correctly but it also reports a "CRC error".
2021-11-14 23:02:51 +01:00
unsigned int error;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
unsigned char* fileIn;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
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;
}
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
error = lodepng_decode32(data, &width, &height, fileIn, length);
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(fileIn);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
`LoadImage`: Check LodePNG return value and print errors Dvoid from Discord just reported a crash when trying to load a custom tiles2.png that was encoded weirdly. The problem is that we don't check the return value from LodePNG, so LodePNG gives us a null pointer, and then SDL_CreateRGBSurfaceWithFormatFrom doesn't check this null pointer, which then propagates until we crash in SDL_ConvertSurfaceFormat (or rather, one of its sub-functions), and we would probably crash somewhere else anyway if it continued. After properly checking LodePNG's return value, along with printing the error, it turns out that Dvoid's custom tiles2.png had an "invalid CRC". I don't know what this means but it sounds worrying. `feh` can read the file correctly but it also reports a "CRC error".
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;
}
Fix surface color masks This fixes the color ordering of every SDL_Surface in the game. Basically, images need to be loaded in ABGR format (except if they don't have alpha, then you use RGB? I'm not sure what's going on here), and then they will be converted to RGB/RGBA afterwards. Due to the surfaces actually being BGR/BGRA, the game used to use getRGBA/getRGB to swap the colors back around to BGRA/BGR, but I've fixed those too.
2021-02-19 07:20:11 +01:00
loadedImage = SDL_CreateRGBSurfaceWithFormatFrom(
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
*data,
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
width,
height,
Remove `noAlpha` argument from `LoadImage` This is just to simplify the function. I really don't see any point in taking away the alpha for some images, other than to disappoint people who mod the game assets. It just complicates loading the image with no real gain. To reduce maintenance costs, let's remove this alternate code path. Also it's a default argument and I don't like default arguments.
2021-12-25 09:57:58 +01:00
32,
width * 4,
SDL_PIXELFORMAT_ABGR8888
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
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);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (loadedImage != NULL)
{
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_freefunc(SDL_FreeSurface, loadedImage);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
VVV_free(data);
if (optimizedImage == NULL)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(data);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
vlog_error("Image not found: %s", filename);
SDL_assert(0 && "Image not found! See stderr.");
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
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)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
return NULL;
}
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
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);
Hello WWWWWWorld!
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)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
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;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix some leaks
2020-06-07 22:29:48 +02:00
void GraphicsResources::destroy(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
#define CLEAR(img) VVV_freefunc(SDL_DestroyTexture, img)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
CLEAR(im_tiles);
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
CLEAR(im_tiles_white);
CLEAR(im_tiles_tint);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
CLEAR(im_tiles2);
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
CLEAR(im_tiles2_tint);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
CLEAR(im_tiles3);
CLEAR(im_entcolours);
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
CLEAR(im_entcolours_tint);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
CLEAR(im_sprites);
CLEAR(im_flipsprites);
CLEAR(im_bfont);
CLEAR(im_teleporter);
Ensure that all member attributes are initialized I ran the game through cppcheck and it spat out a bunch of member attributes that weren't being initialized. So I initialized them. In the previous version of this commit, I added constructors to GraphicsResources, otherlevelclass, labclass, warpclass, and finalclass, but flibit says this changes the code flow enough that it's risky to merge before 2.4, so I got rid of those constructors, too.
2020-07-06 22:04:34 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
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);
Ensure that all member attributes are initialized I ran the game through cppcheck and it spat out a bunch of member attributes that weren't being initialized. So I initialized them. In the previous version of this commit, I added constructors to GraphicsResources, otherlevelclass, labclass, warpclass, and finalclass, but flibit says this changes the code flow enough that it's risky to merge before 2.4, so I got rid of those constructors, too.
2020-07-06 22:04:34 +02:00
#undef CLEAR
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
VVV_freefunc(SDL_FreeSurface, im_sprites_surf);
VVV_freefunc(SDL_FreeSurface, im_flipsprites_surf);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Reference in New Issue Copy Permalink