qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-23 21:02:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/renderer/vulkan/shader.c

258 lines
8.6 KiB
C
Raw Normal View History

[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
/*
shader.c
Vulkan shader manager
Copyright (C) 2020 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
[vulkan] Clean up a lot of unnecessary includes Too much copying of base files.
2022-03-30 06:54:07 +00:00
#include <string.h>
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
#include "QF/dstring.h"
#include "QF/quakefs.h"
#include "QF/sys.h"
[vulkan] Clean up a lot of unnecessary includes Too much copying of base files.
2022-03-30 06:54:07 +00:00
[vulkan] Name some more objects Shaders and descriptor set layouts.
2021-04-19 08:49:03 +00:00
#include "QF/Vulkan/debug.h"
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
#include "QF/Vulkan/device.h"
#include "QF/Vulkan/shader.h"
[vulkan] Add support for 9-slice rendering There's no API yet as I need to look into the handling of qpic_t before I can get any of this into the other renderers (or even vulkan, for that matter). However, the current design for slice rendering is based on glyphs (ie, using instances and vertex pulling), with 3 strips of 3 quads, 16 verts, and 26 indices (2 reset). Hacky testing seems to work, but real tests need the API.
2022-11-18 00:44:01 +00:00
static
#include "libs/video/renderer/vulkan/shader/slice.vert.spvc"
[vullkan] Rework Draw implementation Line rendering now has its own pipeline (removing the texture issue). Glyph rendering (for fonts) has been reworked to use instanced quad rendering, with the geometry (position and texture coords) in a static buffer (uniform texture buffer), and each instance has a glyph index, color, and 2d base position. Multiple fonts can be loaded, but aren't used yet: still just the one (work needs to be done on the queues to support multiple textures/fonts). Quads haven't changed much, but buffer creation and destruction has been cleaned up to use the resource functions.
2022-10-03 01:29:49 +00:00
static
#include "libs/video/renderer/vulkan/shader/line.vert.spvc"
static
#include "libs/video/renderer/vulkan/shader/line.frag.spvc"
[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
static
#include "libs/video/renderer/vulkan/shader/particle.vert.spvc"
static
#include "libs/video/renderer/vulkan/shader/particle.geom.spvc"
static
#include "libs/video/renderer/vulkan/shader/particle.frag.spvc"
static
#include "libs/video/renderer/vulkan/shader/partphysics.comp.spvc"
static
#include "libs/video/renderer/vulkan/shader/partupdate.comp.spvc"
[vulkan] Create the non-C side of the sprite pipeline This adds the shaders and the pipeline specs. I'm not sure that the deferred rendering side of the render pass is appropriate, but I thought I'd give it a go, since quake sprites are really cutoff rather than translucent.
2021-12-14 05:44:16 +00:00
static
#include "libs/video/renderer/vulkan/shader/sprite_gbuf.vert.spvc"
static
#include "libs/video/renderer/vulkan/shader/sprite_gbuf.frag.spvc"
static
#include "libs/video/renderer/vulkan/shader/sprite_depth.vert.spvc"
static
#include "libs/video/renderer/vulkan/shader/sprite_depth.frag.spvc"
[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
[vulkan] Do a depth pass for 2d objects While the HUD and status bar don't cut out a lot of screen (normally), they might start to make a difference when I get transparency working properly. The main thing is this is a step towards pulling the 2d rendering into another render pass so the main deferred pass is world-only.
2022-11-20 17:29:03 +00:00
#include "libs/video/renderer/vulkan/shader/twod_depth.frag.spvc"
static
[vulkan] Move the shaders into their own directory
2021-02-10 08:43:11 +00:00
#include "libs/video/renderer/vulkan/shader/twod.vert.spvc"
[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
[vulkan] Move the shaders into their own directory
2021-02-10 08:43:11 +00:00
#include "libs/video/renderer/vulkan/shader/twod.frag.spvc"
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
static
[vulkan] Move the shaders into their own directory
2021-02-10 08:43:11 +00:00
#include "libs/video/renderer/vulkan/shader/quakebsp.vert.spvc"
[vulkan] Create shanders for brush models The fragment shader is a bit of a mini mega-shader, but I do want to try out specializations.
2021-01-18 08:13:52 +00:00
static
[vulkan] Move the shaders into their own directory
2021-02-10 08:43:11 +00:00
#include "libs/video/renderer/vulkan/shader/quakebsp.frag.spvc"
[vulkan] Create shanders for brush models The fragment shader is a bit of a mini mega-shader, but I do want to try out specializations.
2021-01-18 08:13:52 +00:00
static
[vulkan] Convert bsp and draw to deferred This has bsp and draw passing muster with the validation layers.
2021-02-19 02:14:54 +00:00
#include "libs/video/renderer/vulkan/shader/bsp_depth.vert.spvc"
static
#include "libs/video/renderer/vulkan/shader/bsp_gbuf.vert.spvc"
static
#include "libs/video/renderer/vulkan/shader/bsp_gbuf.geom.spvc"
static
#include "libs/video/renderer/vulkan/shader/bsp_gbuf.frag.spvc"
static
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
#include "libs/video/renderer/vulkan/shader/bsp_shadow.vert.spvc"
static
[vulkan] Fix up commands for deferred rendering Nothing gets output yet (lighting and composite passes not implemented), but everything passes validation until exit (not destroying everything).
2021-02-23 06:43:02 +00:00
#include "libs/video/renderer/vulkan/shader/bsp_sky.frag.spvc"
static
[vulkan] Implement water surface rendering They're unlit (fullbright, but that's nothing new for quake), but working nicely. As a bonus, sort out the sky pass (forced to due to the way command buffers are used).
2021-03-23 03:24:24 +00:00
#include "libs/video/renderer/vulkan/shader/bsp_turb.frag.spvc"
static
[vulkan] Rework lighting to use splats It's currently slower, and the cone splats are buggy, but the lighting code itself got some nice cleanups.
2023-06-27 16:01:56 +00:00
#include "libs/video/renderer/vulkan/shader/light_flat.vert.spvc"
static
#include "libs/video/renderer/vulkan/shader/light_splat.vert.spvc"
static
[vulkan] Add debug lines for light splats Disabled, but all that's needed is to uncomment the debug pipeline in the compose subpass.
2023-06-28 02:47:26 +00:00
#include "libs/video/renderer/vulkan/shader/light_debug.frag.spvc"
static
[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 "libs/video/renderer/vulkan/shader/lighting.frag.spvc"
static
#include "libs/video/renderer/vulkan/shader/compose.frag.spvc"
static
[vulkan] Move the shaders into their own directory
2021-02-10 08:43:11 +00:00
#include "libs/video/renderer/vulkan/shader/alias.vert.spvc"
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
static
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
#include "libs/video/renderer/vulkan/shader/alias_depth.vert.spvc"
static
[vulkan] Move the shaders into their own directory
2021-02-10 08:43:11 +00:00
#include "libs/video/renderer/vulkan/shader/alias.frag.spvc"
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
static
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
#include "libs/video/renderer/vulkan/shader/alias_gbuf.frag.spvc"
static
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
#include "libs/video/renderer/vulkan/shader/alias_shadow.vert.spvc"
static
[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 "libs/video/renderer/vulkan/shader/iqm.vert.spvc"
static
#include "libs/video/renderer/vulkan/shader/iqm.frag.spvc"
static
[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
#include "libs/video/renderer/vulkan/shader/output.frag.spvc"
static
[vulkan] Move the shaders into their own directory
2021-02-10 08:43:11 +00:00
#include "libs/video/renderer/vulkan/shader/passthrough.vert.spvc"
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
static
[vulkan] Switch to full screen triangle instead of quad While I have trouble imagining it making that much performance difference going from 4 verts to 3 for a whopping 2 polygons, or even from 2 triangles to 1 for each poly, using only indices for the vertices does remove a lot of code, and better yet, some memory and buffer allocations... always a good thing. That said, I guess freeing up a GPU thread for something else could make a difference.
2022-04-01 10:50:41 +00:00
#include "libs/video/renderer/vulkan/shader/fstriangle.vert.spvc"
static
[vulkan] Create a water warp output pipeline Although it works as intended (tested via hacking), it's not hooked up as the current frame buffer handling in r_screen is not readily compatible with how vulkan output is handled. This will need some thought to get working.
2022-11-27 03:48:51 +00:00
#include "libs/video/renderer/vulkan/shader/fstrianglest.vert.spvc"
static
[vulkan] Move the shaders into their own directory
2021-02-10 08:43:11 +00:00
#include "libs/video/renderer/vulkan/shader/pushcolor.frag.spvc"
[vulkan] Create a water warp output pipeline Although it works as intended (tested via hacking), it's not hooked up as the current frame buffer handling in r_screen is not readily compatible with how vulkan output is handled. This will need some thought to get working.
2022-11-27 03:48:51 +00:00
static
[vulkan] Implement most of the changes for cube rendering There are some missing parts from this commit as these are the fairly clean changes. Missing is building a separate set of pipelines for the new render pass (might be able to get away from that), OIT heads texture is flat rather than an array, view matrices aren't set up, and the fisheye renderer isn't hooked up to the output pass (code exists but is messy). However, with the missing parts included, testing shows things mostly working: the cube map is rendered correctly even though it's not displayed correctly (incorrect view). This has definitely proven to be a good test for Vulkan's multiview feature (very nice).
2023-01-23 02:14:06 +00:00
#include "libs/video/renderer/vulkan/shader/fisheye.frag.spvc"
static
[vulkan] Create a water warp output pipeline Although it works as intended (tested via hacking), it's not hooked up as the current frame buffer handling in r_screen is not readily compatible with how vulkan output is handled. This will need some thought to get working.
2022-11-27 03:48:51 +00:00
#include "libs/video/renderer/vulkan/shader/waterwarp.frag.spvc"
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
typedef struct shaderdata_s {
const char *name;
const uint32_t *data;
size_t size;
} shaderdata_t;
static shaderdata_t builtin_shaders[] = {
[vulkan] Add support for 9-slice rendering There's no API yet as I need to look into the handling of qpic_t before I can get any of this into the other renderers (or even vulkan, for that matter). However, the current design for slice rendering is based on glyphs (ie, using instances and vertex pulling), with 3 strips of 3 quads, 16 verts, and 26 indices (2 reset). Hacky testing seems to work, but real tests need the API.
2022-11-18 00:44:01 +00:00
{ "slice.vert", slice_vert, sizeof (slice_vert) },
[vullkan] Rework Draw implementation Line rendering now has its own pipeline (removing the texture issue). Glyph rendering (for fonts) has been reworked to use instanced quad rendering, with the geometry (position and texture coords) in a static buffer (uniform texture buffer), and each instance has a glyph index, color, and 2d base position. Multiple fonts can be loaded, but aren't used yet: still just the one (work needs to be done on the queues to support multiple textures/fonts). Quads haven't changed much, but buffer creation and destruction has been cleaned up to use the resource functions.
2022-10-03 01:29:49 +00:00
{ "line.vert", line_vert, sizeof (line_vert) },
{ "line.frag", line_frag, sizeof (line_frag) },
[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
{ "particle.vert", particle_vert, sizeof (particle_vert) },
{ "particle.geom", particle_geom, sizeof (particle_geom) },
{ "particle.frag", particle_frag, sizeof (particle_frag) },
{ "partphysics.comp", partphysics_comp, sizeof (partphysics_comp) },
{ "partupdate.comp", partupdate_comp, sizeof (partupdate_comp) },
[vulkan] Create the non-C side of the sprite pipeline This adds the shaders and the pipeline specs. I'm not sure that the deferred rendering side of the render pass is appropriate, but I thought I'd give it a go, since quake sprites are really cutoff rather than translucent.
2021-12-14 05:44:16 +00:00
{ "sprite_gbuf.vert", sprite_gbuf_vert, sizeof (sprite_gbuf_vert) },
{ "sprite_gbuf.frag", sprite_gbuf_frag, sizeof (sprite_gbuf_frag) },
{ "sprite_depth.vert", sprite_depth_vert, sizeof (sprite_depth_vert) },
{ "sprite_depth.frag", sprite_depth_frag, sizeof (sprite_depth_frag) },
[vulkan] Do a depth pass for 2d objects While the HUD and status bar don't cut out a lot of screen (normally), they might start to make a difference when I get transparency working properly. The main thing is this is a step towards pulling the 2d rendering into another render pass so the main deferred pass is world-only.
2022-11-20 17:29:03 +00:00
{ "twod_depth.frag", twod_depth_frag, sizeof (twod_depth_frag) },
[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
{ "twod.vert", twod_vert, sizeof (twod_vert) },
{ "twod.frag", twod_frag, sizeof (twod_frag) },
[vulkan] Create shanders for brush models The fragment shader is a bit of a mini mega-shader, but I do want to try out specializations.
2021-01-18 08:13:52 +00:00
{ "quakebsp.vert", quakebsp_vert, sizeof (quakebsp_vert) },
{ "quakebsp.frag", quakebsp_frag, sizeof (quakebsp_frag) },
[vulkan] Convert bsp and draw to deferred This has bsp and draw passing muster with the validation layers.
2021-02-19 02:14:54 +00:00
{ "bsp_depth.vert", bsp_depth_vert, sizeof (bsp_depth_vert) },
{ "bsp_gbuf.vert", bsp_gbuf_vert, sizeof (bsp_gbuf_vert) },
{ "bsp_gbuf.geom", bsp_gbuf_geom, sizeof (bsp_gbuf_geom) },
{ "bsp_gbuf.frag", bsp_gbuf_frag, sizeof (bsp_gbuf_frag) },
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
{ "bsp_shadow.vert", bsp_shadow_vert, sizeof (bsp_shadow_vert) },
[vulkan] Fix up commands for deferred rendering Nothing gets output yet (lighting and composite passes not implemented), but everything passes validation until exit (not destroying everything).
2021-02-23 06:43:02 +00:00
{ "bsp_sky.frag", bsp_sky_frag, sizeof (bsp_sky_frag) },
[vulkan] Implement water surface rendering They're unlit (fullbright, but that's nothing new for quake), but working nicely. As a bonus, sort out the sky pass (forced to due to the way command buffers are used).
2021-03-23 03:24:24 +00:00
{ "bsp_turb.frag", bsp_turb_frag, sizeof (bsp_turb_frag) },
[vulkan] Rework lighting to use splats It's currently slower, and the cone splats are buggy, but the lighting code itself got some nice cleanups.
2023-06-27 16:01:56 +00:00
{ "light_flat.vert", light_flat_vert, sizeof (light_flat_vert) },
{ "light_splat.vert", light_splat_vert, sizeof (light_splat_vert) },
[vulkan] Add debug lines for light splats Disabled, but all that's needed is to uncomment the debug pipeline in the compose subpass.
2023-06-28 02:47:26 +00:00
{ "light_debug.frag", light_debug_frag, sizeof (light_debug_frag) },
[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
{ "lighting.frag", lighting_frag, sizeof (lighting_frag) },
{ "compose.frag", compose_frag, sizeof (compose_frag) },
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
{ "alias.vert", alias_vert, sizeof (alias_vert) },
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
{ "alias_depth.vert", alias_depth_vert, sizeof (alias_depth_vert) },
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
{ "alias.frag", alias_frag, sizeof (alias_frag) },
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
{ "alias_gbuf.frag", alias_gbuf_frag, sizeof (alias_gbuf_frag) },
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
{ "alias_shadow.vert", alias_shadow_vert, sizeof (alias_shadow_vert) },
[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
{ "iqm.vert", iqm_vert, sizeof (iqm_vert) },
{ "iqm.frag", iqm_frag, sizeof (iqm_frag) },
[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
{ "output.frag", output_frag, sizeof (output_frag) },
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
{ "passthrough.vert", passthrough_vert, sizeof (passthrough_vert) },
[vulkan] Switch to full screen triangle instead of quad While I have trouble imagining it making that much performance difference going from 4 verts to 3 for a whopping 2 polygons, or even from 2 triangles to 1 for each poly, using only indices for the vertices does remove a lot of code, and better yet, some memory and buffer allocations... always a good thing. That said, I guess freeing up a GPU thread for something else could make a difference.
2022-04-01 10:50:41 +00:00
{ "fstriangle.vert", fstriangle_vert, sizeof (fstriangle_vert) },
[vulkan] Create a water warp output pipeline Although it works as intended (tested via hacking), it's not hooked up as the current frame buffer handling in r_screen is not readily compatible with how vulkan output is handled. This will need some thought to get working.
2022-11-27 03:48:51 +00:00
{ "fstrianglest.vert", fstrianglest_vert, sizeof (fstrianglest_vert) },
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
{ "pushcolor.frag", pushcolor_frag, sizeof (pushcolor_frag) },
[vulkan] Implement most of the changes for cube rendering There are some missing parts from this commit as these are the fairly clean changes. Missing is building a separate set of pipelines for the new render pass (might be able to get away from that), OIT heads texture is flat rather than an array, view matrices aren't set up, and the fisheye renderer isn't hooked up to the output pass (code exists but is messy). However, with the missing parts included, testing shows things mostly working: the cube map is rendered correctly even though it's not displayed correctly (incorrect view). This has definitely proven to be a good test for Vulkan's multiview feature (very nice).
2023-01-23 02:14:06 +00:00
{ "fisheye.frag", fisheye_frag, sizeof (fisheye_frag) },
[vulkan] Create a water warp output pipeline Although it works as intended (tested via hacking), it's not hooked up as the current frame buffer handling in r_screen is not readily compatible with how vulkan output is handled. This will need some thought to get working.
2022-11-27 03:48:51 +00:00
{ "waterwarp.frag", waterwarp_frag, sizeof (waterwarp_frag) },
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
{}
};
#define BUILTIN "$builtin/"
#define BUILTIN_SIZE (sizeof (BUILTIN) - 1)
#define SHADER "$shader/"
#define SHADER_SIZE (sizeof (SHADER) - 1)
VkShaderModule
QFV_CreateShaderModule (qfv_device_t *device, const char *shader_path)
{
VkDevice dev = device->dev;
qfv_devfuncs_t *dfunc = device->funcs;
shaderdata_t _data = {};
shaderdata_t *data = 0;
dstring_t *path = 0;
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
QFile *file = 0;
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
VkShaderModule shader = 0;
if (strncmp (shader_path, BUILTIN, BUILTIN_SIZE) == 0) {
const char *name = shader_path + BUILTIN_SIZE;
for (int i = 0; builtin_shaders[i].name; i++) {
if (strcmp (builtin_shaders[i].name, name) == 0) {
data = &builtin_shaders[i];
break;
}
}
} else if (strncmp (shader_path, SHADER, SHADER_SIZE)) {
path = dstring_new ();
dsprintf (path, "%s/%s", FS_SHADERPATH, shader_path + SHADER_SIZE);
file = Qopen (path->str, "rbz");
} else {
file = QFS_FOpenFile (shader_path);
}
if (file) {
_data.size = Qfilesize (file);
_data.data = malloc (_data.size);
Qread (file, (void *) _data.data, _data.size);
Qclose (file);
data = &_data;
}
if (data) {
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_vulkan,
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
"QFV_CreateShaderModule: creating shader module %s\n",
shader_path);
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
VkShaderModuleCreateInfo createInfo = {
VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, 0,
0, data->size, data->data
};
dfunc->vkCreateShaderModule (dev, &createInfo, 0, &shader);
[vulkan] Name some more objects Shaders and descriptor set layouts.
2021-04-19 08:49:03 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_SHADER_MODULE, shader,
shader_path);
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
} else {
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_vulkan,
[vulkan] Add support for building and loading shaders Shaders can be built as spv files and installed into $libdir/quakeforge/shaders or as spvc files and compiled into the engine. Loading supports $builtin/name to access builtin shaders, $shader/path to access external standard shaders and quake filesystem access for all other paths.
2020-12-23 05:32:29 +00:00
"QFV_CreateShaderModule: could not find shader %s\n",
shader_path);
}
if (path) {
dstring_delete (path);
}
if (_data.data) {
free ((void *) _data.data);
}
return shader;
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
void
QFV_DestroyShaderModule (qfv_device_t *device, VkShaderModule module)
{
VkDevice dev = device->dev;
qfv_devfuncs_t *dfunc = device->funcs;
dfunc->vkDestroyShaderModule (dev, module, 0);
}
Reference in a new issue Copy permalink