qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-27 06:34:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/include/vid_vulkan.h

92 lines
2.7 KiB
C
Raw Normal View History

Separate render and presentation initialization This paves the way for clean initialization of the Vulkan renderer, and very much cleans up the older renderer initialization code as gl and sw are no longer intertwined.
2019-07-08 16:00:47 +00:00
#ifndef __vid_vulkan_h
#define __vid_vulkan_h
#ifndef VK_NO_PROTOTYPES
#define VK_NO_PROTOTYPES
#endif
#include <vulkan/vulkan.h>
Create and destroy render pass and frame buffers
2020-02-18 08:18:37 +00:00
#include "QF/darray.h"
[vulkan] Fix some forward declarations and namespace issues
2023-01-30 04:19:53 +00:00
#include "QF/qtypes.h"
[vulkan] Move projection matrix code to its own file And move more stuff over to simd.
2021-04-25 06:47:50 +00:00
#include "QF/simd/types.h"
Create command pool and frame timing fences Nothing is actually done yet, so the reported fps is around 172k (yes, k), but startup and shutdown seems to be clean (yay validation layers).
2020-02-16 13:45:27 +00:00
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
typedef struct qfv_renderpassset_s
[vulkan] Switch around renderpass and subpass names The old structs will go away eventually, and I'm tired of seeing that _ tail.
2023-06-15 04:13:52 +00:00
DARRAY_TYPE (struct qfv_orenderpass_s *) qfv_renderpassset_t;
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
Separate render and presentation initialization This paves the way for clean initialization of the Vulkan renderer, and very much cleans up the older renderer initialization code as gl and sw are no longer intertwined.
2019-07-08 16:00:47 +00:00
typedef struct vulkan_ctx_s {
void (*load_vulkan) (struct vulkan_ctx_s *ctx);
void (*unload_vulkan) (struct vulkan_ctx_s *ctx);
Remove global vulkan_ctx While I can't say that I'm happy with the details of vulkan_ctx_t, I am pretty sure I don't want to be limited to having only one.
2019-07-09 02:54:23 +00:00
const char **required_extensions;
Separate render and presentation initialization This paves the way for clean initialization of the Vulkan renderer, and very much cleans up the older renderer initialization code as gl and sw are no longer intertwined.
2019-07-08 16:00:47 +00:00
struct vulkan_presentation_s *presentation;
int (*get_presentation_support) (struct vulkan_ctx_s *ctx,
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex);
Create a window and a surface for vulkan Yay, segfaults in R_Init :)
2019-07-09 07:33:44 +00:00
void (*choose_visual) (struct vulkan_ctx_s *ctx);
void (*create_window) (struct vulkan_ctx_s *ctx);
Separate render and presentation initialization This paves the way for clean initialization of the Vulkan renderer, and very much cleans up the older renderer initialization code as gl and sw are no longer intertwined.
2019-07-08 16:00:47 +00:00
VkSurfaceKHR (*create_surface) (struct vulkan_ctx_s *ctx);
Remove global vulkan_ctx While I can't say that I'm happy with the details of vulkan_ctx_t, I am pretty sure I don't want to be limited to having only one.
2019-07-09 02:54:23 +00:00
[util] Make va thread-safe It now takes a context pointer (opaque data) that holds the buffers it uses for the temporary strings. If the context pointer is null, a static context is used (making those uses of va NOT thread-safe). Most calls to va use the static context, but all such calls have been formatted consistently so they are easy to find when it comes time to do a full audit.
2021-01-31 07:01:20 +00:00
struct va_ctx_s *va_ctx;
Completely rework the vulkan related api Things don't work yet, but this feels much cleaner.
2019-07-12 04:15:25 +00:00
struct qfv_instance_s *instance;
struct qfv_device_s *device;
struct qfv_swapchain_s *swapchain;
[vulkan] Ensure msaa settings are consistent I had forgotten that msaa samples was governed by the driver (as a max) and the renderpass setup code simply took the max. Thus why 1 vs 8 caused the display to render incorrectly.
2020-12-21 11:17:27 +00:00
VkSampleCountFlagBits msaaSamples; // FIXME not here?
Completely rework the vulkan related api Things don't work yet, but this feels much cleaner.
2019-07-12 04:15:25 +00:00
VkSurfaceKHR surface; //FIXME surface = window, so "contains" swapchain
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
uint32_t swapImageIndex;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
struct scriptctx_s *script_context;
[vulkan] Create a render context This gets an empty (no tasks or pipelines connected) render context initialized and available for other subsystems to register their task functions. Nothing is using it yet, but the test parse of rp_main_def fails gracefully (needs those tasks).
2023-02-13 08:45:36 +00:00
struct qfv_renderctx_s *render_context;
[vulkan] Integrate screen capture in the new system This gets screenshots working again. As the implementation is now a (trivial) state machine, the pause when grabbing a screenshot is significantly reduced (it can be reduced even further by doing the png compression in a separate thread).
2023-06-25 12:01:34 +00:00
struct qfv_capturectx_s *capture_context;
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
struct texturectx_s *texture_context;
[vulkan] Move matrices into per-frame buffers This should fix the horrid frame rate dependent behavior of the view model. They are also in their own descriptor set so they can be easily shared between pipelines. This has been verified to work for Draw.
2021-12-08 06:28:21 +00:00
struct matrixctx_s *matrix_context;
[vulkan] Implement order implement transparency It's a bit flaky for particles, especially at higher frame rates, but that's due to supporting only 64 overlapping pixels. A reasonable solution is probably switching to a priority heap for the "sort" and upping the limit.
2022-11-30 18:00:47 +00:00
struct translucentctx_s *translucent_context;
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
struct aliasctx_s *alias_context;
[vulkan] Make a lot of progress for brush models Light maps are maybe updating, but as nothing is actually rendered yet, it's hard to tell.
2021-01-19 16:25:54 +00:00
struct bspctx_s *bsp_context;
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
struct iqmctx_s *iqm_context;
[vulkan] Use a buffer for entity transform and color data This allows the use of an entity id to index into the entity data and fetch the transform and colormod data in the vertex shader, thus making instanced rendering possible. Non-world brush entities are still not rendered, but the world entity is using both the entity data buffer and entid buffer.
2022-05-24 15:17:57 +00:00
struct scenectx_s *scene_context;
[vulkan] Upload palette as a 16x16 image It turns out my approach to alias skin coloring just doesn't work for the quake data due to the color curves not having a linear relationship, especially the bottom colors.
2022-11-15 00:26:17 +00:00
struct palettectx_s *palette_context;
[vulkan] Start work on particles for Vulkan This gets the pipelines loaded (and unloaded on shutdown). Probably the easy part :P. Still need to sort out the command buffers, synchronization, and particle generation (and probably a bunch else that's not coming to mind).
2021-12-16 14:17:01 +00:00
struct particlectx_s *particle_context;
[vulkan] Implement the sprite render passes It turned out the bindless approach wouldn't work too well for my design of the sprite objects, but I don't think that's a big issue at this stage (and it seems bindless is causing problems for brush/alias rendering via renderdoc and on my versa pro). However, I have figured out how to make effective use of descriptor sets (finally :P). The actual normal still needs checking, but the sprites are currently unlit so not an issue at this stage.
2021-12-14 16:22:05 +00:00
struct spritectx_s *sprite_context;
[vulkan] Rework draw to use a context struct Cleans up global space and makes it usable in multiple contexts. Also, max quads dropped to 32k as each frame now has its own vertex buffer to avoid issues with vertex overwrites (which I have seen). However, all vertex buffers are in the one memory/buffer object (using offsets) and the index buffer has been moved into a device-local memory object.
2021-01-16 05:42:25 +00:00
struct drawctx_s *draw_context;
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
struct lightingctx_s *lighting_context;
struct composectx_s *compose_context;
[vulkan] Add a module to handle output When working, this will handle the output to the swap-chain images and any final post-processing effects (gamma correction, screen scaling, etc). However, currently the screen is just black because the image for getting the main render pass output isn't hooked up yet.
2022-11-22 08:47:36 +00:00
struct outputctx_s *output_context;
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
Rework much of the Vulkan array handling So much for all those little wrappers hiding the device. Some survived, but mostly just the bigger things like device, swapchain, etc.
2020-02-17 11:29:35 +00:00
VkCommandPool cmdpool;
[vulkan] Use only one global staging buffer I think I did two as a bit of a ring buffer, but the new ring buffer system used inside a staging buffer makes it less necessary. Also, the staging buffer is now a fair bit bigger (4M is probably not really enough)
2021-01-16 05:37:16 +00:00
struct qfv_stagebuf_s *staging;
[vulkan] Change curFrame from size_t to uint32_t I very much doubt that even 4294967295 frames will be needed, let alone more. Saves me having to use %zd or %zu all over the place.
2022-11-25 07:02:39 +00:00
uint32_t curFrame;
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
qfv_renderpassset_t renderPasses;
Create command pool and frame timing fences Nothing is actually done yet, so the reported fps is around 172k (yes, k), but startup and shutdown seems to be clean (yay validation layers).
2020-02-16 13:45:27 +00:00
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
[vulkan] Create some default textures Black, white and magenta. This gets glow (full bright) maps working.
2021-01-23 06:40:31 +00:00
struct qfv_tex_s *default_black;
struct qfv_tex_s *default_white;
struct qfv_tex_s *default_magenta;
[vulkan] Add an array view for default_magenta The validation layers get very picky about image view types (rightfully so, I imagine).
2021-12-08 12:08:37 +00:00
struct qfv_tex_s *default_magenta_array;
[vulkan] Create some default textures Black, white and magenta. This gets glow (full bright) maps working.
2021-01-23 06:40:31 +00:00
[vulkan] Move viewport and scissor into qfv_renderpass_t This makes much more sense as they are intimately tied to the frame buffer on which a render pass is working. Now, just the window width and height are stored in vulkan_ctx_t. As a side benefit, QFV_CreateSwapchain no long references viddef (now just palette and conview in vulkan_draw.c to go).
2022-04-01 11:34:41 +00:00
// size of window
int window_width;
int window_height;
[console] Resurrect console scaling Currently only for gl/glsl/vulkan. However, rather than futzing with con_width and con_height (and trying to guess good values), con_scale (currently an integer) gives consistent pixel scaling regardless of window size.
2022-11-13 13:23:56 +00:00
int twod_scale;
[vulkan] Add some matrix buffers It seems they could all be in the one buffer: there are indications that uniform binding can be fairly fine-grained. I need to investigate that.
2021-01-12 02:26:20 +00:00
Separate render and presentation initialization This paves the way for clean initialization of the Vulkan renderer, and very much cleans up the older renderer initialization code as gl and sw are no longer intertwined.
2019-07-08 16:00:47 +00:00
#define EXPORTED_VULKAN_FUNCTION(fname) PFN_##fname fname;
#define GLOBAL_LEVEL_VULKAN_FUNCTION(fname) PFN_##fname fname;
#include "QF/Vulkan/funclist.h"
} vulkan_ctx_t;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
#define qfvPushDebug(ctx, x) \
do { \
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (developer & SYS_vulkan) { \
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
DARRAY_APPEND(&(ctx)->instance->debug_stack, (x)); \
} \
} while (0)
#define qfvPopDebug(ctx) \
do { \
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (developer & SYS_vulkan) { \
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
__auto_type ds = &(ctx)->instance->debug_stack; \
DARRAY_REMOVE_AT(ds, ds->size - 1); \
} \
} while (0)
Separate render and presentation initialization This paves the way for clean initialization of the Vulkan renderer, and very much cleans up the older renderer initialization code as gl and sw are no longer intertwined.
2019-07-08 16:00:47 +00:00
#endif//__vid_vulkan_h
Reference in a new issue Copy permalink