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

1349 lines
40 KiB
C
Raw Normal View History

[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.c
Vulkan bsp
Copyright (C) 2012 Bill Currie <bill@taniwha.org>
Copyright (C) 2021 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2012/1/7
Date: 2021/1/18
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
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <stdlib.h>
#include "qfalloca.h"
#include "QF/cvar.h"
#include "QF/darray.h"
#include "QF/image.h"
#include "QF/render.h"
#include "QF/sys.h"
#include "QF/va.h"
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
#include "QF/scene/entity.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"
#include "QF/Vulkan/qf_lightmap.h"
[vulkan] Switch bsp renderer to multi-texture I guess it's not quite bindless as the texture index is a push constant, but it seems to work well (and I may have fixed some full-bright issues by accident, though I suspect that's just my imagination, but they do look good).
2021-12-08 12:11:36 +00:00
#include "QF/Vulkan/qf_matrices.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_texture.h"
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
#include "QF/Vulkan/buffer.h"
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
#include "QF/Vulkan/barrier.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/command.h"
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
#include "QF/Vulkan/debug.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/descriptor.h"
#include "QF/Vulkan/device.h"
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
#include "QF/Vulkan/image.h"
[vulkan] Get wall rendering partially working Many surfaces are missing (I suspect it's due to transform stage management in the index emitter), and currently only the light maps are rendered (still not binding the correct textures), but the basics are working.
2021-01-21 17:20:32 +00:00
#include "QF/Vulkan/instance.h"
[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
#include "QF/Vulkan/renderpass.h"
[vulkan] Rename texture.c to scrap.c I had originally planned on mixing the stage management with general texture support code like I did in glsl, but I think that was a mistake and I did keep looking for scrap.[ch] when I wanted to edit something to do with the scrap...
2021-01-21 07:39:11 +00:00
#include "QF/Vulkan/scrap.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/staging.h"
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
#include "QF/simd/types.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 "r_internal.h"
#include "vid_vulkan.h"
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
typedef struct bsp_push_constants_s {
mat4f_t Model;
quat_t fog;
float time;
[vulkan] Implement water alpha I'm not sure it's working properly, but that compose pass is suspect, especially with respect to lighting.
2022-05-21 08:48:45 +00:00
float alpha;
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
} bsp_push_constants_t;
[vulkan] Fix some 32-bit compatibility issues mostly dealing with vulkan's handles always being 64-bit, but pointers being either 32 or 64.
2021-04-01 23:48:11 +00:00
static const char * __attribute__((used)) bsp_pass_names[] = {
[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
"depth",
"g-buffer",
[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
"sky",
"turb",
[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] Use correct vertex shader for skys This gets skys rendering again, but their depth is incorrect.
2021-03-22 23:25:56 +00:00
static QFV_Subpass subpass_map[] = {
QFV_passDepth, // QFV_bspDepth
QFV_passGBuffer, // QFV_bspGBuffer
[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
QFV_passTranslucent, // QFV_bspSky
QFV_passTranslucent, // QFV_bspTurb
[vulkan] Use correct vertex shader for skys This gets skys rendering again, but their depth is incorrect.
2021-03-22 23:25:56 +00:00
};
[vulkan] Reset model transform for world surfaces Fixes the misplaced walls.
2021-01-21 17:42:58 +00:00
static float identity[] = {
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1,
};
[model] Initialize r_notexture_mip in the right places That being in the renderer. This is why qwaq needed that call to Mod_ProcessTexture (but no longer does :)
2022-05-05 12:22:44 +00:00
static vulktex_t vulkan_notexture = { };
[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
#define ALLOC_CHUNK 64
static void
add_texture (texture_t *tx, vulkan_ctx_t *ctx)
{
bspctx_t *bctx = ctx->bsp_context;
vulktex_t *tex = tx->render;
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
if (tex->tex) {
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
tex->tex_id = bctx->registered_textures.size;
DARRAY_APPEND (&bctx->registered_textures, tex);
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
tex->descriptor = Vulkan_CreateTextureDescriptor (ctx, tex->tex,
bctx->sampler);
}
[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
}
void
Vulkan_ClearElements (vulkan_ctx_t *ctx)
{
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
// bspctx_t *bctx = ctx->bsp_context;
[vulkan] Make a lot of progress for brush models Light maps are maybe updating, but as nothing is actually rendered yet, it's hard to tell.
2021-01-19 16:25:54 +00:00
}
static inline void
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
chain_surface (const bsp_face_t *face, bsp_pass_t *pass, bspctx_t *bctx)
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
DARRAY_APPEND (&pass->face_queue[face->tex_id],
((instface_t) { bctx->inst_id, face - bctx->faces }));
[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
}
static void
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
register_textures (mod_brush_t *brush, vulkan_ctx_t *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
{
texture_t *tex;
[util] Make bsp_t counts size_t and other bsp data counts unsigned, and clean up the resulting mess.
2021-08-01 12:54:05 +00:00
for (unsigned i = 0; i < brush->numtextures; i++) {
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
tex = brush->textures[i];
[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
if (!tex)
continue;
add_texture (tex, ctx);
}
}
static void
clear_textures (vulkan_ctx_t *ctx)
{
bspctx_t *bctx = ctx->bsp_context;
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
if (bctx->main_pass.face_queue) {
for (size_t i = 0; i < bctx->registered_textures.size; i++) {
DARRAY_CLEAR (&bctx->main_pass.face_queue[i]);
}
free (bctx->main_pass.face_queue);
bctx->main_pass.face_queue = 0;
}
bctx->registered_textures.size = 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
}
void
Vulkan_RegisterTextures (model_t **models, int num_models, vulkan_ctx_t *ctx)
{
int i;
model_t *m;
[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
mod_brush_t *brush = &r_refdef.worldmodel->brush;
[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
clear_textures (ctx);
add_texture (r_notexture_mip, ctx);
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
register_textures (brush, 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
for (i = 0; i < num_models; i++) {
m = models[i];
if (!m)
continue;
// sub-models are done as part of the main model
[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
if (*m->path == '*')
[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
continue;
// world has already been done, not interested in non-brush models
[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
if (m == r_refdef.worldmodel || m->type != mod_brush)
[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
continue;
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
brush = &m->brush;
brush->numsubmodels = 1; // no support for submodels in non-world model
register_textures (brush, 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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
bspctx_t *bctx = ctx->bsp_context;
int num_tex = bctx->registered_textures.size;
bctx->main_pass.face_queue = malloc (num_tex * sizeof (bsp_instfaceset_t));
for (int i = 0; i < num_tex; i++) {
bctx->main_pass.face_queue[i]
= (bsp_instfaceset_t) DARRAY_STATIC_INIT (128);
}
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
typedef struct {
msurface_t *face;
model_t *model;
int model_face_base;
} faceref_t;
typedef struct DARRAY_TYPE (faceref_t) facerefset_t;
[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
static void
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
count_verts_inds (faceref_t *faceref, uint32_t *verts, uint32_t *inds)
[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
{
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
msurface_t *surf = faceref->face;
[renderer] Be more consistent with msurface_t names Use "surf" everywhere in gl, glsl and vulkan. Not worried about sw/sw32 at this stage (I don't poke around in there anywhere near as much).
2021-07-15 12:38:12 +00:00
*verts = surf->numedges;
*inds = surf->numedges + 1;
[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
}
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
typedef struct {
bsp_face_t *faces;
uint32_t *indices;
bspvert_t *vertices;
uint32_t index_base;
uint32_t vertex_base;
int tex_id;
} buildctx_t;
static void
build_surf_displist (faceref_t *faceref, buildctx_t *build)
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
msurface_t *surf = faceref->face;
mod_brush_t *brush = &faceref->model->brush;;
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
int facenum = surf - brush->surfaces;
bsp_face_t *face = &build->faces[facenum + faceref->model_face_base];
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
// create a triangle fan
int numverts = surf->numedges;
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
face->first_index = build->index_base;
face->index_count = numverts + 1; // +1 for primitive restart
face->tex_id = build->tex_id;
face->flags = surf->flags;
build->index_base += face->index_count;
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
for (int i = 0; i < numverts; i++) {
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
build->indices[face->first_index + i] = build->vertex_base + i;
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
build->indices[face->first_index + numverts] = -1; // primitive restart
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
bspvert_t *verts = build->vertices + build->vertex_base;
build->vertex_base += numverts;
[renderer] Be more consistent with msurface_t names Use "surf" everywhere in gl, glsl and vulkan. Not worried about sw/sw32 at this stage (I don't poke around in there anywhere near as much).
2021-07-15 12:38:12 +00:00
mtexinfo_t *texinfo = surf->texinfo;
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
mvertex_t *vertices = brush->vertexes;
medge_t *edges = brush->edges;
int *surfedges = brush->surfedges;
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
for (int i = 0; i < numverts; i++) {
vec_t *vec;
int index = surfedges[surf->firstedge + i];
[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
if (index > 0) {
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
// forward edge
[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
vec = vertices[edges[index].v[0]].position;
[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
} else {
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
// reverse edge
[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
vec = vertices[edges[-index].v[1]].position;
[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
}
[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
VectorCopy (vec, verts[i].vertex);
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
verts[i].vertex[3] = 1; // homogeneous coord
vec2f_t st = {
DotProduct (vec, texinfo->vecs[0]) + texinfo->vecs[0][3],
DotProduct (vec, texinfo->vecs[1]) + texinfo->vecs[1][3],
};
verts[i].tlst[0] = st[0] / texinfo->texture->width;
verts[i].tlst[1] = st[1] / texinfo->texture->height;
if (surf->lightpic) {
//lightmap texture coordinates
//every lit surface has its own lighmap at a 1/16 resolution
//(ie, 16 albedo pixels for every lightmap pixel)
const vrect_t *rect = surf->lightpic->rect;
vec2f_t lmorg = (vec2f_t) { VEC2_EXP (&rect->x) } * 16 + 8;
vec2f_t texorg = { VEC2_EXP (surf->texturemins) };
st = ((st - texorg + lmorg) / 16) * surf->lightpic->size;
verts[i].tlst[2] = st[0];
verts[i].tlst[3] = st[1];
} else {
// no lightmap for this surface (probably sky or water), so
// make the lightmap texture polygone degenerate
[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
verts[i].tlst[2] = 0;
verts[i].tlst[3] = 0;
}
}
}
void
Vulkan_BuildDisplayLists (model_t **models, int num_models, vulkan_ctx_t *ctx)
{
[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
qfv_device_t *device = ctx->device;
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
qfv_devfuncs_t *dfunc = device->funcs;
[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
bspctx_t *bctx = ctx->bsp_context;
[vulkan] Cope with an empty world model Vulkan doesn't appreciate the empty buffers that result from the model not having any textures or surfaces that can be rendered (rightfully so, for such a bare-metal api).
2022-04-25 22:26:32 +00:00
if (!num_models) {
return;
}
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
facerefset_t *face_sets = alloca (bctx->registered_textures.size
* sizeof (facerefset_t));
for (size_t i = 0; i < bctx->registered_textures.size; i++) {
face_sets[i] = (facerefset_t) DARRAY_STATIC_INIT (1024);
}
[vulkan] Clean up and document some of the bsp code Getting close to understanding (again) how it all works. I only just barely understood when I got vulkan's renderer running, but I really need to understand for when I modify things for shadows. The main thing hurdle was tinst, but that was dealt with in the previous commit, and now it's just sorting out the mess of elechains and elementss.
2021-07-13 13:59:51 +00:00
// run through all surfaces, chaining them to their textures, thus
[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
// effectively sorting the surfaces by texture (without worrying about
// surface order on the same texture chain).
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
int face_base = 0;
[util] Make bsp_t counts size_t and other bsp data counts unsigned, and clean up the resulting mess.
2021-08-01 12:54:05 +00:00
for (int i = 0; i < num_models; i++) {
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
model_t *m = models[i];
[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
// sub-models are done as part of the main model
[vulkan] Clean up and document some of the bsp code Getting close to understanding (again) how it all works. I only just barely understood when I got vulkan's renderer running, but I really need to understand for when I modify things for shadows. The main thing hurdle was tinst, but that was dealt with in the previous commit, and now it's just sorting out the mess of elechains and elementss.
2021-07-13 13:59:51 +00:00
// and non-bsp models don't have surfaces.
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
if (!m || *m->path == '*' || m->type != mod_brush)
[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
continue;
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
mod_brush_t *brush = &m->brush;
dmodel_t *dm = brush->submodels;
[util] Make bsp_t counts size_t and other bsp data counts unsigned, and clean up the resulting mess.
2021-08-01 12:54:05 +00:00
for (unsigned j = 0; j < brush->numsurfaces; j++) {
[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
if (j == dm->firstface + dm->numfaces) {
[vulkan] Clean up and document some of the bsp code Getting close to understanding (again) how it all works. I only just barely understood when I got vulkan's renderer running, but I really need to understand for when I modify things for shadows. The main thing hurdle was tinst, but that was dealt with in the previous commit, and now it's just sorting out the mess of elechains and elementss.
2021-07-13 13:59:51 +00:00
// move on to the next sub-model
[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
dm++;
[build] Fix some windows bitrot
2021-08-02 05:02:41 +00:00
if (dm == brush->submodels + brush->numsubmodels) {
[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
// limit the surfaces
// probably never hit
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
Sys_Printf ("Vulkan_BuildDisplayLists: too many faces\n");
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
brush->numsurfaces = j;
[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
break;
}
}
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
msurface_t *surf = brush->surfaces + j;
[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
// append surf to the texture chain
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
vulktex_t *tex = surf->texinfo->texture->render;
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
DARRAY_APPEND (&face_sets[tex->tex_id],
((faceref_t) { surf, m, face_base }));
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
face_base += brush->numsurfaces;
[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
}
// All vertices from all brush models go into one giant vbo.
[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
uint32_t vertex_count = 0;
uint32_t index_count = 0;
uint32_t poly_count = 0;
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
// This is not optimal as counted vertices are not shared between faces,
// however this greatly simplifies display list creation as no care needs
// to be taken when it comes to UVs, and every vertex needs a unique light
// map UV anyway (when lightmaps are used).
for (size_t i = 0; i < bctx->registered_textures.size; i++) {
for (size_t j = 0; j < face_sets[i].size; j++) {
faceref_t *faceref = &face_sets[i].a[j];
[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
uint32_t verts, inds;
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
count_verts_inds (faceref, &verts, &inds);
[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
vertex_count += verts;
index_count += inds;
poly_count++;
}
}
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
[vulkan] Get wall rendering partially working Many surfaces are missing (I suspect it's due to transform stage management in the index emitter), and currently only the light maps are rendered (still not binding the correct textures), but the basics are working.
2021-01-21 17:20:32 +00:00
size_t atom = device->physDev->properties.limits.nonCoherentAtomSize;
size_t atom_mask = atom - 1;
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
size_t frames = bctx->frames.size;
size_t index_buffer_size = index_count * frames * sizeof (uint32_t);
size_t vertex_buffer_size = vertex_count * sizeof (bspvert_t);
[vulkan] Get wall rendering partially working Many surfaces are missing (I suspect it's due to transform stage management in the index emitter), and currently only the light maps are rendered (still not binding the correct textures), but the basics are working.
2021-01-21 17:20:32 +00:00
index_buffer_size = (index_buffer_size + atom_mask) & ~atom_mask;
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
qfv_stagebuf_t *stage = QFV_CreateStagingBuffer (device, "bsp",
vertex_buffer_size,
ctx->cmdpool);
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
qfv_packet_t *packet = QFV_PacketAcquire (stage);
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
bspvert_t *vertices = QFV_PacketExtend (packet, vertex_buffer_size);
// holds all the polygon definitions: vertex indices + poly_count
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
// primitive restart markers. The primitive restart markers are included
// in index_count.
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
// so each polygon within the list:
// index count-1 indices
// index
// ...
// "end of primitive" (~0u)
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
free (bctx->faces);
free (bctx->poly_indices);
bctx->faces = malloc (face_base * sizeof (bsp_face_t));
bctx->poly_indices = malloc (index_count * sizeof (uint32_t));
[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
[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
// All usable surfaces have been chained to the (base) texture they use.
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
// Run through the textures, using their chains to build display lists.
[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
// For animated textures, if a surface is on one texture of the group, it
[vulkan] Clean up display list building and add some comments Some very much needed comments :P Still, nicely, I now have a much better understanding of how the display lists are created (10 years is a long time to remember how intricate code works (I do remember fighting to get it working back then))
2022-05-11 10:24:39 +00:00
// will effectively be on all (just one at a time).
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
buildctx_t build = {
.faces = bctx->faces,
.indices = bctx->poly_indices,
.vertices = vertices,
.index_base = 0,
.vertex_base = 0,
};
for (size_t i = 0; i < bctx->registered_textures.size; i++) {
build.tex_id = i;
for (size_t j = 0; j < face_sets[i].size; j++) {
faceref_t *faceref = &face_sets[i].a[j];
build_surf_displist (faceref, &build);
[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
}
}
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
"R_BuildDisplayLists: verts:%u, inds:%u, polys:%u\n",
vertex_count, index_count, poly_count);
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
if (index_buffer_size > bctx->index_buffer_size) {
if (bctx->index_buffer) {
dfunc->vkUnmapMemory (device->dev, bctx->index_memory);
dfunc->vkDestroyBuffer (device->dev, bctx->index_buffer, 0);
dfunc->vkFreeMemory (device->dev, bctx->index_memory, 0);
}
bctx->index_buffer
= QFV_CreateBuffer (device, index_buffer_size,
VK_BUFFER_USAGE_TRANSFER_DST_BIT
[vulkan] Bind the bsp main pipeline No drawing commands are issued yet, but vulkan seems to be happy with the state.
2021-01-20 07:51:35 +00:00
| VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_BUFFER, bctx->index_buffer,
"buffer:bsp:index");
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
bctx->index_memory
= QFV_AllocBufferMemory (device, bctx->index_buffer,
[vulkan] Use cached memory for the bsp index buffer Since it is updated every frame, it needs to be as fast as possible for the cpu code. This seems to make a difference of about 10us (~130 -> ~120) when testing in marcher. Not a huge change, but the timing calculation was wrapped around the entire base world pass, so there was a fair bit of overhead from bsp traversal etc.
2022-04-06 05:40:40 +00:00
VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
index_buffer_size, 0);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_DEVICE_MEMORY,
bctx->index_memory, "memory:bsp:index");
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
QFV_BindBufferMemory (device,
bctx->index_buffer, bctx->index_memory, 0);
bctx->index_buffer_size = index_buffer_size;
void *data;
dfunc->vkMapMemory (device->dev, bctx->index_memory, 0,
index_buffer_size, 0, &data);
uint32_t *index_data = data;
for (size_t i = 0; i < frames; i++) {
[vulkan] Bind the bsp main pipeline No drawing commands are issued yet, but vulkan seems to be happy with the state.
2021-01-20 07:51:35 +00:00
uint32_t offset = index_count * i;
bctx->frames.a[i].index_data = index_data + offset;
bctx->frames.a[i].index_offset = offset * sizeof (uint32_t);
[vulkan] Fix the bsp vertex index list creation There's still a problem with the vertex data itself not getting sent to the GPU properly, but vulkan is now happy with my tiny test map (which required disabling skies entirely until I get null textures working).
2021-01-21 05:37:39 +00:00
bctx->frames.a[i].index_count = 0;
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
}
}
if (vertex_buffer_size > bctx->vertex_buffer_size) {
if (bctx->vertex_buffer) {
dfunc->vkDestroyBuffer (device->dev, bctx->vertex_buffer, 0);
dfunc->vkFreeMemory (device->dev, bctx->vertex_memory, 0);
}
bctx->vertex_buffer
= QFV_CreateBuffer (device, vertex_buffer_size,
VK_BUFFER_USAGE_TRANSFER_DST_BIT
| VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_BUFFER,
bctx->vertex_buffer, "buffer:bsp:vertex");
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
bctx->vertex_memory
= QFV_AllocBufferMemory (device, bctx->vertex_buffer,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
vertex_buffer_size, 0);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_DEVICE_MEMORY,
bctx->vertex_memory, "memory:bsp:vertex");
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
QFV_BindBufferMemory (device,
bctx->vertex_buffer, bctx->vertex_memory, 0);
bctx->vertex_buffer_size = vertex_buffer_size;
}
[vulkan] Clean up buffer barriers a bit This even fixes a couple of minor issues that snuck past validation.
2021-04-24 06:47:31 +00:00
qfv_bufferbarrier_t bb = bufferBarriers[qfv_BB_Unknown_to_TransferWrite];
bb.barrier.buffer = bctx->vertex_buffer;
bb.barrier.size = vertex_buffer_size;
dfunc->vkCmdPipelineBarrier (packet->cmd, bb.srcStages, bb.dstStages,
0, 0, 0, 1, &bb.barrier, 0, 0);
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
VkBufferCopy copy_region = { packet->offset, 0, vertex_buffer_size };
[vulkan] Fix a pile of data upload issues Copying data from the wrong buffer was the cause of the corrupted brush model vertices, and then lots of little errors (mostly forgetting to multiply by bpp) for textures.
2021-01-21 12:24:54 +00:00
dfunc->vkCmdCopyBuffer (packet->cmd, stage->buffer,
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
bctx->vertex_buffer, 1, &copy_region);
[vulkan] Clean up buffer barriers a bit This even fixes a couple of minor issues that snuck past validation.
2021-04-24 06:47:31 +00:00
bb = bufferBarriers[qfv_BB_TransferWrite_to_VertexAttrRead];
bb.barrier.buffer = bctx->vertex_buffer;
bb.barrier.size = vertex_buffer_size;
dfunc->vkCmdPipelineBarrier (packet->cmd, bb.srcStages, bb.dstStages,
0, 0, 0, 1, &bb.barrier, 0, 0);
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
QFV_PacketSubmit (packet);
[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
QFV_DestroyStagingBuffer (stage);
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
for (size_t i = 0; i < bctx->registered_textures.size; i++) {
DARRAY_CLEAR (&face_sets[i]);
}
[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
}
static void
R_DrawBrushModel (entity_t *e, vulkan_ctx_t *ctx)
{
float dot, radius;
model_t *model;
plane_t *plane;
msurface_t *surf;
qboolean rotated;
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
vec3_t mins, maxs;
vec4f_t org;
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
mod_brush_t *brush;
[renderer] Remove currententity from non-sw renderers Really needed only for vulkan, but removing currententity from gl and glsl made testing easier.
2021-07-22 06:39:28 +00:00
bspctx_t *bctx = ctx->bsp_context;
bctx->entity = e;
bctx->transform = e->renderer.full_transform;
bctx->color = e->renderer.colormod;
[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
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
model = e->renderer.model;
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
brush = &model->brush;
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
mat4f_t mat;
Transform_GetWorldMatrix (e->transform, mat);
memcpy (e->renderer.full_transform, mat, sizeof (mat));//FIXME
if (mat[0][0] != 1 || mat[1][1] != 1 || mat[2][2] != 1) {
[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
rotated = true;
radius = model->radius;
Update vec3_t/vec4f_t hacks to work with clang Still work with gcc, of course, and I still need to fix them properly, but now they're actually slightly easier to find as they all have vec_t and FIXME on the same line.
2022-03-30 15:07:20 +00:00
if (R_CullSphere (r_refdef.frustum, (vec_t*)&mat[3], radius)) { //FIXME
[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
return;
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
}
[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
} else {
rotated = false;
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
VectorAdd (mat[3], model->mins, mins);
VectorAdd (mat[3], model->maxs, maxs);
[mathlib] Remove frustum global It should never have been there and is now in the refdef (not its final home: it should probably be part of the camera).
2022-03-19 03:33:12 +00:00
if (R_CullBox (r_refdef.frustum, mins, maxs))
[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
return;
}
[renderer] Clean up use of vup/vright/vpn This moves the common camera setup code out of the individual drivers, and completely removes vup/vright/vpn from the non-software renderers. This has highlighted the craziness around AngleVectors with it putting +X forward, -Y right and +Z up. The main issue with this is it requires a 90 degree pre-rotation about the Z axis to get the camera pointing in the right direction, and that's for the native sw renderer (vulkan needs a 90 degree pre-rotation about X, and gl and glsl need to invert an axis, too), though at least it's just a matrix swizzle and vector negation. However, it does mean the camera matrices can't be used directly. Also rename vpn to vfwd (still abbreviated, but fwd is much clearer in meaning (to me, at least) than pn (plane normal, I guess, but which way?)).
2022-03-14 00:34:24 +00:00
org = r_refdef.frame.position - mat[3];
[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
if (rotated) {
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
vec4f_t temp = org;
[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
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
org[0] = DotProduct (temp, mat[0]);
org[1] = DotProduct (temp, mat[1]);
org[2] = DotProduct (temp, mat[2]);
[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
}
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
surf = &brush->surfaces[brush->firstmodelsurface];
[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
[util] Make bsp_t counts size_t and other bsp data counts unsigned, and clean up the resulting mess.
2021-08-01 12:54:05 +00:00
for (unsigned i = 0; i < brush->nummodelsurfaces; i++, surf++) {
[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
// find the node side on which we are
plane = surf->plane;
dot = PlaneDiff (org, plane);
// enqueue the polygon
if (((surf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON))
|| (!(surf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON))) {
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
//chain_surface (surf, 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
}
}
}
static inline void
visit_leaf (mleaf_t *leaf)
{
[glsl,vulkan] More comments in the bsp code And maybe a nano-optimization. Switching from (~side + 1) to (-side) seems to give glsl a very tiny speed boost, but certainly doesn't hurt. Looking at some assembly output for the three cases, the two hacks seem to generate the same code as each other, but 3 instructions vs 6 for ?:. While ?: is more generically robust, the hacks are tuned for the knowledge side is either 0 or 1. The later xor might alter things, but at least I now know that the hack (either version) is worthwhile.
2022-05-13 13:00:03 +00:00
// since this leaf will be rendered, any entities in the leaf also need
// to be rendered (the bsp tree doubles as an entity cull structure)
[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
if (leaf->efrags)
R_StoreEfrags (leaf->efrags);
}
[glsl,vulkan] More comments in the bsp code And maybe a nano-optimization. Switching from (~side + 1) to (-side) seems to give glsl a very tiny speed boost, but certainly doesn't hurt. Looking at some assembly output for the three cases, the two hacks seem to generate the same code as each other, but 3 instructions vs 6 for ?:. While ?: is more generically robust, the hacks are tuned for the knowledge side is either 0 or 1. The later xor might alter things, but at least I now know that the hack (either version) is worthwhile.
2022-05-13 13:00:03 +00:00
// 1 = back side, 0 = front side
[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
static inline int
get_side (mnode_t *node)
{
// find the node side on which we are
[renderer] Clean up use of vup/vright/vpn This moves the common camera setup code out of the individual drivers, and completely removes vup/vright/vpn from the non-software renderers. This has highlighted the craziness around AngleVectors with it putting +X forward, -Y right and +Z up. The main issue with this is it requires a 90 degree pre-rotation about the Z axis to get the camera pointing in the right direction, and that's for the native sw renderer (vulkan needs a 90 degree pre-rotation about X, and gl and glsl need to invert an axis, too), though at least it's just a matrix swizzle and vector negation. However, it does mean the camera matrices can't be used directly. Also rename vpn to vfwd (still abbreviated, but fwd is much clearer in meaning (to me, at least) than pn (plane normal, I guess, but which way?)).
2022-03-14 00:34:24 +00:00
vec4f_t org = r_refdef.frame.position;
[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
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
return dotf (org, node->plane)[0] < 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
}
static inline void
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
visit_node (mod_brush_t *brush, mnode_t *node, int side, vulkan_ctx_t *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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
bspctx_t *bctx = ctx->bsp_context;
bsp_pass_t *pass = &ctx->bsp_context->main_pass;
[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
int c;
// sneaky hack for side = side ? SURF_PLANEBACK : 0;
[glsl,vulkan] More comments in the bsp code And maybe a nano-optimization. Switching from (~side + 1) to (-side) seems to give glsl a very tiny speed boost, but certainly doesn't hurt. Looking at some assembly output for the three cases, the two hacks seem to generate the same code as each other, but 3 instructions vs 6 for ?:. While ?: is more generically robust, the hacks are tuned for the knowledge side is either 0 or 1. The later xor might alter things, but at least I now know that the hack (either version) is worthwhile.
2022-05-13 13:00:03 +00:00
// seems to be microscopically faster even on modern hardware
side = (-side) & SURF_PLANEBACK;
// chain any visible surfaces on the node that face the camera.
// not all nodes have any surfaces to draw (purely a split plane)
[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
if ((c = node->numsurfaces)) {
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
const bsp_face_t *face = bctx->faces + node->firstsurface;
const int *frame = pass->face_frames + node->firstsurface;
for (; c; c--, face++, frame++) {
if (*frame != r_visframecount)
[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
continue;
// side is either 0 or SURF_PLANEBACK
[glsl,vulkan] More comments in the bsp code And maybe a nano-optimization. Switching from (~side + 1) to (-side) seems to give glsl a very tiny speed boost, but certainly doesn't hurt. Looking at some assembly output for the three cases, the two hacks seem to generate the same code as each other, but 3 instructions vs 6 for ?:. While ?: is more generically robust, the hacks are tuned for the knowledge side is either 0 or 1. The later xor might alter things, but at least I now know that the hack (either version) is worthwhile.
2022-05-13 13:00:03 +00:00
// if side and the surface facing differ, then the camera is
// on backside of the surface
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
if (side ^ (face->flags & SURF_PLANEBACK))
[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
continue; // wrong side
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
chain_surface (face, pass, bctx);
[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
}
}
}
static inline int
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
test_node (mod_brush_t *brush, int node_id)
[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
{
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
if (node_id < 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
return 0;
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
if (r_node_visframes[node_id] != r_visframecount)
[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
return 0;
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
mnode_t *node = brush->nodes + node_id;
[mathlib] Remove frustum global It should never have been there and is now in the refdef (not its final home: it should probably be part of the camera).
2022-03-19 03:33:12 +00:00
if (R_CullBox (r_refdef.frustum, node->minmaxs, node->minmaxs + 3))
[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
return 0;
return 1;
}
static void
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
R_VisitWorldNodes (mod_brush_t *brush, vulkan_ctx_t *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
{
typedef struct {
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
int node_id;
[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
int side;
} rstack_t;
rstack_t *node_ptr;
rstack_t *node_stack;
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
int node_id;
int front;
[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
int side;
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
node_id = 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
// +2 for paranoia
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
node_stack = alloca ((brush->depth + 2) * sizeof (rstack_t));
[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
node_ptr = node_stack;
while (1) {
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
while (test_node (brush, node_id)) {
mnode_t *node = brush->nodes + node_id;
[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
side = get_side (node);
front = node->children[side];
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
if (test_node (brush, front)) {
node_ptr->node_id = node_id;
[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
node_ptr->side = side;
node_ptr++;
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
node_id = front;
[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
continue;
}
[vulkan] Add some comments and clean some code Figuring out bsp rendering for shadows is a fair bit harder than expected :P
2021-07-22 07:13:12 +00:00
// front is either not a node (ie, is a leaf) or is not visible
// if node is visible, then at least one of its child nodes
// must also be visible, and a leaf child in front of the node
// will be visible, so no need for vis checks on a leaf
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
if (front < 0) {
mleaf_t *leaf = brush->leafs + ~front;
if (leaf->contents != CONTENTS_SOLID) {
visit_leaf (leaf);
}
}
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
visit_node (brush, node, side, ctx);
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
node_id = node->children[side ^ 1];
}
if (node_id < 0) {
mleaf_t *leaf = brush->leafs + ~node_id;
if (leaf->contents != CONTENTS_SOLID) {
visit_leaf (leaf);
}
[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
}
if (node_ptr != node_stack) {
node_ptr--;
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
node_id = node_ptr->node_id;
[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
side = node_ptr->side;
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
mnode_t *node = brush->nodes + node_id;
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
visit_node (brush, node, side, ctx);
[model] Move plane info into mnode_t, and visframe out The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
2022-05-22 02:18:32 +00:00
node_id = node->children[side ^ 1];
[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
continue;
}
break;
}
}
[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
static void
push_transform (vec_t *transform, VkPipelineLayout layout,
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
qfv_device_t *device, VkCommandBuffer cmd)
[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] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
qfv_push_constants_t push_constants[] = {
{ VK_SHADER_STAGE_VERTEX_BIT,
field_offset (bsp_push_constants_t, Model),
sizeof (mat4f_t), transform },
};
QFV_PushConstants (device, cmd, layout, 1, push_constants);
[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
}
static void
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
bind_texture (vulktex_t *tex, uint32_t setnum, VkPipelineLayout layout,
qfv_devfuncs_t *dfunc, VkCommandBuffer cmd)
[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] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
VkDescriptorSet sets[] = {
tex->descriptor,
};
dfunc->vkCmdBindDescriptorSets (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
layout, setnum, 1, sets, 0, 0);
[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
}
static void
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
push_fragconst (bsp_push_constants_t *constants, VkPipelineLayout layout,
qfv_device_t *device, VkCommandBuffer cmd)
[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] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
qfv_push_constants_t push_constants[] = {
//{ VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof (mat), mat },
{ VK_SHADER_STAGE_FRAGMENT_BIT,
field_offset (bsp_push_constants_t, fog),
sizeof (constants->fog), &constants->fog },
{ VK_SHADER_STAGE_FRAGMENT_BIT,
field_offset (bsp_push_constants_t, time),
sizeof (constants->time), &constants->time },
[vulkan] Implement water alpha I'm not sure it's working properly, but that compose pass is suspect, especially with respect to lighting.
2022-05-21 08:48:45 +00:00
{ VK_SHADER_STAGE_FRAGMENT_BIT,
field_offset (bsp_push_constants_t, alpha),
sizeof (constants->alpha), &constants->alpha },
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
};
[vulkan] Implement water alpha I'm not sure it's working properly, but that compose pass is suspect, especially with respect to lighting.
2022-05-21 08:48:45 +00:00
QFV_PushConstants (device, cmd, layout, 3, push_constants);
[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] 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
static void
[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_begin_subpass (QFV_BspSubpass subpass, VkPipeline pipeline,
[vulkan] Switch bsp renderer to multi-texture I guess it's not quite bindless as the texture index is a push constant, but it seems to work well (and I may have fixed some full-bright issues by accident, though I suspect that's just my imagination, but they do look good).
2021-12-08 12:11:36 +00:00
VkPipelineLayout layout, qfv_renderframe_t *rFrame)
[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] 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_ctx_t *ctx = rFrame->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
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
bspctx_t *bctx = ctx->bsp_context;
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
__auto_type cframe = &ctx->frames.a[ctx->curFrame];
[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
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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
VkCommandBuffer cmd = bframe->cmdSet.a[subpass];
[vulkan] Build brush model display lists Not working particularly well yet, but no errors out of validation.
2021-01-20 17:13:40 +00:00
[vulkan] Bind the bsp main pipeline No drawing commands are issued yet, but vulkan seems to be happy with the state.
2021-01-20 07:51:35 +00:00
dfunc->vkResetCommandBuffer (cmd, 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
VkCommandBufferInheritanceInfo inherit = {
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, 0,
[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
rFrame->renderpass->renderpass, subpass_map[subpass],
[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
cframe->framebuffer,
0, 0, 0,
};
VkCommandBufferBeginInfo beginInfo = {
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, 0,
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
| VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, &inherit,
};
[vulkan] Bind the bsp main pipeline No drawing commands are issued yet, but vulkan seems to be happy with the state.
2021-01-20 07:51:35 +00:00
dfunc->vkBeginCommandBuffer (cmd, &beginInfo);
[vulkan] Label the drawing command buffers
2021-04-18 11:40:43 +00:00
QFV_duCmdBeginLabel (device, cmd, va (ctx->va_ctx, "bsp:%s",
bsp_pass_names[subpass]),
[vulkan] Use correct vertex shader for skys This gets skys rendering again, but their depth is incorrect.
2021-03-22 23:25:56 +00:00
{0, 0.5, 0.6, 1});
[vulkan] Bind the bsp main pipeline No drawing commands are issued yet, but vulkan seems to be happy with the state.
2021-01-20 07:51:35 +00:00
dfunc->vkCmdBindPipeline (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
[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
pipeline);
[vulkan] Move viewport and scissor into qfv_renderpass_t This makes much more sense as they are intimately tied to the frame buffer on which a render pass is working. Now, just the window width and height are stored in vulkan_ctx_t. As a side benefit, QFV_CreateSwapchain no long references viddef (now just palette and conview in vulkan_draw.c to go).
2022-04-01 11:34:41 +00:00
dfunc->vkCmdSetViewport (cmd, 0, 1, &rFrame->renderpass->viewport);
dfunc->vkCmdSetScissor (cmd, 0, 1, &rFrame->renderpass->scissor);
[vulkan] Bind the bsp main pipeline No drawing commands are issued yet, but vulkan seems to be happy with the state.
2021-01-20 07:51:35 +00:00
VkDeviceSize offsets[] = { 0 };
dfunc->vkCmdBindVertexBuffers (cmd, 0, 1, &bctx->vertex_buffer, offsets);
dfunc->vkCmdBindIndexBuffer (cmd, bctx->index_buffer, bframe->index_offset,
VK_INDEX_TYPE_UINT32);
[vulkan] Switch alias pipeline to multi-texture This gets the alias pipeline in line with the bsp pipeline, and thus everything is about as functional as it was before the rework (minus dealing with large texture sets).
2021-12-08 15:25:50 +00:00
VkDescriptorSet sets[] = {
[vulkan] Fix a typo and gcc purity warning
2021-12-13 01:39:01 +00:00
Vulkan_Matrix_Descriptors (ctx, ctx->curFrame),
[vulkan] Switch bsp renderer to multi-texture I guess it's not quite bindless as the texture index is a push constant, but it seems to work well (and I may have fixed some full-bright issues by accident, though I suspect that's just my imagination, but they do look good).
2021-12-08 12:11:36 +00:00
};
dfunc->vkCmdBindDescriptorSets (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
layout, 0, 1, sets, 0, 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
//XXX glsl_Fog_GetColor (fog);
//XXX fog[3] = glsl_Fog_GetDensity () / 64.0;
}
static void
[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
bsp_end_subpass (VkCommandBuffer cmd, vulkan_ctx_t *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
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
[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] Use correct vertex shader for skys This gets skys rendering again, but their depth is incorrect.
2021-03-22 23:25:56 +00:00
QFV_duCmdEndLabel (device, cmd);
[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
dfunc->vkEndCommandBuffer (cmd);
}
static void
[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
bsp_begin (qfv_renderframe_t *rFrame)
[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] 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_ctx_t *ctx = rFrame->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
bspctx_t *bctx = ctx->bsp_context;
[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
//XXX quat_t fog;
bctx->default_color[3] = 1;
QuatCopy (bctx->default_color, bctx->last_color);
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
DARRAY_APPEND (&rFrame->subpassCmdSets[QFV_passDepth],
[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
bframe->cmdSet.a[QFV_bspDepth]);
[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
DARRAY_APPEND (&rFrame->subpassCmdSets[QFV_passGBuffer],
[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
bframe->cmdSet.a[QFV_bspGBuffer]);
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
qfvPushDebug (ctx, "bsp_begin_subpass");
[vulkan] Switch bsp renderer to multi-texture I guess it's not quite bindless as the texture index is a push constant, but it seems to work well (and I may have fixed some full-bright issues by accident, though I suspect that's just my imagination, but they do look good).
2021-12-08 12:11:36 +00:00
bsp_begin_subpass (QFV_bspDepth, bctx->depth, bctx->layout, rFrame);
bsp_begin_subpass (QFV_bspGBuffer, bctx->gbuf, bctx->layout, rFrame);
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
qfvPopDebug (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] 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] 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
static void
bsp_end (vulkan_ctx_t *ctx)
{
bspctx_t *bctx = ctx->bsp_context;
[vulkan] Make a lot of progress for brush models Light maps are maybe updating, but as nothing is actually rendered yet, it's hard to tell.
2021-01-19 16:25:54 +00:00
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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
bsp_end_subpass (bframe->cmdSet.a[QFV_bspDepth], ctx);
bsp_end_subpass (bframe->cmdSet.a[QFV_bspGBuffer], 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] 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
static void
[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
turb_begin (qfv_renderframe_t *rFrame)
[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] 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_ctx_t *ctx = rFrame->vulkan_ctx;
[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
bspctx_t *bctx = ctx->bsp_context;
[vulkan] Make a lot of progress for brush models Light maps are maybe updating, but as nothing is actually rendered yet, it's hard to tell.
2021-01-19 16:25:54 +00:00
[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
bctx->default_color[3] = bound (0, r_wateralpha, 1);
[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] 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
QuatCopy (bctx->default_color, bctx->last_color);
[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] 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
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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] 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
DARRAY_APPEND (&rFrame->subpassCmdSets[QFV_passTranslucent],
[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
bframe->cmdSet.a[QFV_bspTurb]);
[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] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
qfvPushDebug (ctx, "bsp_begin_subpass");
[vulkan] Switch bsp renderer to multi-texture I guess it's not quite bindless as the texture index is a push constant, but it seems to work well (and I may have fixed some full-bright issues by accident, though I suspect that's just my imagination, but they do look good).
2021-12-08 12:11:36 +00:00
bsp_begin_subpass (QFV_bspTurb, bctx->turb, bctx->layout, rFrame);
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
qfvPopDebug (ctx);
[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
}
[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] 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
static void
turb_end (vulkan_ctx_t *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] 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
bspctx_t *bctx = ctx->bsp_context;
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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] 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_end_subpass (bframe->cmdSet.a[QFV_bspTurb], ctx);
}
[vulkan] Update the sky matrix Regardless of whether the sky is spinning or not, the matrix needs to be updated with the current origin in order to get the direction vector right in the shader. Also, it's in the update that the required x-y plane rotation gets in so the skies move in the correct direction.
2022-02-18 04:29:41 +00:00
[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
static void
[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
sky_begin (qfv_renderframe_t *rFrame)
[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] 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_ctx_t *ctx = rFrame->vulkan_ctx;
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
bspctx_t *bctx = ctx->bsp_context;
[vulkan] Make a lot of progress for brush models Light maps are maybe updating, but as nothing is actually rendered yet, it's hard to tell.
2021-01-19 16:25:54 +00:00
bctx->default_color[3] = 1;
QuatCopy (bctx->default_color, bctx->last_color);
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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] 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
DARRAY_APPEND (&rFrame->subpassCmdSets[QFV_passTranslucent],
[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
bframe->cmdSet.a[QFV_bspSky]);
[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] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
qfvPushDebug (ctx, "bsp_begin_subpass");
[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
if (bctx->skybox_tex) {
[vulkan] Switch bsp renderer to multi-texture I guess it's not quite bindless as the texture index is a push constant, but it seems to work well (and I may have fixed some full-bright issues by accident, though I suspect that's just my imagination, but they do look good).
2021-12-08 12:11:36 +00:00
bsp_begin_subpass (QFV_bspSky, bctx->skybox, bctx->layout, rFrame);
[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
} else {
[vulkan] Switch bsp renderer to multi-texture I guess it's not quite bindless as the texture index is a push constant, but it seems to work well (and I may have fixed some full-bright issues by accident, though I suspect that's just my imagination, but they do look good).
2021-12-08 12:11:36 +00:00
bsp_begin_subpass (QFV_bspSky, bctx->skysheet, bctx->layout, rFrame);
[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] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
qfvPopDebug (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
}
static void
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
sky_end (vulkan_ctx_t *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] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
bspctx_t *bctx = ctx->bsp_context;
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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] 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_end_subpass (bframe->cmdSet.a[QFV_bspSky], 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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
static void
clear_queues (bspctx_t *bctx, bsp_pass_t *pass)
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
for (size_t i = 0; i < bctx->registered_textures.size; i++) {
DARRAY_RESIZE (&pass->face_queue[i], 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
}
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
for (int j = 0; j < pass->num_queues; j++) {
DARRAY_RESIZE (&pass->draw_queues[j], 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
}
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
pass->index_count = 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
}
static void
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
draw_queue (bsp_pass_t *pass, int queue, VkPipelineLayout layout,
qfv_device_t *device, VkCommandBuffer cmd)
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
qfv_devfuncs_t *dfunc = device->funcs;
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
for (size_t i = 0; i < pass->draw_queues[queue].size; i++) {
__auto_type d = pass->draw_queues[queue].a[i];
if (pass->textures) {
vulktex_t *tex = pass->textures->a[d.tex_id];
bind_texture (tex, 1, layout, dfunc, cmd);
}
dfunc->vkCmdDrawIndexed (cmd, d.index_count, d.instance_count,
d.first_index, 0, d.first_instance);
[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
}
}
void
[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_DrawWorld (qfv_renderframe_t *rFrame)
[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] 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_ctx_t *ctx = rFrame->vulkan_ctx;
[vulkan] Build brush model display lists Not working particularly well yet, but no errors out of validation.
2021-01-20 17:13:40 +00:00
qfv_device_t *device = ctx->device;
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
//qfv_devfuncs_t *dfunc = device->funcs;
[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
bspctx_t *bctx = ctx->bsp_context;
[vulkan] Build brush model display lists Not working particularly well yet, but no errors out of validation.
2021-01-20 17:13:40 +00:00
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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
entity_t worldent;
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
mod_brush_t *brush;
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
bctx->main_pass.face_frames = r_face_visframes;
bctx->main_pass.leaf_frames = r_leaf_visframes;
bctx->main_pass.node_frames = r_node_visframes;
clear_queues (bctx, &bctx->main_pass); // do this first for water and skys
[vulkan] Fix the bsp vertex index list creation There's still a problem with the vertex data itself not getting sent to the GPU properly, but vulkan is now happy with my tiny test map (which required disabling skies entirely until I get null textures working).
2021-01-21 05:37:39 +00:00
bframe->index_count = 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
memset (&worldent, 0, sizeof (worldent));
[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
worldent.renderer.model = r_refdef.worldmodel;
brush = &r_refdef.worldmodel->brush;
[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
[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
bctx->entity = &worldent;
[renderer] Remove currententity from non-sw renderers Really needed only for vulkan, but removing currententity from gl and glsl made testing easier.
2021-07-22 06:39:28 +00:00
bctx->transform = 0;
bctx->color = 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
[models] Move brush data into its own struct This is a big step towards a cleaner api. The struct reference in model_t really should be a pointer, but bsp submodel(?) loading messed that up, though that's just a matter of taking more care in the loading code. It seems sensible to make that a separate step.
2021-02-01 10:31:11 +00:00
R_VisitWorldNodes (brush, ctx);
[vulkan] Cope with an empty world model Vulkan doesn't appreciate the empty buffers that result from the model not having any textures or surfaces that can be rendered (rightfully so, for such a bare-metal api).
2022-04-25 22:26:32 +00:00
if (!bctx->vertex_buffer) {
return;
}
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (r_drawentities) {
[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
for (size_t i = 0; i < r_ent_queue->ent_queues[mod_brush].size; i++) {
entity_t *ent = r_ent_queue->ent_queues[mod_brush].a[i];
[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_DrawBrushModel (ent, 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
bsp_begin (rFrame);
[vulkan] Build brush model display lists Not working particularly well yet, but no errors out of validation.
2021-01-20 17:13:40 +00:00
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
push_transform (identity, bctx->layout, device,
[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
bframe->cmdSet.a[QFV_bspDepth]);
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
push_transform (identity, bctx->layout, device,
[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
bframe->cmdSet.a[QFV_bspGBuffer]);
[vulkan] Update labeled struct inits I had used some legacy gcc extensions rather than standard C (clang wasn't too happy about that).
2022-03-30 16:26:57 +00:00
bsp_push_constants_t frag_constants = { .time = vr_data.realtime };
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
push_fragconst (&frag_constants, bctx->layout, device,
[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
bframe->cmdSet.a[QFV_bspGBuffer]);
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
__auto_type pass = &bctx->main_pass;
pass->indices = bframe->index_data;
for (size_t i = 0; i < bctx->registered_textures.size; i++) {
__auto_type queue = &pass->face_queue[i];
if (!queue->size) {
continue;
}
//FIXME implement draw_queue selection correctly (per face)
int dq = 0;
if (bctx->faces[queue->a[0].face].flags & SURF_DRAWSKY) {
dq = 1;
[vulkan] Build brush model display lists Not working particularly well yet, but no errors out of validation.
2021-01-20 17:13:40 +00:00
}
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
if (bctx->faces[queue->a[0].face].flags & SURF_DRAWTURB) {
dq = 2;
}
bsp_draw_t draw = {
.tex_id = i,
.instance_count = 1,
.first_index = pass->index_count,
};
for (size_t j = 0; j < queue->size; j++) {
__auto_type is = queue->a[j];
__auto_type f = bctx->faces[is.face];
memcpy (pass->indices + pass->index_count,
bctx->poly_indices + f.first_index,
f.index_count * sizeof (uint32_t));
draw.index_count += f.index_count;
pass->index_count += f.index_count;
}
DARRAY_APPEND (&pass->draw_queues[dq], draw);
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
VkPipelineLayout layout = bctx->layout;
pass->textures = 0;
draw_queue (pass, 0, layout, device, bframe->cmdSet.a[QFV_bspDepth]);
pass->textures = &bctx->registered_textures;
draw_queue (pass, 0, layout, device, bframe->cmdSet.a[QFV_bspGBuffer]);
[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
bsp_end (ctx);
[vulkan] Flush bsp vertex indices after all drawing
2021-12-17 06:52:17 +00:00
}
[vulkan] Get wall rendering partially working Many surfaces are missing (I suspect it's due to transform stage management in the index emitter), and currently only the light maps are rendered (still not binding the correct textures), but the basics are working.
2021-01-21 17:20:32 +00:00
[vulkan] Flush bsp vertex indices after all drawing
2021-12-17 06:52:17 +00:00
void
Vulkan_Bsp_Flush (vulkan_ctx_t *ctx)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
bspctx_t *bctx = ctx->bsp_context;
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[vulkan] Get wall rendering partially working Many surfaces are missing (I suspect it's due to transform stage management in the index emitter), and currently only the light maps are rendered (still not binding the correct textures), but the basics are working.
2021-01-21 17:20:32 +00:00
size_t atom = device->physDev->properties.limits.nonCoherentAtomSize;
size_t atom_mask = atom - 1;
size_t offset = bframe->index_offset;
size_t size = bframe->index_count * sizeof (uint32_t);
[vulkan] Cope with an empty world model Vulkan doesn't appreciate the empty buffers that result from the model not having any textures or surfaces that can be rendered (rightfully so, for such a bare-metal api).
2022-04-25 22:26:32 +00:00
if (!bframe->index_count) {
return;
}
[vulkan] Get wall rendering partially working Many surfaces are missing (I suspect it's due to transform stage management in the index emitter), and currently only the light maps are rendered (still not binding the correct textures), but the basics are working.
2021-01-21 17:20:32 +00:00
offset &= ~atom_mask;
size = (size + atom_mask) & ~atom_mask;
VkMappedMemoryRange range = {
VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, 0,
bctx->index_memory, offset, size
};
dfunc->vkFlushMappedMemoryRanges (device->dev, 1, &range);
[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
}
void
[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_DrawWaterSurfaces (qfv_renderframe_t *rFrame)
[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] 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_ctx_t *ctx = rFrame->vulkan_ctx;
[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
qfv_device_t *device = ctx->device;
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
//qfv_devfuncs_t *dfunc = device->funcs;
[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
bspctx_t *bctx = ctx->bsp_context;
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
if (!bctx->main_pass.draw_queues[2].size)
[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
return;
[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
turb_begin (rFrame);
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
push_transform (identity, bctx->layout, device,
[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
bframe->cmdSet.a[QFV_bspTurb]);
[vulkan] Implement water alpha I'm not sure it's working properly, but that compose pass is suspect, especially with respect to lighting.
2022-05-21 08:48:45 +00:00
bsp_push_constants_t frag_constants = {
.time = vr_data.realtime,
.alpha = r_wateralpha
};
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
push_fragconst (&frag_constants, bctx->layout, device,
[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
bframe->cmdSet.a[QFV_bspTurb]);
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
VkPipelineLayout layout = bctx->layout;
__auto_type pass = &bctx->main_pass;
pass->textures = &bctx->registered_textures;
draw_queue (pass, 2, layout, device, bframe->cmdSet.a[QFV_bspTurb]);
turb_end (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
}
void
[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_DrawSky (qfv_renderframe_t *rFrame)
[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] 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_ctx_t *ctx = rFrame->vulkan_ctx;
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
[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
bspctx_t *bctx = ctx->bsp_context;
[vulkan] Build brush model display lists Not working particularly well yet, but no errors out of validation.
2021-01-20 17:13:40 +00:00
bspframe_t *bframe = &bctx->frames.a[ctx->curFrame];
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
if (!bctx->main_pass.draw_queues[1].size)
[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
return;
[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
sky_begin (rFrame);
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
vulktex_t skybox = { .descriptor = bctx->skybox_descriptor };
bind_texture (&skybox, 2, bctx->layout, dfunc,
bframe->cmdSet.a[QFV_bspSky]);
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
push_transform (identity, bctx->layout, device,
[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
bframe->cmdSet.a[QFV_bspSky]);
[vulkan] Update labeled struct inits I had used some legacy gcc extensions rather than standard C (clang wasn't too happy about that).
2022-03-30 16:26:57 +00:00
bsp_push_constants_t frag_constants = { .time = vr_data.realtime };
[vulkan] Clean up bsp push-constants.
2021-12-17 06:51:33 +00:00
push_fragconst (&frag_constants, bctx->layout, device,
[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
bframe->cmdSet.a[QFV_bspSky]);
[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] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
VkPipelineLayout layout = bctx->layout;
__auto_type pass = &bctx->main_pass;
pass->textures = &bctx->registered_textures;
draw_queue (pass, 1, layout, device, bframe->cmdSet.a[QFV_bspSky]);
sky_end (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] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
static void
create_default_skys (vulkan_ctx_t *ctx)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
bspctx_t *bctx = ctx->bsp_context;
VkImage skybox;
VkImage skysheet;
VkDeviceMemory memory;
VkImageView boxview;
VkImageView sheetview;
bctx->default_skybox = calloc (2, sizeof (qfv_tex_t));
bctx->default_skysheet = bctx->default_skybox + 1;
VkExtent3D extents = { 1, 1, 1 };
skybox = QFV_CreateImage (device, 1, VK_IMAGE_TYPE_2D,
VK_FORMAT_B8G8R8A8_UNORM, extents, 1, 1,
VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_USAGE_SAMPLED_BIT
| VK_IMAGE_USAGE_TRANSFER_DST_BIT);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE, skybox,
"bsp:image:default_skybox");
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
skysheet = QFV_CreateImage (device, 0, VK_IMAGE_TYPE_2D,
VK_FORMAT_B8G8R8A8_UNORM, extents, 1, 2,
VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_USAGE_SAMPLED_BIT
| VK_IMAGE_USAGE_TRANSFER_DST_BIT);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE, skysheet,
"bsp:image:default_skysheet");
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
VkMemoryRequirements requirements;
dfunc->vkGetImageMemoryRequirements (device->dev, skybox, &requirements);
size_t boxsize = requirements.size;
dfunc->vkGetImageMemoryRequirements (device->dev, skysheet, &requirements);
size_t sheetsize = requirements.size;
memory = QFV_AllocImageMemory (device, skybox,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
boxsize + sheetsize,
VK_IMAGE_USAGE_TRANSFER_DST_BIT
| VK_IMAGE_USAGE_SAMPLED_BIT);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_DEVICE_MEMORY, memory,
"bsp:memory:default_skys");
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
QFV_BindImageMemory (device, skybox, memory, 0);
QFV_BindImageMemory (device, skysheet, memory, boxsize);
boxview = QFV_CreateImageView (device, skybox, VK_IMAGE_VIEW_TYPE_CUBE,
VK_FORMAT_B8G8R8A8_UNORM,
VK_IMAGE_ASPECT_COLOR_BIT);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE_VIEW, boxview,
[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
"bsp:iview:default_skybox");
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
sheetview = QFV_CreateImageView (device, skysheet,
VK_IMAGE_VIEW_TYPE_2D_ARRAY,
VK_FORMAT_B8G8R8A8_UNORM,
VK_IMAGE_ASPECT_COLOR_BIT);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE_VIEW, sheetview,
"bsp:iview:default_skysheet");
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
bctx->default_skybox->image = skybox;
bctx->default_skybox->view = boxview;
bctx->default_skybox->memory = memory;
bctx->default_skysheet->image = skysheet;
bctx->default_skysheet->view = sheetview;
// temporarily commandeer the light map's staging buffer
qfv_packet_t *packet = QFV_PacketAcquire (bctx->light_stage);
[vulkan] Clean up image barriers a bit Mostly, this gets the stage flags in with the barrier, but also adds a couple more barrier templates. It should make for slightly less verbose code, and one less opportunity for error (mismatched barrier/stages).
2021-04-24 03:42:29 +00:00
qfv_imagebarrier_t ib = imageBarriers[qfv_LT_Undefined_to_TransferDst];
ib.barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
ib.barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
VkImageMemoryBarrier barriers[2] = { ib.barrier, ib.barrier };
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
barriers[0].image = skybox;
barriers[1].image = skysheet;
[vulkan] Clean up image barriers a bit Mostly, this gets the stage flags in with the barrier, but also adds a couple more barrier templates. It should make for slightly less verbose code, and one less opportunity for error (mismatched barrier/stages).
2021-04-24 03:42:29 +00:00
dfunc->vkCmdPipelineBarrier (packet->cmd, ib.srcStages, ib.dstStages,
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
0, 0, 0, 0, 0,
2, barriers);
VkClearColorValue color = {};
VkImageSubresourceRange range = {
VK_IMAGE_ASPECT_COLOR_BIT,
0, VK_REMAINING_MIP_LEVELS,
0, VK_REMAINING_ARRAY_LAYERS
};
dfunc->vkCmdClearColorImage (packet->cmd, skybox,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
&color, 1, &range);
dfunc->vkCmdClearColorImage (packet->cmd, skysheet,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
&color, 1, &range);
[vulkan] Clean up image barriers a bit Mostly, this gets the stage flags in with the barrier, but also adds a couple more barrier templates. It should make for slightly less verbose code, and one less opportunity for error (mismatched barrier/stages).
2021-04-24 03:42:29 +00:00
ib = imageBarriers[qfv_LT_TransferDst_to_ShaderReadOnly];
ib.barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
ib.barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
barriers[0] = ib.barrier;
barriers[1] = ib.barrier;
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
barriers[0].image = skybox;
barriers[1].image = skysheet;
[vulkan] Clean up image barriers a bit Mostly, this gets the stage flags in with the barrier, but also adds a couple more barrier templates. It should make for slightly less verbose code, and one less opportunity for error (mismatched barrier/stages).
2021-04-24 03:42:29 +00:00
dfunc->vkCmdPipelineBarrier (packet->cmd, ib.srcStages, ib.dstStages,
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
0, 0, 0, 0, 0,
2, barriers);
QFV_PacketSubmit (packet);
}
[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
void
Vulkan_Bsp_Init (vulkan_ctx_t *ctx)
{
qfv_device_t *device = ctx->device;
[model] Initialize r_notexture_mip in the right places That being in the renderer. This is why qwaq needed that call to Mod_ProcessTexture (but no longer does :)
2022-05-05 12:22:44 +00:00
r_notexture_mip->render = &vulkan_notexture;
[vulkan] Add some more debug stack contexts
2021-12-02 13:48:50 +00:00
qfvPushDebug (ctx, "bsp init");
[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
bspctx_t *bctx = calloc (1, sizeof (bspctx_t));
ctx->bsp_context = bctx;
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
bctx->light_scrap = QFV_CreateScrap (device, "lightmap_atlas", 2048,
tex_frgba, ctx->staging);
[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
size_t size = QFV_ScrapSize (bctx->light_scrap);
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
bctx->light_stage = QFV_CreateStagingBuffer (device, "lightmap", size,
ctx->cmdpool);
[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] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
create_default_skys (ctx);
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
DARRAY_INIT (&bctx->registered_textures, 64);
bctx->main_pass.num_queues = 3;
bctx->main_pass.draw_queues = malloc (bctx->main_pass.num_queues
* sizeof (bsp_drawset_t));
for (int i = 0; i < bctx->main_pass.num_queues; i++) {
DARRAY_INIT (&bctx->main_pass.draw_queues[i], 64);
}
[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] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
size_t frames = ctx->frames.size;
[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
DARRAY_INIT (&bctx->frames, frames);
DARRAY_RESIZE (&bctx->frames, frames);
bctx->frames.grow = 0;
[vulkan] Add support for compute shaders This needed changing Vulkan_CreatePipeline to Vulkan_CreateGraphicsPipeline for consistency (and parsing the difference from a plist seemed... not worth thinking about).
2021-12-16 14:00:17 +00:00
bctx->depth = Vulkan_CreateGraphicsPipeline (ctx, "bsp_depth");
bctx->gbuf = Vulkan_CreateGraphicsPipeline (ctx, "bsp_gbuf");
bctx->skybox = Vulkan_CreateGraphicsPipeline (ctx, "bsp_skybox");
bctx->skysheet = Vulkan_CreateGraphicsPipeline (ctx, "bsp_skysheet");
bctx->turb = Vulkan_CreateGraphicsPipeline (ctx, "bsp_turb");
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
bctx->layout = Vulkan_CreatePipelineLayout (ctx, "quakebsp_layout");
bctx->sampler = Vulkan_CreateSampler (ctx, "quakebsp_sampler");
[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
for (size_t i = 0; i < frames; i++) {
__auto_type bframe = &bctx->frames.a[i];
[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
DARRAY_INIT (&bframe->cmdSet, QFV_bspNumPasses);
DARRAY_RESIZE (&bframe->cmdSet, QFV_bspNumPasses);
bframe->cmdSet.grow = 0;
QFV_AllocateCommandBuffers (device, ctx->cmdpool, 1, &bframe->cmdSet);
for (int j = 0; j < QFV_bspNumPasses; j++) {
QFV_duSetObjectName (device, VK_OBJECT_TYPE_COMMAND_BUFFER,
bframe->cmdSet.a[i],
va (ctx->va_ctx, "cmd:bsp:%zd:%s", i,
bsp_pass_names[j]));
}
[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] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
bctx->skybox_descriptor
= Vulkan_CreateTextureDescriptor (ctx, bctx->default_skybox,
bctx->sampler);
[vulkan] Add some more debug stack contexts
2021-12-02 13:48:50 +00:00
qfvPopDebug (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
}
void
Vulkan_Bsp_Shutdown (struct vulkan_ctx_s *ctx)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
bspctx_t *bctx = ctx->bsp_context;
[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
for (size_t i = 0; i < bctx->frames.size; i++) {
__auto_type bframe = &bctx->frames.a[i];
free (bframe->cmdSet.a);
}
[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
dfunc->vkDestroyPipeline (device->dev, bctx->depth, 0);
dfunc->vkDestroyPipeline (device->dev, bctx->gbuf, 0);
[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
dfunc->vkDestroyPipeline (device->dev, bctx->skybox, 0);
dfunc->vkDestroyPipeline (device->dev, bctx->skysheet, 0);
[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
dfunc->vkDestroyPipeline (device->dev, bctx->turb, 0);
[vulkan] Implement thread-safe rendering for the world model Sub-models and instance models need an instance data buffer, but this gets the basics working (and the proof of concept). Using arrays like this actually simplified a lot of the code, and will make it easy to get transparency without turbulence (just another queue).
2022-05-22 16:28:43 +00:00
DARRAY_CLEAR (&bctx->registered_textures);
for (int i = 0; i < bctx->main_pass.num_queues; i++) {
DARRAY_CLEAR (&bctx->main_pass.draw_queues[i]);
}
free (bctx->main_pass.draw_queues);
[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
DARRAY_CLEAR (&bctx->frames);
QFV_DestroyStagingBuffer (bctx->light_stage);
QFV_DestroyScrap (bctx->light_scrap);
[vulkan] Create a populate the vertex buffer And create/map the index buffer.
2021-01-20 07:28:04 +00:00
if (bctx->vertex_buffer) {
dfunc->vkDestroyBuffer (device->dev, bctx->vertex_buffer, 0);
dfunc->vkFreeMemory (device->dev, bctx->vertex_memory, 0);
}
if (bctx->index_buffer) {
dfunc->vkDestroyBuffer (device->dev, bctx->index_buffer, 0);
dfunc->vkFreeMemory (device->dev, bctx->index_memory, 0);
}
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
[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
if (bctx->skybox_tex) {
Vulkan_UnloadTex (ctx, bctx->skybox_tex);
}
[vulkan] Get sky sheets mostly working They render (incorrectly because the images weren't translated correctly), but aren't animated (haven't pushed the time constant)
2021-01-23 11:42:53 +00:00
dfunc->vkDestroyImageView (device->dev, bctx->default_skysheet->view, 0);
dfunc->vkDestroyImage (device->dev, bctx->default_skysheet->image, 0);
dfunc->vkDestroyImageView (device->dev, bctx->default_skybox->view, 0);
dfunc->vkDestroyImage (device->dev, bctx->default_skybox->image, 0);
dfunc->vkFreeMemory (device->dev, bctx->default_skybox->memory, 0);
free (bctx->default_skybox);
[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] 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
void
Vulkan_LoadSkys (const char *sky, vulkan_ctx_t *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] 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
bspctx_t *bctx = ctx->bsp_context;
const char *name;
[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
int i;
tex_t *tex;
static const char *sky_suffix[] = { "ft", "bk", "up", "dn", "rt", "lf"};
[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
if (bctx->skybox_tex) {
Vulkan_UnloadTex (ctx, bctx->skybox_tex);
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
Vulkan_FreeTexture (ctx, bctx->skybox_descriptor);
[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
}
bctx->skybox_tex = 0;
if (!sky || !*sky) {
[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
sky = r_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] 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
if (!*sky || !strcasecmp (sky, "none")) {
[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, "Skybox unloaded\n");
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
bctx->skybox_descriptor
= Vulkan_CreateTextureDescriptor (ctx, bctx->default_skybox,
bctx->sampler);
[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
return;
}
[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
name = va (ctx->va_ctx, "env/%s_map", sky);
tex = LoadImage (name, 1);
if (tex) {
bctx->skybox_tex = Vulkan_LoadEnvMap (ctx, tex, sky);
[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, "Loaded %s\n", name);
[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
} else {
[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
int failed = 0;
tex_t *sides[6] = { };
[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
for (i = 0; i < 6; i++) {
[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
name = va (ctx->va_ctx, "env/%s%s", sky, sky_suffix[i]);
tex = LoadImage (name, 1);
if (!tex) {
[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, "Couldn't load %s\n", name);
[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
// also look in gfx/env, where Darkplaces looks for skies
[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
name = va (ctx->va_ctx, "gfx/env/%s%s", sky, sky_suffix[i]);
tex = LoadImage (name, 1);
if (!tex) {
[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, "Couldn't load %s\n", name);
[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
failed = 1;
[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
continue;
}
}
[vulkan] Don't lose other sky cube faces Because LoadImage uses Hunk_TempAlloc, the face images need to be copied individually. Really, what's neeeded is to be able to load the image data into a pre-allocated buffer (ideally, the staging buffer for vulkan, but that's for later).
2021-04-24 23:38:48 +00:00
//FIXME find a better way (also, assumes data and struct together)
sides[i] = malloc (ImageSize (tex, 1));
memcpy (sides[i], tex, ImageSize (tex, 1));
sides[i]->data = (byte *)(sides[i] + 1);
[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, "Loaded %s\n", name);
[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
}
if (!failed) {
bctx->skybox_tex = Vulkan_LoadEnvSides (ctx, sides, sky);
[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] Don't lose other sky cube faces Because LoadImage uses Hunk_TempAlloc, the face images need to be copied individually. Really, what's neeeded is to be able to load the image data into a pre-allocated buffer (ideally, the staging buffer for vulkan, but that's for later).
2021-04-24 23:38:48 +00:00
for (i = 0; i < 6; i++) {
free (sides[i]);
}
[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] 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
if (bctx->skybox_tex) {
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
bctx->skybox_descriptor
[vulkan] Bind the correct texture for sky boxes That took way too long to find: just couldn't see it for looking.
2022-02-17 16:17:25 +00:00
= Vulkan_CreateTextureDescriptor (ctx, bctx->skybox_tex,
[vulkan] Abandon bindless rendering At least for now, it is more trouble than it is worth as it (or my implementation of it) breaks lavapipe and renderdoc.
2021-12-17 03:20:32 +00:00
bctx->sampler);
[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, "Skybox %s loaded\n", sky);
[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
}
}
Reference in a new issue Copy permalink