mpo/VVVVVV
1
0
Fork 0
mirror of https://github.com/TerryCavanagh/VVVVVV.git synced 2024-12-23 10:09:43 +01:00
Code Issues Releases Wiki Activity
VVVVVV/desktop_version/src/preloader.cpp

145 lines
3.8 KiB
C++
Raw Normal View History

preloader.cpp: make loading screen translatable This mainly adds loc::gettext calls and replaces SDL_snprintf by VFormat for the percentage. This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-31 02:12:57 +01:00
#include "Constants.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "Enums.h"
Migrate more prints and graphics.len calls to font:: I especially focused on graphics.len and the print calls around them, because graphics.len calls appear a bit less often, might be overlooked when migrating print calls (thus possibly using different fonts by accident) and are often used for some kind of right-alignment or centering which can be changed into PR_RIGHT or PR_CEN with a different X anyway. Notably, I also added a new function to generate these kinds of sliders: ....[]............ Different languages means that the slider for analogue stick sensitivity needs to be longer to fit possibly long words for Low/Medium/High, and then different font sizes means that the longer slider won't fit onscreen in a language that needs a 12-wide font. So slider_get() can take a "target width", which dynamically changes the number of characters depending on the width of them in the interface font. I kinda forgot that I could force the 8x8 font instead of adapting the characters in the slider to the font, and other ideas (like using different characters or a more graphical progress bar) have been brought up on Discord, so this might all change again sooner or later.
2023-01-16 21:29:50 +01:00
#include "Font.h"
Remove unnecessary includes from header files Including a header file inside another header file means a bunch of files are going to be unnecessarily recompiled whenever that inner header file is changed. So I minimized the amount of header files included in a header file, and only included the ones that were necessary (system includes don't count, I'm only talking about includes from within this project). Then the includes are only in the .cpp files themselves. This also minimizes problems such as a NO_CUSTOM_LEVELS build failing because some file depended on an include that got included in editor.h, which is another benefit of removing unnecessary includes from header files.
2020-07-19 21:05:41 +02:00
#include "Game.h"
#include "Graphics.h"
Use SDL_Color for colors instead of colourTransform colourTransform is a struct with only one member, a Uint32. The issue with `Uint32`s is that it requires a bunch of bit shifting logic to edit the colors. The issue with bit shifting logic is that people have a tendency to hardcode the shift amounts instead of using the shift amount variables of the SDL_PixelFormat, which makes it annoying to change the color masks of surfaces. This commit fixes both issues by unhardcoding the bit shift amounts in DrawPixel and ReadPixel, and by axing the `Uint32`s in favor of using SDL_Color. According to the SDL_PixelFormat documentation ( https://wiki.libsdl.org/SDL2/SDL_PixelFormat ), the logic to read and draw to pixels from colors below 32-bit was just wrong. Specifically, for 8-bit, there's a color palette used instead of some intrinsic color information stored in the pixel itself. But we shouldn't need that logic anyways because we don't use colors below 32-bit. So I axed that too.
2023-01-02 01:36:43 +01:00
#include "GraphicsUtil.h"
Allow pressing ACTION to skip fake loading screen While there already exists an option to skip the fake loading screen entirely (without requiring an ACTION press), there are several reasons for including this option as well: * So people upgrading from 2.2 won't have to sit through the fake loading screen the first time they open 2.3. * So if people are too lazy to use the existing option, they can use this one instead. * So tool-assisted speedruns (TASes) of this game can skip the fake loading screen without requiring an existing settings.vvv beforehand. This last one is the biggest reason for me, since I'm not sure what TASVideos.org rules are regarding existing save files, but with this change nobody has to worry about their rules and can safely just press ACTION to skip the fake loading screen automatically.
2020-12-21 00:19:22 +01:00
#include "KeyPoll.h"
Fix alphabetical ordering of includes in `preloader.cpp` Dav999 added `#include "Localization.h"` before `#include "KeyPoll.h"`, when it should go after instead, because the letter L comes after the letter K in the English alphabet.
2023-01-29 08:29:04 +01:00
#include "Localization.h"
Use `SDL_Point` instead of rolling our own `point` struct The `point` struct was a relic of ActionScript and was added because of the Flash 'point' object. However, it seems like Simon Roth didn't realize that SDL has its own point struct. With this, `Maths.h` can be un-included from a couple headers, which exposes the fact that `preloader.cpp` was relying on `Maths.h` being transitively included from `Graphics.h`.
2023-01-29 08:32:14 +01:00
#include "Maths.h"
Remove unnecessary includes from header files Including a header file inside another header file means a bunch of files are going to be unnecessarily recompiled whenever that inner header file is changed. So I minimized the amount of header files included in a header file, and only included the ones that were necessary (system includes don't count, I'm only talking about includes from within this project). Then the includes are only in the .cpp files themselves. This also minimizes problems such as a NO_CUSTOM_LEVELS build failing because some file depended on an include that got included in editor.h, which is another benefit of removing unnecessary includes from header files.
2020-07-19 21:05:41 +02:00
#include "UtilityClass.h"
preloader.cpp: make loading screen translatable This mainly adds loc::gettext calls and replaces SDL_snprintf by VFormat for the percentage. This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-31 02:12:57 +01:00
#include "VFormat.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Clean up unnecessary exports and add static keywords This patch cleans up unnecessary exports from header files (there were only a few), as well as adds the static keyword to all symbols that aren't exported and are specific to a file. This helps the linker out in not doing any unnecessary work, speeding it up and avoiding silent symbol conflicts (otherwise two symbols with the same name (and type/signature in C++) would quietly resolve as okay by the linker).
2021-01-10 18:14:37 +01:00
static int pre_fakepercent=0, pre_transition=30;
static bool pre_startgame=false;
Use SDL_Color for colors instead of colourTransform colourTransform is a struct with only one member, a Uint32. The issue with `Uint32`s is that it requires a bunch of bit shifting logic to edit the colors. The issue with bit shifting logic is that people have a tendency to hardcode the shift amounts instead of using the shift amount variables of the SDL_PixelFormat, which makes it annoying to change the color masks of surfaces. This commit fixes both issues by unhardcoding the bit shift amounts in DrawPixel and ReadPixel, and by axing the `Uint32`s in favor of using SDL_Color. According to the SDL_PixelFormat documentation ( https://wiki.libsdl.org/SDL2/SDL_PixelFormat ), the logic to read and draw to pixels from colors below 32-bit was just wrong. Specifically, for 8-bit, there's a color palette used instead of some intrinsic color information stored in the pixel itself. But we shouldn't need that logic anyways because we don't use colors below 32-bit. So I axed that too.
2023-01-02 01:36:43 +01:00
static SDL_Color pre_darkcol = {0, 0, 0, 0};
static SDL_Color pre_lightcol = {0, 0, 0, 0};
static int pre_curcol = 0, pre_coltimer = 0, pre_offset = 0;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Clean up unnecessary exports and add static keywords This patch cleans up unnecessary exports from header files (there were only a few), as well as adds the static keyword to all symbols that aren't exported and are specific to a file. This helps the linker out in not doing any unnecessary work, speeding it up and avoiding silent symbol conflicts (otherwise two symbols with the same name (and type/signature in C++) would quietly resolve as okay by the linker).
2021-01-10 18:14:37 +01:00
static int pre_frontrectx=30, pre_frontrecty=20, pre_frontrectw=260, pre_frontrecth=200;
static int pre_temprectx=0, pre_temprecty=0, pre_temprectw=320, pre_temprecth=240;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void preloaderinput(void)
Allow pressing ACTION to skip fake loading screen While there already exists an option to skip the fake loading screen entirely (without requiring an ACTION press), there are several reasons for including this option as well: * So people upgrading from 2.2 won't have to sit through the fake loading screen the first time they open 2.3. * So if people are too lazy to use the existing option, they can use this one instead. * So tool-assisted speedruns (TASes) of this game can skip the fake loading screen without requiring an existing settings.vvv beforehand. This last one is the biggest reason for me, since I'm not sure what TASVideos.org rules are regarding existing save files, but with this change nobody has to worry about their rules and can safely just press ACTION to skip the fake loading screen automatically.
2020-12-21 00:19:22 +01:00
{
game.press_action = false;
if (key.isDown(KEYBOARD_z) || key.isDown(KEYBOARD_SPACE) || key.isDown(KEYBOARD_v) || key.isDown(game.controllerButton_flip)) {
game.press_action = true;
}
if (game.press_action) {
//Skip to TITLEMODE immediately
game.gamestate = TITLEMODE;
game.jumpheld = true;
}
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void preloaderrenderfixed(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
if (pre_transition < 30) pre_transition--;
if(pre_transition>=30){
pre_fakepercent++;
if (pre_fakepercent >= 100) {
pre_fakepercent = 100;
pre_startgame = true;
}
pre_offset = (pre_offset + 4 + int(fRandom() * 5.0f))%32;
pre_coltimer--;
if (pre_coltimer <= 0) {
pre_curcol = (pre_curcol + int(fRandom() * 5.0f)) % 6;
pre_coltimer = 8;
}
Move preloader update code to new function preloaderlogic() Otherwise the preloader will go by way too quickly.
2020-05-04 19:06:07 +02:00
}
Move all fixed-timestep render updates to new file RenderFixed.cpp As part of fixing #464, I'll need to move these pieces of code around easily. In #220 I just kind of shoved them awkwardly in whatever fixed function would be last called in the gamestate loop, which I shouldn't have done as I've now had to make formal fixed-render functions anyway. Because these fixed functions need to be called directly before a render function, and I'm fixing the order to put render functions in their proper place, so I need to be able to move these around easily, and making them function calls instead of inlined makes them easier to manipulate.
2020-11-08 00:47:49 +01:00
if (pre_transition <= -10) {
game.gamestate = TITLEMODE;
}
Move preloader update code to new function preloaderlogic() Otherwise the preloader will go by way too quickly.
2020-05-04 19:06:07 +02:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void preloaderrender(void)
Move preloader update code to new function preloaderlogic() Otherwise the preloader will go by way too quickly.
2020-05-04 19:06:07 +02:00
{
preloader.cpp: make loading screen translatable This mainly adds loc::gettext calls and replaces SDL_snprintf by VFormat for the percentage. This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-31 02:12:57 +01:00
bool print_percentage = false;
Move preloader update code to new function preloaderlogic() Otherwise the preloader will go by way too quickly.
2020-05-04 19:06:07 +02:00
if(pre_transition>=30){
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
switch(pre_curcol) {
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
case 0:
Axe `RGBflip()` in favor of `getRGB()` RGBflip() does the exact same thing as getRGB(), now that all the surface masks have been fixed. This axes RGBflip() and changes all callers to use getRGB() instead. It is more readable that way. By doing this, there is less copy-pasting. Additionally, it is now easier to search for RGBf() - which is an ENTIRELY different function than RGBflip() - now that the name of RGBf is no longer the first four characters of some different, unrelated function. Previously I would've had to do `rg 'RGBf[^\w]'` which was stupid and awful and I hated it.
2021-09-11 11:15:20 +02:00
pre_lightcol = graphics.getRGB(0xBF,0x59,0x6F);
pre_darkcol = graphics.getRGB(0x88,0x3E,0x53);
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
break;
case 1:
Axe `RGBflip()` in favor of `getRGB()` RGBflip() does the exact same thing as getRGB(), now that all the surface masks have been fixed. This axes RGBflip() and changes all callers to use getRGB() instead. It is more readable that way. By doing this, there is less copy-pasting. Additionally, it is now easier to search for RGBf() - which is an ENTIRELY different function than RGBflip() - now that the name of RGBf is no longer the first four characters of some different, unrelated function. Previously I would've had to do `rg 'RGBf[^\w]'` which was stupid and awful and I hated it.
2021-09-11 11:15:20 +02:00
pre_lightcol = graphics.getRGB(0x6C,0xBC,0x5C);
pre_darkcol = graphics.getRGB(0x50,0x86,0x40);
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
break;
case 2:
Axe `RGBflip()` in favor of `getRGB()` RGBflip() does the exact same thing as getRGB(), now that all the surface masks have been fixed. This axes RGBflip() and changes all callers to use getRGB() instead. It is more readable that way. By doing this, there is less copy-pasting. Additionally, it is now easier to search for RGBf() - which is an ENTIRELY different function than RGBflip() - now that the name of RGBf is no longer the first four characters of some different, unrelated function. Previously I would've had to do `rg 'RGBf[^\w]'` which was stupid and awful and I hated it.
2021-09-11 11:15:20 +02:00
pre_lightcol = graphics.getRGB(0x5D,0x57,0xAA);
pre_darkcol = graphics.getRGB(0x2F,0x2F,0x6C);
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
break;
case 3:
Axe `RGBflip()` in favor of `getRGB()` RGBflip() does the exact same thing as getRGB(), now that all the surface masks have been fixed. This axes RGBflip() and changes all callers to use getRGB() instead. It is more readable that way. By doing this, there is less copy-pasting. Additionally, it is now easier to search for RGBf() - which is an ENTIRELY different function than RGBflip() - now that the name of RGBf is no longer the first four characters of some different, unrelated function. Previously I would've had to do `rg 'RGBf[^\w]'` which was stupid and awful and I hated it.
2021-09-11 11:15:20 +02:00
pre_lightcol = graphics.getRGB(0xB7,0xBA,0x5E);
pre_darkcol = graphics.getRGB(0x84,0x83,0x42);
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
break;
case 4:
Axe `RGBflip()` in favor of `getRGB()` RGBflip() does the exact same thing as getRGB(), now that all the surface masks have been fixed. This axes RGBflip() and changes all callers to use getRGB() instead. It is more readable that way. By doing this, there is less copy-pasting. Additionally, it is now easier to search for RGBf() - which is an ENTIRELY different function than RGBflip() - now that the name of RGBf is no longer the first four characters of some different, unrelated function. Previously I would've had to do `rg 'RGBf[^\w]'` which was stupid and awful and I hated it.
2021-09-11 11:15:20 +02:00
pre_lightcol = graphics.getRGB(0x57,0x90,0xAA);
pre_darkcol = graphics.getRGB(0x2F,0x5B,0x6C);
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
break;
case 5:
Axe `RGBflip()` in favor of `getRGB()` RGBflip() does the exact same thing as getRGB(), now that all the surface masks have been fixed. This axes RGBflip() and changes all callers to use getRGB() instead. It is more readable that way. By doing this, there is less copy-pasting. Additionally, it is now easier to search for RGBf() - which is an ENTIRELY different function than RGBflip() - now that the name of RGBf is no longer the first four characters of some different, unrelated function. Previously I would've had to do `rg 'RGBf[^\w]'` which was stupid and awful and I hated it.
2021-09-11 11:15:20 +02:00
pre_lightcol = graphics.getRGB(0x90,0x61,0xB1);
pre_darkcol = graphics.getRGB(0x58,0x3D,0x71);
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
break;
default:
Axe `RGBflip()` in favor of `getRGB()` RGBflip() does the exact same thing as getRGB(), now that all the surface masks have been fixed. This axes RGBflip() and changes all callers to use getRGB() instead. It is more readable that way. By doing this, there is less copy-pasting. Additionally, it is now easier to search for RGBf() - which is an ENTIRELY different function than RGBflip() - now that the name of RGBf is no longer the first four characters of some different, unrelated function. Previously I would've had to do `rg 'RGBf[^\w]'` which was stupid and awful and I hated it.
2021-09-11 11:15:20 +02:00
pre_lightcol = graphics.getRGB(0x00,0x00,0x00);
pre_darkcol = graphics.getRGB(0x08,0x00,0x00);
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
break;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
for (int i = 0; i < 18; i++) {
pre_temprecty = (i * 16)- pre_offset;
Remove one trailing whitespace in preloader.cpp Only one.
2020-04-02 23:20:52 +02:00
if (i % 2 == 0)
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +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
graphics.fill_rect(pre_temprectx, pre_temprecty, pre_temprectw,pre_temprecth, pre_lightcol);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
else
{
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
graphics.fill_rect(pre_temprectx, pre_temprecty, pre_temprectw,pre_temprecth, pre_darkcol);
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
graphics.fill_rect(pre_frontrectx, pre_frontrecty, pre_frontrectw,pre_frontrecth, graphics.getRGB(0x3E,0x31,0xA2));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
preloader.cpp: make loading screen translatable This mainly adds loc::gettext calls and replaces SDL_snprintf by VFormat for the percentage. This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-31 02:12:57 +01:00
print_percentage = true;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
//Render
if (pre_startgame) {
pre_transition = 29;
}
}else if (pre_transition <= -10) {
Move all fixed-timestep render updates to new file RenderFixed.cpp As part of fixing #464, I'll need to move these pieces of code around easily. In #220 I just kind of shoved them awkwardly in whatever fixed function would be last called in the gamestate loop, which I shouldn't have done as I've now had to make formal fixed-render functions anyway. Because these fixed functions need to be called directly before a render function, and I'm fixing the order to put render functions in their proper place, so I need to be able to move these around easily, and making them function calls instead of inlined makes them easier to manipulate.
2020-11-08 00:47:49 +01:00
//Switch to TITLEMODE (handled by preloaderrenderfixed)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}else if (pre_transition < 5) {
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
graphics.fill_rect(0, 0, 0);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}else if (pre_transition < 20) {
pre_temprecty = 0;
pre_temprecth = 240;
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
graphics.fill_rect(0, 0, 0);
graphics.fill_rect(pre_frontrectx, pre_frontrecty, pre_frontrectw,pre_frontrecth, graphics.getRGB(0x3E,0x31,0xA2));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
preloader.cpp: make loading screen translatable This mainly adds loc::gettext calls and replaces SDL_snprintf by VFormat for the percentage. This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-31 02:12:57 +01:00
print_percentage = true;
}
if (print_percentage) {
char buffer[SCREEN_WIDTH_CHARS + 1];
vformat_buf(
buffer, sizeof(buffer),
loc::gettext("LOADING... {percent|digits=2|spaces}%"),
"percent:int",
pre_fakepercent
);
XFLIP LOADING... screen
2024-01-05 17:21:21 +01:00
font::print(PR_RIGHT | PR_CJK_HIGH | PR_RTL_XFLIP, 282, 204, buffer, 124, 112, 218);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix mixed indentation in preloader.cpp Not that much, but only because it's not a big file to begin with.
2020-04-02 23:22:45 +02:00
graphics.drawfade();
Only render screen effects on the title screen and in-game In-game because that's where screen effects are used the most. But on the title screen, screen effects are used when you press ACTION to start the game, and when you enable screen effects, too. Otherwise, we don't need screen effects for any other game-gamestate.
2020-04-27 04:29:40 +02:00
graphics.render();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Reference in a new issue Copy permalink