qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-12-20 17:41:06 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/renderer/vid_render_vulkan.c

804 lines
19 KiB
C
Raw Normal View History

Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
/*
vid_render_vulkan.c
Vulkan version of the renderer
Copyright (C) 2019 Bill Currie <bill@taniwha.org>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
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
#include <stdlib.h>
[vulkan] Fail gracefully if vulkan driver init fails Well, a little more gracefully than a segfault, at least.
2021-11-29 04:40:56 +00:00
#include "QF/cvar.h"
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
#include "QF/darray.h"
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
#include "QF/dstring.h"
#include "QF/quakefs.h"
Create a window and a surface for vulkan Yay, segfaults in R_Init :)
2019-07-09 07:33:44 +00:00
#include "QF/sys.h"
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
#include "QF/va.h"
Create a window and a surface for vulkan Yay, segfaults in R_Init :)
2019-07-09 07:33:44 +00:00
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
#include "QF/plugin/general.h"
#include "QF/plugin/vid_render.h"
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
#include "QF/Vulkan/qf_alias.h"
[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
#include "QF/Vulkan/qf_bsp.h"
[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
#include "QF/Vulkan/qf_compose.h"
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
#include "QF/Vulkan/qf_draw.h"
[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
#include "QF/Vulkan/qf_iqm.h"
[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
#include "QF/Vulkan/qf_lighting.h"
[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
#include "QF/Vulkan/qf_lightmap.h"
#include "QF/Vulkan/qf_main.h"
[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
#include "QF/Vulkan/qf_matrices.h"
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
#include "QF/Vulkan/qf_particles.h"
[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
#include "QF/Vulkan/qf_scene.h"
[vulkan] Load sprite model data The vertices and frame images are loaded into the one memory object, with the vertices first followed by the images. The vertices are 2D xy+uv sets meant to be applied to the model transform frame, and are pre-computed for the sprite size (this part does support sprites with varying frame image sizes). The frame images are loaded into one image with each frame on its own layer. This will cause some problems if any sprites with varying frame image sizes are found, but the three sprites in quake are all uniform size.
2021-12-14 01:02:35 +00:00
#include "QF/Vulkan/qf_sprite.h"
[vulkan] Generate triangle fans for bsp models They're not uploaded to the card yet, but the basics seem to be working.
2021-01-20 06:11:50 +00:00
#include "QF/Vulkan/qf_texture.h"
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
#include "QF/Vulkan/qf_vid.h"
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
#include "QF/Vulkan/capture.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
#include "QF/Vulkan/command.h"
[vulkan] Label renderpass and subpass sections This makes finding the relevant commands in render doc much much easier.
2022-05-07 03:38:31 +00:00
#include "QF/Vulkan/debug.h"
Completely rework the vulkan related api Things don't work yet, but this feels much cleaner.
2019-07-12 04:15:25 +00:00
#include "QF/Vulkan/device.h"
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
#include "QF/Vulkan/image.h"
Completely rework the vulkan related api Things don't work yet, but this feels much cleaner.
2019-07-12 04:15:25 +00:00
#include "QF/Vulkan/instance.h"
[renderer] Clean up FOV and viewport handling Viewport and FOV updates are now separate so updating one doesn't cause recalculations of the other. Also, perspective setup is now done directly from the tangents of the half angles for fov_x and fov_y making the renderers independent of fov/aspect mode. I imagine things are a bit of a mess with view size changes, and especially screen size changes (not supported yet anyway), and vulkan winds up updating its projection matrices every frame, but everything that's expected to work does (vulkan errors out for fisheye or warp due to frame buffer creation not being supported yet).
2022-03-30 05:55:32 +00:00
#include "QF/Vulkan/projection.h"
[vulkan] Free the staging buffer's command buffers Since the staging buffer allocates the command buffers it uses, it needs to free them when it is freed. I think I was confused by the validation layers not complaining about unfreed buffers when shutting down, but that's because destroying the pool (during program shutdown, when the validation layers would complain) frees all the buffers. Thus, due to staging buffers being created and destroyed during the level load process, (rather large) command buffers were piling up like imps in a Doom level. In the process, it was necessary to rearrange some of the shutdown code because vulkan_vid_render_shutdown destroys the shared command pool, but the pool is required for freeing the command buffers, but there was a minor mess of long-lived staging buffers being freed afterwards. That didn't end particularly well.
2022-05-13 01:19:08 +00:00
#include "QF/Vulkan/staging.h"
[vulkan] Make frame-buffers independent of swapchain This is more correct as the environment (X11 etc) might provide more swapchain images than we want: 3 frames in flight is generally considered a good balance between saturating the hardware and latency.
2021-01-16 12:24:42 +00:00
#include "QF/Vulkan/renderpass.h"
Completely rework the vulkan related api Things don't work yet, but this feels much cleaner.
2019-07-12 04:15:25 +00:00
#include "QF/Vulkan/swapchain.h"
[video] Use views instead of conwidth and conheight conwidth and conheight have been moved into vid.conview (probably change the name at some time), and scr_vrect has been replaced by a view as well. This makes it much easier to create 2d elements that follow the screen size (taking advantage of a view's gravity) which will, in the end, make changing the window size easier.
2021-07-10 09:04:34 +00:00
#include "QF/ui/view.h"
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
#include "QF/scene/entity.h"
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
#include "QF/scene/scene.h"
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
#include "mod_internal.h"
#include "r_internal.h"
Move vid callbacks into vid_internal Currently segfaults because viddef is an alias for *r_data->vid, which has not yet been initialized (chicken and egg).
2019-07-08 04:40:29 +00:00
#include "vid_internal.h"
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
#include "vid_vulkan.h"
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
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
static vulkan_ctx_t *vulkan_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
[particles] Create a psystem object This takes care of the global variables to a point (there is still the global struct shared between the non-vulkan renderers), but it also takes care of glsl's points-only rendering.
2021-12-19 05:47:25 +00:00
static struct psystem_s *
vulkan_ParticleSystem (void)
{
return Vulkan_ParticleSystem (vulkan_ctx);
}
Correct extension handling I had missed a critical bit from the cookbook.
2019-07-10 04:16:46 +00:00
static void
vulkan_R_Init (void)
{
[vulkan] Create a staging buffer struct And move the barrier prefabs into a more convenient place.
2021-01-10 16:24:15 +00:00
Vulkan_CreateStagingBuffers (vulkan_ctx);
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_CreateSwapchain (vulkan_ctx);
[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
Vulkan_CreateFrames (vulkan_ctx);
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
Vulkan_CreateCapture (vulkan_ctx);
[vulkan] Make frame-buffers independent of swapchain This is more correct as the environment (X11 etc) might provide more swapchain images than we want: 3 frames in flight is generally considered a good balance between saturating the hardware and latency.
2021-01-16 12:24:42 +00:00
Vulkan_CreateRenderPass (vulkan_ctx);
[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_Texture_Init (vulkan_ctx);
[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
[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
Vulkan_Matrix_Init (vulkan_ctx);
[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
Vulkan_Scene_Init (vulkan_ctx);
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
Vulkan_Alias_Init (vulkan_ctx);
[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
Vulkan_Bsp_Init (vulkan_ctx);
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
Vulkan_IQM_Init (vulkan_ctx);
[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
Vulkan_Particles_Init (vulkan_ctx);
[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
Vulkan_Sprite_Init (vulkan_ctx);
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
Vulkan_Draw_Init (vulkan_ctx);
[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
Vulkan_Lighting_Init (vulkan_ctx);
Vulkan_Compose_Init (vulkan_ctx);
[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
[vulkan] Initialize skins This allows the qw client to run with Vulkan.
2021-03-19 13:53:23 +00:00
Skin_Init ();
Create and destroy render pass and frame buffers
2020-02-18 08:18:37 +00:00
[vulkan] Get the 2D pipeline up and running First pixels! This was a nightmare of little issues that the validation layers couldn't help with: incorrect input assembly, incorrect vertex attribute specs. Though the layers did help with getting the queues working. Still, lots of work to go but this is a major breakthrough as I now have access to visual debugging for textures and the like.
2021-01-12 02:27:41 +00:00
SCR_Init ();
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
}
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
static void
vulkan_R_ClearState (void)
{
[renderer] move r_worldentity and r_viewleaf into refdef More cleanup of globals that seem to be quake specific.
2022-03-14 06:27:43 +00:00
r_refdef.worldmodel = 0;
[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
R_ClearEfrags ();
R_ClearDlights ();
[particles] Merge particle spawning into client After yesterday's crazy marathon editing all the particles files, and starting to do another big change to them today, I realized that I really do need to merge them down. All the actual spawning is now in the client library (though particle insertion will need to be moved). GLSL particle rendering is semi-broken in that it now does only points (until I come up with a way to select between points and quads (probably a context object, which I need anyway for Vulkan)).
2021-12-19 04:08:39 +00:00
R_ClearParticles ();
[vulkan] Clear lights when the scene is cleared Fixes a segfault when shutting down my test program.
2022-05-07 03:12:02 +00:00
Vulkan_LoadLights (0, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
vulkan_R_LoadSkys (const char *skyname)
{
[vulkan] Implement sky box loading and rendering Loading is broken for multi-file image sets due to the way images are loaded (this needs some thought for making it effecient), but the Blender environment map loading works.
2021-03-25 06:54:34 +00:00
Vulkan_LoadSkys (skyname, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
vulkan_R_NewScene (scene_t *scene)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
Vulkan_NewScene (scene, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
[qw] Clean up netgraph somewhat The renderer's LineGraph now takes a height parameter, and netgraph now uses cl_* cvars instead of r_* (which never really made sense), including it's own height cvar (the render graphs still use r_graphheight).
2021-07-11 01:59:27 +00:00
vulkan_R_LineGraph (int x, int y, int *h_vals, int count, int height)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
}
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
static void
vulkan_Draw_Character (int x, int y, unsigned ch)
{
Vulkan_Draw_Character (x, y, ch, vulkan_ctx);
}
static void
vulkan_Draw_String (int x, int y, const char *str)
{
Vulkan_Draw_String (x, y, str, vulkan_ctx);
}
static void
vulkan_Draw_nString (int x, int y, const char *str, int count)
{
Vulkan_Draw_nString (x, y, str, count, vulkan_ctx);
}
static void
vulkan_Draw_AltString (int x, int y, const char *str)
{
Vulkan_Draw_AltString (x, y, str, vulkan_ctx);
}
static void
vulkan_Draw_ConsoleBackground (int lines, byte alpha)
{
Vulkan_Draw_ConsoleBackground (lines, alpha, vulkan_ctx);
}
static void
vulkan_Draw_Crosshair (void)
{
Vulkan_Draw_Crosshair (vulkan_ctx);
}
static void
vulkan_Draw_CrosshairAt (int ch, int x, int y)
{
Vulkan_Draw_CrosshairAt (ch, x, y, vulkan_ctx);
}
static void
vulkan_Draw_TileClear (int x, int y, int w, int h)
{
Vulkan_Draw_TileClear (x, y, w, h, vulkan_ctx);
}
static void
vulkan_Draw_Fill (int x, int y, int w, int h, int c)
{
Vulkan_Draw_Fill (x, y, w, h, c, vulkan_ctx);
}
static void
vulkan_Draw_TextBox (int x, int y, int width, int lines, byte alpha)
{
Vulkan_Draw_TextBox (x, y, width, lines, alpha, vulkan_ctx);
}
static void
vulkan_Draw_FadeScreen (void)
{
Vulkan_Draw_FadeScreen (vulkan_ctx);
}
static void
vulkan_Draw_BlendScreen (quat_t color)
{
Vulkan_Draw_BlendScreen (color, vulkan_ctx);
}
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
static qpic_t *
vulkan_Draw_CachePic (const char *path, qboolean alpha)
{
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
return Vulkan_Draw_CachePic (path, alpha, vulkan_ctx);
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] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
static void
vulkan_Draw_UncachePic (const char *path)
{
Vulkan_Draw_UncachePic (path, vulkan_ctx);
}
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
static qpic_t *
vulkan_Draw_MakePic (int width, int height, const byte *data)
{
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
return Vulkan_Draw_MakePic (width, height, data, vulkan_ctx);
}
static void
vulkan_Draw_DestroyPic (qpic_t *pic)
{
Vulkan_Draw_DestroyPic (pic, vulkan_ctx);
}
static qpic_t *
vulkan_Draw_PicFromWad (const char *name)
{
return Vulkan_Draw_PicFromWad (name, vulkan_ctx);
}
static void
vulkan_Draw_Pic (int x, int y, qpic_t *pic)
{
Vulkan_Draw_Pic (x, y, pic, vulkan_ctx);
}
static void
vulkan_Draw_Picf (float x, float y, qpic_t *pic)
{
Vulkan_Draw_Picf (x, y, pic, vulkan_ctx);
}
static void
vulkan_Draw_SubPic (int x, int y, qpic_t *pic, int srcx, int srcy, int width, int height)
{
Vulkan_Draw_SubPic (x, y, pic, srcx, srcy, width, height, vulkan_ctx);
Correct extension handling I had missed a critical bit from the cookbook.
2019-07-10 04:16:46 +00:00
}
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
static void
vulkan_begin_frame (void)
{
uint32_t imageIndex = 0;
qfv_device_t *device = vulkan_ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
VkDevice dev = device->dev;
__auto_type frame = &vulkan_ctx->frames.a[vulkan_ctx->curFrame];
dfunc->vkWaitForFences (dev, 1, &frame->fence, VK_TRUE, 2000000000);
QFV_AcquireNextImage (vulkan_ctx->swapchain,
frame->imageAvailableSemaphore,
0, &imageIndex);
vulkan_ctx->swapImageIndex = imageIndex;
}
static void
vulkan_render_view (void)
{
__auto_type frame = &vulkan_ctx->frames.a[vulkan_ctx->curFrame];
uint32_t imageIndex = vulkan_ctx->swapImageIndex;
for (size_t i = 0; i < vulkan_ctx->renderPasses.size; i++) {
__auto_type rp = vulkan_ctx->renderPasses.a[i];
__auto_type rpFrame = &rp->frames.a[vulkan_ctx->curFrame];
frame->framebuffer = rp->framebuffers->a[imageIndex];
rp->draw (rpFrame);
}
}
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
static void
vulkan_draw_entities (entqueue_t *queue)
{
__auto_type frame = &vulkan_ctx->frames.a[vulkan_ctx->curFrame];
uint32_t imageIndex = vulkan_ctx->swapImageIndex;
for (size_t i = 0; i < vulkan_ctx->renderPasses.size; i++) {
__auto_type rp = vulkan_ctx->renderPasses.a[i];
__auto_type rpFrame = &rp->frames.a[vulkan_ctx->curFrame];
frame->framebuffer = rp->framebuffers->a[imageIndex];
Vulkan_RenderEntities (queue, rpFrame);
}
}
static void
vulkan_draw_particles (struct psystem_s *psystem)
{
}
[renderer] Handle transparent surfaces Other than the view model (undecided on the approach) this has R_RenderView pretty much pulled out of the low level renderers. With this, I'll be able to focus on scene handling for a bit then getting shadows and fisheye working (again for fisheye).
2022-03-17 15:14:48 +00:00
static void
vulkan_draw_transparent (void)
{
}
[renderer] Get sw fisheye working again Again, gl/vulkan not working yet (on the assumption that sw would be trickier). Fisheye overrides water warp because updating the projection map every frame is far too expensive. I've added a post-process pass to the interface in order to hide the implementation details, but I'm not sure I'm happy about how the multi-pass rendering for cube maps is handled (or having the frame buffers as exposed as they are), but mainly because Vulkan will make implementation interesting.
2022-03-24 06:45:01 +00:00
static void
vulkan_post_process (framebuffer_t *src)
{
}
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
static void
[renderer] Get timegraph and zgraph working Only for sw and gl right now, but this sorts out the issues that prevented the graphs working at all.
2022-03-15 06:42:43 +00:00
vulkan_set_2d (int scaled)
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
{
[renderer] Clean up FOV and viewport handling Viewport and FOV updates are now separate so updating one doesn't cause recalculations of the other. Also, perspective setup is now done directly from the tangents of the half angles for fov_x and fov_y making the renderers independent of fov/aspect mode. I imagine things are a bit of a mess with view size changes, and especially screen size changes (not supported yet anyway), and vulkan winds up updating its projection matrices every frame, but everything that's expected to work does (vulkan errors out for fisheye or warp due to frame buffer creation not being supported yet).
2022-03-30 05:55:32 +00:00
//FIXME this should not be done every frame
__auto_type mctx = vulkan_ctx->matrix_context;
__auto_type mat = &mctx->matrices;
int width = vid.conview->xlen; //FIXME vid
int height = vid.conview->ylen;
QFV_Orthographic (mat->Projection2d, 0, width, 0, height, 0, 99999);
mctx->dirty = mctx->frames.size;
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
}
static void
vulkan_end_frame (void)
{
qfv_device_t *device = vulkan_ctx->device;
VkDevice dev = device->dev;
qfv_devfuncs_t *dfunc = device->funcs;
qfv_queue_t *queue = &device->queue;
__auto_type frame = &vulkan_ctx->frames.a[vulkan_ctx->curFrame];
uint32_t imageIndex = vulkan_ctx->swapImageIndex;
VkCommandBufferBeginInfo beginInfo
= { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
VkRenderPassBeginInfo renderPassInfo = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
.renderArea = { {0, 0}, vulkan_ctx->swapchain->extent },
};
dfunc->vkBeginCommandBuffer (frame->cmdBuffer, &beginInfo);
for (size_t i = 0; i < vulkan_ctx->renderPasses.size; i++) {
__auto_type rp = vulkan_ctx->renderPasses.a[i];
__auto_type rpFrame = &rp->frames.a[vulkan_ctx->curFrame];
[vulkan] Label renderpass and subpass sections This makes finding the relevant commands in render doc much much easier.
2022-05-07 03:38:31 +00:00
QFV_CmdBeginLabel (device, frame->cmdBuffer, rp->name, rp->color);
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
if (rpFrame->renderpass) {
renderPassInfo.framebuffer = frame->framebuffer,
renderPassInfo.renderPass = rp->renderpass;
renderPassInfo.clearValueCount = rp->clearValues->size;
renderPassInfo.pClearValues = rp->clearValues->a;
dfunc->vkCmdBeginRenderPass (frame->cmdBuffer, &renderPassInfo,
rpFrame->subpassContents);
for (int j = 0; j < rpFrame->subpassCount; j++) {
__auto_type cmdSet = &rpFrame->subpassCmdSets[j];
if (cmdSet->size) {
[vulkan] Label renderpass and subpass sections This makes finding the relevant commands in render doc much much easier.
2022-05-07 03:38:31 +00:00
QFV_CmdBeginLabel (device, frame->cmdBuffer,
rpFrame->subpassInfo[j].name,
rpFrame->subpassInfo[j].color);
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
dfunc->vkCmdExecuteCommands (frame->cmdBuffer,
cmdSet->size, cmdSet->a);
[vulkan] Label renderpass and subpass sections This makes finding the relevant commands in render doc much much easier.
2022-05-07 03:38:31 +00:00
QFV_CmdEndLabel (device, frame->cmdBuffer);
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
}
// reset for next time around
cmdSet->size = 0;
//Regardless of whether any commands were submitted for this
//subpass, must step through each and every subpass, otherwise
//the attachments won't be transitioned correctly.
if (j < rpFrame->subpassCount - 1) {
dfunc->vkCmdNextSubpass (frame->cmdBuffer,
rpFrame->subpassContents);
}
}
dfunc->vkCmdEndRenderPass (frame->cmdBuffer);
} else {
for (int j = 0; j < rpFrame->subpassCount; j++) {
__auto_type cmdSet = &rpFrame->subpassCmdSets[j];
if (cmdSet->size) {
dfunc->vkCmdExecuteCommands (frame->cmdBuffer,
cmdSet->size, cmdSet->a);
}
// reset for next time around
cmdSet->size = 0;
}
}
[vulkan] Label renderpass and subpass sections This makes finding the relevant commands in render doc much much easier.
2022-05-07 03:38:31 +00:00
QFV_CmdEndLabel (device, frame->cmdBuffer);
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
}
if (vulkan_ctx->capture_callback) {
VkImage srcImage = vulkan_ctx->swapchain->images->a[imageIndex];
VkCommandBuffer cmd = QFV_CaptureImage (vulkan_ctx->capture, srcImage,
vulkan_ctx->curFrame);
dfunc->vkCmdExecuteCommands (frame->cmdBuffer, 1, &cmd);
}
dfunc->vkEndCommandBuffer (frame->cmdBuffer);
VkPipelineStageFlags waitStage
= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submitInfo = {
VK_STRUCTURE_TYPE_SUBMIT_INFO, 0,
1, &frame->imageAvailableSemaphore, &waitStage,
1, &frame->cmdBuffer,
1, &frame->renderDoneSemaphore,
};
dfunc->vkResetFences (dev, 1, &frame->fence);
dfunc->vkQueueSubmit (queue->queue, 1, &submitInfo, frame->fence);
if (vulkan_ctx->capture_callback) {
//FIXME look into "threading" this rather than waiting here
dfunc->vkWaitForFences (device->dev, 1, &frame->fence, VK_TRUE,
1000000000ull);
vulkan_ctx->capture_callback (QFV_CaptureData (vulkan_ctx->capture,
vulkan_ctx->curFrame),
vulkan_ctx->capture->extent.width,
vulkan_ctx->capture->extent.height);
vulkan_ctx->capture_callback = 0;
}
VkPresentInfoKHR presentInfo = {
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, 0,
1, &frame->renderDoneSemaphore,
1, &vulkan_ctx->swapchain->swapchain, &imageIndex,
0
};
dfunc->vkQueuePresentKHR (queue->queue, &presentInfo);
vulkan_ctx->curFrame++;
vulkan_ctx->curFrame %= vulkan_ctx->frames.size;
}
[renderer] Get sw fisheye working again Again, gl/vulkan not working yet (on the assumption that sw would be trickier). Fisheye overrides water warp because updating the projection map every frame is far too expensive. I've added a post-process pass to the interface in order to hide the implementation details, but I'm not sure I'm happy about how the multi-pass rendering for cube maps is handled (or having the frame buffers as exposed as they are), but mainly because Vulkan will make implementation interesting.
2022-03-24 06:45:01 +00:00
static framebuffer_t *
vulkan_create_cube_map (int size)
{
[vulkan] Safely ignore fisheye and water warp I didn't like the abort (especially having pushed it to master). This takes care of things until I can get them implemented properly (hopefully soon).
2022-04-01 07:49:39 +00:00
return 0;
[renderer] Get sw fisheye working again Again, gl/vulkan not working yet (on the assumption that sw would be trickier). Fisheye overrides water warp because updating the projection map every frame is far too expensive. I've added a post-process pass to the interface in order to hide the implementation details, but I'm not sure I'm happy about how the multi-pass rendering for cube maps is handled (or having the frame buffers as exposed as they are), but mainly because Vulkan will make implementation interesting.
2022-03-24 06:45:01 +00:00
}
[renderer] Move to using dynamic frame buffers For now, OpenGL and Vulkan renderers are broken as I focused on getting the software renderer working (which was quite tricky to get right). This fixes a couple of issues: the segfault when warping the screen (due to the scene rendering move invalidating the warp buffer), and warp always having 320x200 resolution. There's still the problem of the effect being too subtle at high resolution, but that's just a matter of updating the tables and tweaking the code in D_WarpScreen. Another issue is the Draw functions should probably write directly to the main frame buffer or even one passed in as a parameter. This would remove the need for binding the main buffer at the beginning and end of the frame.
2022-03-24 03:22:27 +00:00
static framebuffer_t *
vulkan_create_frame_buffer (int width, int height)
{
[vulkan] Safely ignore fisheye and water warp I didn't like the abort (especially having pushed it to master). This takes care of things until I can get them implemented properly (hopefully soon).
2022-04-01 07:49:39 +00:00
return 0;
[renderer] Move to using dynamic frame buffers For now, OpenGL and Vulkan renderers are broken as I focused on getting the software renderer working (which was quite tricky to get right). This fixes a couple of issues: the segfault when warping the screen (due to the scene rendering move invalidating the warp buffer), and warp always having 320x200 resolution. There's still the problem of the effect being too subtle at high resolution, but that's just a matter of updating the tables and tweaking the code in D_WarpScreen. Another issue is the Draw functions should probably write directly to the main frame buffer or even one passed in as a parameter. This would remove the need for binding the main buffer at the beginning and end of the frame.
2022-03-24 03:22:27 +00:00
}
static void
vulkan_bind_framebuffer (framebuffer_t *framebuffer)
{
}
[renderer] Clean up post processing While it's not where I want it to be, it at least now no longer messes with frame buffer binding or the view ports. This involved switching around buffers in D_WarpScreen so that the main buffer could be bound before post-processing.
2022-03-25 15:29:34 +00:00
static void
vulkan_set_viewport (const vrect_t *view)
{
}
[renderer] Clean up FOV and viewport handling Viewport and FOV updates are now separate so updating one doesn't cause recalculations of the other. Also, perspective setup is now done directly from the tangents of the half angles for fov_x and fov_y making the renderers independent of fov/aspect mode. I imagine things are a bit of a mess with view size changes, and especially screen size changes (not supported yet anyway), and vulkan winds up updating its projection matrices every frame, but everything that's expected to work does (vulkan errors out for fisheye or warp due to frame buffer creation not being supported yet).
2022-03-30 05:55:32 +00:00
static void
vulkan_set_fov (float x, float y)
{
if (!vulkan_ctx || !vulkan_ctx->matrix_context) {
return;
}
__auto_type mctx = vulkan_ctx->matrix_context;
__auto_type mat = &mctx->matrices;
QFV_PerspectiveTan (mat->Projection3d, x, y);
mctx->dirty = mctx->frames.size;
}
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
static int
is_bgr (VkFormat format)
{
return (format >= VK_FORMAT_B8G8R8A8_UNORM
&& format <= VK_FORMAT_B8G8R8A8_SRGB);
}
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
static void
capture_screenshot (const byte *data, int width, int height)
{
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
int count = width * height;
tex_t *tex = malloc (sizeof (tex_t) + count * 3);
if (tex) {
tex->data = (byte *) (tex + 1);
[image] Make WritePNG take settings from tex_t This means that a tex_t object is passed in instead of just raw bytes and width and height, but it means the texture can specify whether it's flipped or uses BGR instead of RGB. This fixes the upside down screenshots for vulkan.
2022-03-31 11:00:13 +00:00
tex->flagbits = 0;
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
tex->width = width;
tex->height = height;
tex->format = tex_rgb;
tex->palette = 0;
[image] Make WritePNG take settings from tex_t This means that a tex_t object is passed in instead of just raw bytes and width and height, but it means the texture can specify whether it's flipped or uses BGR instead of RGB. This fixes the upside down screenshots for vulkan.
2022-03-31 11:00:13 +00:00
tex->flagbits = 0;
tex->loaded = 1;
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
if (!vulkan_ctx->capture->canBlit ||
is_bgr (vulkan_ctx->swapchain->format)) {
[image] Make WritePNG take settings from tex_t This means that a tex_t object is passed in instead of just raw bytes and width and height, but it means the texture can specify whether it's flipped or uses BGR instead of RGB. This fixes the upside down screenshots for vulkan.
2022-03-31 11:00:13 +00:00
tex->bgr = 1;
}
const byte *src = data;
byte *dst = tex->data;
for (int count = width * height; count-- > 0; ) {
*dst++ = *src++;
*dst++ = *src++;
*dst++ = *src++;
src++;
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
}
}
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
capfunc_t callback = vulkan_ctx->capture_complete;
callback (tex, vulkan_ctx->capture_complete_data);;
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
}
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
static void
vulkan_capture_screen (capfunc_t callback, void *data)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
if (!vulkan_ctx->capture) {
[renderer] Merge screenshot code as much as possible Only CaptureBGR is per-renderer as the rest of the screenshot code uses it to do the actual capture (which is target dependent). Vulkan is currently broken due to capture being an asynchronous process and the rest of the code expecting capture to be synchronous (also, bgr vs rgb). The best thing is all renderers now write the same format (currently png).
2022-03-07 05:39:47 +00:00
Sys_Printf ("Capture not supported\n");
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
callback (0, data);
return;
[vulkan] Implement screenshot Finally, I can brag about my progress on irc :)
2021-03-24 10:20:53 +00:00
}
vulkan_ctx->capture_callback = capture_screenshot;
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
vulkan_ctx->capture_complete = callback;
vulkan_ctx->capture_complete_data = data;
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
[model] Clean up the globals around model loading Covers only the generic load code (alias etc to follow), but this should take care of a lot of issues in the future.
2021-02-01 05:39:00 +00:00
vulkan_Mod_LoadLighting (model_t *mod, bsp_t *bsp)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
[model] Clean up the globals around model loading Covers only the generic load code (alias etc to follow), but this should take care of a lot of issues in the future.
2021-02-01 05:39:00 +00:00
Vulkan_Mod_LoadLighting (mod, bsp, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
[model] Clean up the globals around model loading Covers only the generic load code (alias etc to follow), but this should take care of a lot of issues in the future.
2021-02-01 05:39:00 +00:00
vulkan_Mod_SubdivideSurface (model_t *mod, msurface_t *fa)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
}
static void
[model] Clean up the globals around model loading Covers only the generic load code (alias etc to follow), but this should take care of a lot of issues in the future.
2021-02-01 05:39:00 +00:00
vulkan_Mod_ProcessTexture (model_t *mod, texture_t *tx)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
[model] Clean up the globals around model loading Covers only the generic load code (alias etc to follow), but this should take care of a lot of issues in the future.
2021-02-01 05:39:00 +00:00
Vulkan_Mod_ProcessTexture (mod, tx, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
vulkan_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx,
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
void *_m, int _s, int extra)
{
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
Vulkan_Mod_MakeAliasModelDisplayLists (alias_ctx, _m, _s, extra,
vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
[model] Make alias skin loading a batch operation Really, this won't make all that much difference because alias models with more than one skin are quite rare, and those with animated skin groups are even rarer. However, for those models that do have more than one skin, it will allow for reduced allocation overheads, and when supported (glsl, vulkan, maybe gl), loading all the skins into an array texture (since all skins are the same size, though external skins may vary), but that's not implemented yet, this just wraps the old one skin at a time code.
2022-04-04 06:38:27 +00:00
static void
vulkan_Mod_LoadAllSkins (mod_alias_ctx_t *alias_ctx)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
[model] Make alias skin loading a batch operation Really, this won't make all that much difference because alias models with more than one skin are quite rare, and those with animated skin groups are even rarer. However, for those models that do have more than one skin, it will allow for reduced allocation overheads, and when supported (glsl, vulkan, maybe gl), loading all the skins into an array texture (since all skins are the same size, though external skins may vary), but that's not implemented yet, this just wraps the old one skin at a time code.
2022-04-04 06:38:27 +00:00
Vulkan_Mod_LoadAllSkins (alias_ctx, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
vulkan_Mod_FinalizeAliasModel (mod_alias_ctx_t *alias_ctx)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
Vulkan_Mod_FinalizeAliasModel (alias_ctx, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
vulkan_Mod_LoadExternalSkins (mod_alias_ctx_t *alias_ctx)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
}
static void
vulkan_Mod_IQMFinish (model_t *mod)
{
[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
Vulkan_Mod_IQMFinish (mod, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
[sprite] Separate model and texture loading As much as it can be since the texture data is interleaved with the model data in the files (I guess not that bad a design for 25 years ago with the tight memory constraints), but this paves the way for supporting sprites in Vulkan.
2021-12-13 23:36:19 +00:00
vulkan_Mod_SpriteLoadFrames (mod_sprite_ctx_t *sprite_ctx)
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
{
[vulkan] Load sprite model data The vertices and frame images are loaded into the one memory object, with the vertices first followed by the images. The vertices are 2D xy+uv sets meant to be applied to the model transform frame, and are pre-computed for the sprite size (this part does support sprites with varying frame image sizes). The frame images are loaded into one image with each frame on its own layer. This will cause some problems if any sprites with varying frame image sizes are found, but the three sprites in quake are all uniform size.
2021-12-14 01:02:35 +00:00
Vulkan_Mod_SpriteLoadFrames (sprite_ctx, vulkan_ctx);
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
}
static void
vulkan_Skin_SetupSkin (struct skin_s *skin, int cmap)
{
}
static void
vulkan_Skin_ProcessTranslation (int cmap, const byte *translation)
{
}
static void
vulkan_Skin_InitTranslations (void)
{
}
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
static void
[video] Get 16 and 32 bit sw32 mostly working in x11 Lighting on alias models seems to be borked, and skies are borked in both sw renderers (seems to be nothing to do with this commit, though).
2021-07-10 15:09:41 +00:00
set_palette (void *data, const byte *palette)
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
{
//FIXME really don't want this here: need an application domain
//so Quake can be separated from QuakeForge (ie, Quake itself becomes
//an app using the QuakeForge engine)
}
static void
[video] Get 16 and 32 bit sw32 mostly working in x11 Lighting on alias models seems to be borked, and skies are borked in both sw renderers (seems to be nothing to do with this commit, though).
2021-07-10 15:09:41 +00:00
vulkan_vid_render_choose_visual (void *data)
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
{
Vulkan_CreateDevice (vulkan_ctx);
[vulkan] Fail gracefully if vulkan driver init fails Well, a little more gracefully than a segfault, at least.
2021-11-29 04:40:56 +00:00
if (!vulkan_ctx->device) {
Sys_Error ("Unable to create Vulkan device.%s",
[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
vulkan_use_validation ? ""
[vulkan] Fail gracefully if vulkan driver init fails Well, a little more gracefully than a segfault, at least.
2021-11-29 04:40:56 +00:00
: "\nSet vulkan_use_validation for details");
}
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
vulkan_ctx->choose_visual (vulkan_ctx);
vulkan_ctx->cmdpool = QFV_CreateCommandPool (vulkan_ctx->device,
vulkan_ctx->device->queue.queueFamily,
0, 1);
__auto_type cmdset = QFV_AllocCommandBufferSet (1, alloca);
QFV_AllocateCommandBuffers (vulkan_ctx->device, vulkan_ctx->cmdpool, 0,
cmdset);
vulkan_ctx->cmdbuffer = cmdset->a[0];
vulkan_ctx->fence = QFV_CreateFence (vulkan_ctx->device, 1);
Sys_MaskPrintf (SYS_vulkan, "vk choose visual %p %p %d %#zx\n",
vulkan_ctx->device->dev, vulkan_ctx->device->queue.queue,
vulkan_ctx->device->queue.queueFamily,
(size_t) vulkan_ctx->cmdpool);
}
static void
[video] Get 16 and 32 bit sw32 mostly working in x11 Lighting on alias models seems to be borked, and skies are borked in both sw renderers (seems to be nothing to do with this commit, though).
2021-07-10 15:09:41 +00:00
vulkan_vid_render_create_context (void *data)
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
{
vulkan_ctx->create_window (vulkan_ctx);
vulkan_ctx->surface = vulkan_ctx->create_surface (vulkan_ctx);
Sys_MaskPrintf (SYS_vulkan, "vk create context %#zx\n",
(size_t) vulkan_ctx->surface);
}
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
static vid_model_funcs_t model_funcs = {
[vulkan] Generate triangle fans for bsp models They're not uploaded to the card yet, but the basics seem to be working.
2021-01-20 06:11:50 +00:00
sizeof (vulktex_t) + 2 * sizeof (qfv_tex_t),
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
vulkan_Mod_LoadLighting,
vulkan_Mod_SubdivideSurface,
vulkan_Mod_ProcessTexture,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
Mod_LoadIQM,
Mod_LoadAliasModel,
Mod_LoadSpriteModel,
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
vulkan_Mod_MakeAliasModelDisplayLists,
[model] Make alias skin loading a batch operation Really, this won't make all that much difference because alias models with more than one skin are quite rare, and those with animated skin groups are even rarer. However, for those models that do have more than one skin, it will allow for reduced allocation overheads, and when supported (glsl, vulkan, maybe gl), loading all the skins into an array texture (since all skins are the same size, though external skins may vary), but that's not implemented yet, this just wraps the old one skin at a time code.
2022-04-04 06:38:27 +00:00
vulkan_Mod_LoadAllSkins,
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
vulkan_Mod_FinalizeAliasModel,
vulkan_Mod_LoadExternalSkins,
vulkan_Mod_IQMFinish,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
0,
[sprite] Separate model and texture loading As much as it can be since the texture data is interleaved with the model data in the files (I guess not that bad a design for 25 years ago with the tight memory constraints), but this paves the way for supporting sprites in Vulkan.
2021-12-13 23:36:19 +00:00
vulkan_Mod_SpriteLoadFrames,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
[model] Support freeing of skin data I doubt it's enough, but it does seem to cover what's needed for glsl (maybe not the actual textures, unsure there, but I think they're recycled).
2022-05-12 13:46:31 +00:00
Skin_Free,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
Skin_SetColormap,
Skin_SetSkin,
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
vulkan_Skin_SetupSkin,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
Skin_SetTranslation,
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
vulkan_Skin_ProcessTranslation,
vulkan_Skin_InitTranslations,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
};
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
static void
vulkan_vid_render_init (void)
{
if (!vr_data.vid->vid_internal->vulkan_context) {
Sys_Error ("Sorry, Vulkan not supported by this program.");
}
vulkan_ctx = vr_data.vid->vid_internal->vulkan_context ();
vulkan_ctx->load_vulkan (vulkan_ctx);
Vulkan_Init_Common (vulkan_ctx);
[video] Get 16 and 32 bit sw32 mostly working in x11 Lighting on alias models seems to be borked, and skies are borked in both sw renderers (seems to be nothing to do with this commit, though).
2021-07-10 15:09:41 +00:00
vr_data.vid->vid_internal->data = vulkan_ctx;
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
vr_data.vid->vid_internal->set_palette = set_palette;
vr_data.vid->vid_internal->choose_visual = vulkan_vid_render_choose_visual;
vr_data.vid->vid_internal->create_context = vulkan_vid_render_create_context;
vr_funcs = &vulkan_vid_render_funcs;
m_funcs = &model_funcs;
}
static void
vulkan_vid_render_shutdown (void)
{
[vulkan] Fail gracefully if vulkan driver init fails Well, a little more gracefully than a segfault, at least.
2021-11-29 04:40:56 +00:00
if (!vulkan_ctx || !vulkan_ctx->device) {
return;
}
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
qfv_device_t *device = vulkan_ctx->device;
qfv_devfuncs_t *df = device->funcs;
VkDevice dev = device->dev;
QFV_DeviceWaitIdle (device);
[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
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
Mod_ClearAll ();
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
Vulkan_Compose_Shutdown (vulkan_ctx);
Vulkan_Lighting_Shutdown (vulkan_ctx);
Vulkan_Draw_Shutdown (vulkan_ctx);
[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
Vulkan_Sprite_Shutdown (vulkan_ctx);
[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
Vulkan_Particles_Shutdown (vulkan_ctx);
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
Vulkan_IQM_Shutdown (vulkan_ctx);
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
Vulkan_Bsp_Shutdown (vulkan_ctx);
Vulkan_Alias_Shutdown (vulkan_ctx);
[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
Vulkan_Scene_Shutdown (vulkan_ctx);
[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
Vulkan_Matrix_Shutdown (vulkan_ctx);
[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
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
Vulkan_Texture_Shutdown (vulkan_ctx);
[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
Vulkan_DestroyRenderPasses (vulkan_ctx);
[vulkan] Free the staging buffer's command buffers Since the staging buffer allocates the command buffers it uses, it needs to free them when it is freed. I think I was confused by the validation layers not complaining about unfreed buffers when shutting down, but that's because destroying the pool (during program shutdown, when the validation layers would complain) frees all the buffers. Thus, due to staging buffers being created and destroyed during the level load process, (rather large) command buffers were piling up like imps in a Doom level. In the process, it was necessary to rearrange some of the shutdown code because vulkan_vid_render_shutdown destroys the shared command pool, but the pool is required for freeing the command buffers, but there was a minor mess of long-lived staging buffers being freed afterwards. That didn't end particularly well.
2022-05-13 01:19:08 +00:00
QFV_DestroyStagingBuffer (vulkan_ctx->staging);
df->vkDestroyFence (dev, vulkan_ctx->fence, 0);
df->vkDestroyCommandPool (dev, vulkan_ctx->cmdpool, 0);
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
Vulkan_Shutdown_Common (vulkan_ctx);
}
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
vid_render_funcs_t vulkan_vid_render_funcs = {
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
vulkan_vid_render_init,
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
vulkan_Draw_Character,
vulkan_Draw_String,
vulkan_Draw_nString,
vulkan_Draw_AltString,
vulkan_Draw_ConsoleBackground,
vulkan_Draw_Crosshair,
vulkan_Draw_CrosshairAt,
vulkan_Draw_TileClear,
vulkan_Draw_Fill,
vulkan_Draw_TextBox,
vulkan_Draw_FadeScreen,
vulkan_Draw_BlendScreen,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
vulkan_Draw_CachePic,
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
vulkan_Draw_UncachePic,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
vulkan_Draw_MakePic,
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
vulkan_Draw_DestroyPic,
vulkan_Draw_PicFromWad,
vulkan_Draw_Pic,
vulkan_Draw_Picf,
vulkan_Draw_SubPic,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
[particles] Create a psystem object This takes care of the global variables to a point (there is still the global struct shared between the non-vulkan renderers), but it also takes care of glsl's points-only rendering.
2021-12-19 05:47:25 +00:00
vulkan_ParticleSystem,
Correct extension handling I had missed a critical bit from the cookbook.
2019-07-10 04:16:46 +00:00
vulkan_R_Init,
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
vulkan_R_ClearState,
vulkan_R_LoadSkys,
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
vulkan_R_NewScene,
[renderer] Stub out all the vulkan functions nq-x11 now gets through all three demos without crashing (but without rendering anything useful, though).
2021-01-18 03:46:06 +00:00
vulkan_R_LineGraph,
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
vulkan_begin_frame,
vulkan_render_view,
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
vulkan_draw_entities,
vulkan_draw_particles,
[renderer] Handle transparent surfaces Other than the view model (undecided on the approach) this has R_RenderView pretty much pulled out of the low level renderers. With this, I'll be able to focus on scene handling for a bit then getting shadows and fisheye working (again for fisheye).
2022-03-17 15:14:48 +00:00
vulkan_draw_transparent,
[renderer] Get sw fisheye working again Again, gl/vulkan not working yet (on the assumption that sw would be trickier). Fisheye overrides water warp because updating the projection map every frame is far too expensive. I've added a post-process pass to the interface in order to hide the implementation details, but I'm not sure I'm happy about how the multi-pass rendering for cube maps is handled (or having the frame buffers as exposed as they are), but mainly because Vulkan will make implementation interesting.
2022-03-24 06:45:01 +00:00
vulkan_post_process,
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
vulkan_set_2d,
vulkan_end_frame,
[renderer] Move to using dynamic frame buffers For now, OpenGL and Vulkan renderers are broken as I focused on getting the software renderer working (which was quite tricky to get right). This fixes a couple of issues: the segfault when warping the screen (due to the scene rendering move invalidating the warp buffer), and warp always having 320x200 resolution. There's still the problem of the effect being too subtle at high resolution, but that's just a matter of updating the tables and tweaking the code in D_WarpScreen. Another issue is the Draw functions should probably write directly to the main frame buffer or even one passed in as a parameter. This would remove the need for binding the main buffer at the beginning and end of the frame.
2022-03-24 03:22:27 +00:00
[renderer] Get sw fisheye working again Again, gl/vulkan not working yet (on the assumption that sw would be trickier). Fisheye overrides water warp because updating the projection map every frame is far too expensive. I've added a post-process pass to the interface in order to hide the implementation details, but I'm not sure I'm happy about how the multi-pass rendering for cube maps is handled (or having the frame buffers as exposed as they are), but mainly because Vulkan will make implementation interesting.
2022-03-24 06:45:01 +00:00
vulkan_create_cube_map,
[renderer] Move to using dynamic frame buffers For now, OpenGL and Vulkan renderers are broken as I focused on getting the software renderer working (which was quite tricky to get right). This fixes a couple of issues: the segfault when warping the screen (due to the scene rendering move invalidating the warp buffer), and warp always having 320x200 resolution. There's still the problem of the effect being too subtle at high resolution, but that's just a matter of updating the tables and tweaking the code in D_WarpScreen. Another issue is the Draw functions should probably write directly to the main frame buffer or even one passed in as a parameter. This would remove the need for binding the main buffer at the beginning and end of the frame.
2022-03-24 03:22:27 +00:00
vulkan_create_frame_buffer,
vulkan_bind_framebuffer,
[renderer] Clean up post processing While it's not where I want it to be, it at least now no longer messes with frame buffer binding or the view ports. This involved switching around buffers in D_WarpScreen so that the main buffer could be bound before post-processing.
2022-03-25 15:29:34 +00:00
vulkan_set_viewport,
[renderer] Clean up FOV and viewport handling Viewport and FOV updates are now separate so updating one doesn't cause recalculations of the other. Also, perspective setup is now done directly from the tangents of the half angles for fov_x and fov_y making the renderers independent of fov/aspect mode. I imagine things are a bit of a mess with view size changes, and especially screen size changes (not supported yet anyway), and vulkan winds up updating its projection matrices every frame, but everything that's expected to work does (vulkan errors out for fisheye or warp due to frame buffer creation not being supported yet).
2022-03-30 05:55:32 +00:00
vulkan_set_fov,
[renderer] Move to using dynamic frame buffers For now, OpenGL and Vulkan renderers are broken as I focused on getting the software renderer working (which was quite tricky to get right). This fixes a couple of issues: the segfault when warping the screen (due to the scene rendering move invalidating the warp buffer), and warp always having 320x200 resolution. There's still the problem of the effect being too subtle at high resolution, but that's just a matter of updating the tables and tweaking the code in D_WarpScreen. Another issue is the Draw functions should probably write directly to the main frame buffer or even one passed in as a parameter. This would remove the need for binding the main buffer at the beginning and end of the frame.
2022-03-24 03:22:27 +00:00
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
vulkan_capture_screen,
Uncomment already implemented functions
2019-07-09 12:07:59 +00:00
&model_funcs
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
};
static general_funcs_t plugin_info_general_funcs = {
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
.shutdown = vulkan_vid_render_shutdown,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
};
static general_data_t plugin_info_general_data;
static plugin_funcs_t plugin_info_funcs = {
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
.general = &plugin_info_general_funcs,
.vid_render = &vulkan_vid_render_funcs,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
};
static plugin_data_t plugin_info_data = {
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
.general = &plugin_info_general_data,
.vid_render = &vid_render_data,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
};
static plugin_t plugin_info = {
Fix vid renderer plugin types I guess that plugin type is currently not checked, otherwise I doubt the mistake would have gone unnoticed.
2019-07-07 05:57:56 +00:00
qfp_vid_render,
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
0,
QFPLUGIN_VERSION,
"0.1",
Correct vulkan plugin strings
2019-07-07 05:59:20 +00:00
"Vulkan Renderer",
[vulkan] Correct a pile of copyright attributions Id Software had pretty much nothing to do with the vulkan renderer (they still get credit for code that's heavily based on the original quake code, of course).
2022-05-04 05:39:47 +00:00
"Copyright (C) 2019 Bill Currie <bill@taniwha.org>\n"
Start work on a Vulkan-based renderer Doesn't do much other than create an instance and enumerate some stuff, but the build system is working.
2019-07-06 05:42:53 +00:00
"Please see the file \"AUTHORS\" for a list of contributors",
&plugin_info_funcs,
&plugin_info_data,
};
PLUGIN_INFO(vid_render, vulkan)
{
return &plugin_info;
}
Reference in a new issue Copy permalink