qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-24 05:11:42 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/renderer/vulkan/vulkan_iqm.c

329 lines
9.1 KiB
C
Raw Normal View History

[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
/*
vulkan_iqm.c
Vulkan IQM model pipeline
Copyright (C) 2022 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2022/5/3
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
#include <string.h>
#include "QF/cvar.h"
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
#include "QF/iqm.h"
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
#include "QF/va.h"
#include "QF/scene/entity.h"
#include "QF/Vulkan/qf_iqm.h"
#include "QF/Vulkan/qf_matrices.h"
#include "QF/Vulkan/qf_texture.h"
#include "QF/Vulkan/debug.h"
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
#include "QF/Vulkan/descriptor.h"
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
#include "QF/Vulkan/device.h"
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
#include "QF/Vulkan/dsmanager.h"
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
#include "QF/Vulkan/instance.h"
[vulkan] Implement IQM animations Unfortunately, the animations are pre-baked (by the loader) blocking run-time determined animations (IK etc). However, this at least gets everything working so the basics can be verified (the shader posed some issue resulting in horror movies ;).
2022-05-08 05:21:40 +00:00
#include "QF/Vulkan/resource.h"
[vulkan] Register task functions for the pipelines They're currently just stubs, but this gets the render info loading working without any errors. The next step is to connect up pipelines and create the image resources, then implementing the task functions will have meaning.
2023-02-13 15:55:22 +00:00
#include "QF/Vulkan/render.h"
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
#include "r_internal.h"
#include "vid_vulkan.h"
typedef struct {
mat4f_t mat;
float blend;
byte colorA[4];
byte colorB[4];
vec4f_t base_color;
vec4f_t fog;
} iqm_push_constants_t;
static void
emit_commands (VkCommandBuffer cmd, int pose1, int pose2,
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
qfv_iqm_skin_t *skins,
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
uint32_t numPC, qfv_push_constants_t *constants,
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
iqm_t *iqm, qfv_taskctx_t *taskctx, entity_t ent)
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
{
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
auto ctx = taskctx->ctx;
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
auto device = ctx->device;
auto dfunc = device->funcs;
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
auto layout = taskctx->pipeline->layout;
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
auto mesh = (qfv_iqm_t *) iqm->extra_data;
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
VkDeviceSize offsets[] = { 0, 0, };
VkBuffer buffers[] = {
mesh->geom_buffer,
mesh->rend_buffer,
};
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
int bindingCount = 2;//skins ? 2 : 1;
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
[vulkan] Add entity labels to command queues Brush models looked a little too tricky due to the very different style of command queue, so that's left for now, but alias, iqm and sprite entities are now labeled. The labels are made up of the lower 5 hex digits of the entity address, the position, and colored by the normalized position vector. Not sure that's the best choice as it does mean the color changes as the entity moves, and can be quite subtle between nearby entities, but it still helps identify the entities in the command buffer. And, as I suspected, I've got multiple draw calls for the one ogre. Now to find out why.
2022-05-07 05:12:02 +00:00
Vulkan_BeginEntityLabel (ctx, cmd, ent);
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
dfunc->vkCmdBindVertexBuffers (cmd, 0, bindingCount, buffers, offsets);
dfunc->vkCmdBindIndexBuffer (cmd, mesh->index_buffer, 0,
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
VK_INDEX_TYPE_UINT16);
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
QFV_PushConstants (device, cmd, layout, numPC, constants);
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
for (int i = 0; i < iqm->num_meshes; i++) {
if (skins) {
VkDescriptorSet sets[] = {
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
skins[i].descriptor,
mesh->bones_descriptors[ctx->curFrame],
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
};
dfunc->vkCmdBindDescriptorSets (cmd,
VK_PIPELINE_BIND_POINT_GRAPHICS,
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
layout, 1, 2, sets, 0, 0);
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
} else {
VkDescriptorSet sets[] = {
mesh->bones_descriptors[ctx->curFrame],
};
dfunc->vkCmdBindDescriptorSets (cmd,
VK_PIPELINE_BIND_POINT_GRAPHICS,
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
layout, 2, 1, sets, 0, 0);
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
}
dfunc->vkCmdDrawIndexed (cmd, 3 * iqm->meshes[i].num_triangles, 1,
3 * iqm->meshes[i].first_triangle, 0, 0);
}
[vulkan] Add entity labels to command queues Brush models looked a little too tricky due to the very different style of command queue, so that's left for now, but alias, iqm and sprite entities are now labeled. The labels are made up of the lower 5 hex digits of the entity address, the position, and colored by the normalized position vector. Not sure that's the best choice as it does mean the color changes as the entity moves, and can be quite subtle between nearby entities, but it still helps identify the entities in the command buffer. And, as I suspected, I've got multiple draw calls for the one ogre. Now to find out why.
2022-05-07 05:12:02 +00:00
QFV_CmdEndLabel (device, cmd);
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
}
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
static VkWriteDescriptorSet base_buffer_write = {
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 0, 0,
0, 0, 1,
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
0, 0, 0
};
void
Vulkan_IQMAddBones (vulkan_ctx_t *ctx, iqm_t *iqm)
{
qfvPushDebug (ctx, "Vulkan_IQMAddBones");
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
auto device = ctx->device;
auto dfunc = device->funcs;
auto ictx = ctx->iqm_context;
auto mesh = (qfv_iqm_t *) iqm->extra_data;
int num_sets = ictx->frames.size;
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
if (!ictx->dsmanager) {
ictx->dsmanager = QFV_Render_DSManager (ctx, "bone_set");
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
}
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
for (int i = 0; i < num_sets; i++) {
auto set = QFV_DSManager_AllocSet (ictx->dsmanager);
mesh->bones_descriptors[i] = set;
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
}
VkDescriptorBufferInfo bufferInfo[num_sets];
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
size_t bones_size = sizeof (vec4f_t[iqm->num_joints * 3]);
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
for (int i = 0; i < num_sets; i++) {
bufferInfo[i].buffer = mesh->bones_buffer;
bufferInfo[i].offset = i * bones_size;
bufferInfo[i].range = bones_size;
};
VkWriteDescriptorSet write[num_sets];
for (int i = 0; i < num_sets; i++) {
write[i] = base_buffer_write;
write[i].dstSet = mesh->bones_descriptors[i];
write[i].pBufferInfo = &bufferInfo[i];
}
dfunc->vkUpdateDescriptorSets (device->dev, num_sets, write, 0, 0);
qfvPopDebug (ctx);
}
void
Vulkan_IQMRemoveBones (vulkan_ctx_t *ctx, iqm_t *iqm)
{
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
auto ictx = ctx->iqm_context;
auto mesh = (qfv_iqm_t *) iqm->extra_data;
int num_sets = ictx->frames.size;
[vulkan] Get IQM rendering working The bones aren't animated yet (and I realized I made the mistake of thinking the bone buffer was per-model when it's really per-instance (I think this mistake is in the rest of QF, too)), skin rendering is a mess, need to default vertex attributes that aren't in the model... Still, it's quite satisfying seeing Mr Fixit on screen again :) I wound up moving the pipeline spec in with the rest of the pipelines as the system isn't really ready for separating them.
2022-05-07 01:08:46 +00:00
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
for (int i = 0; i < num_sets; i++) {
QFV_DSManager_FreeSet (ictx->dsmanager, mesh->bones_descriptors[i]);
}
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
}
void
Vulkan_IQMAddSkin (vulkan_ctx_t *ctx, qfv_iqm_skin_t *skin)
{
iqmctx_t *ictx = ctx->iqm_context;
skin->descriptor = Vulkan_CreateCombinedImageSampler (ctx, skin->view,
ictx->sampler);
}
void
Vulkan_IQMRemoveSkin (vulkan_ctx_t *ctx, qfv_iqm_skin_t *skin)
{
Vulkan_FreeTexture (ctx, skin->descriptor);
skin->descriptor = 0;
}
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
static void
iqm_draw_ent (qfv_taskctx_t *taskctx, entity_t ent, bool pass)
{
auto ctx = taskctx->ctx;
auto device = ctx->device;
auto dfunc = device->funcs;
renderer_t *renderer = Ent_GetComponent (ent.id, scene_renderer, ent.reg);
auto model = renderer->model;
auto iqm = (iqm_t *) model->aliashdr;
qfv_iqm_t *mesh = iqm->extra_data;
auto skins = mesh->skins;
iqm_push_constants_t constants = {};
iqmframe_t *frame;
animation_t *animation = Ent_GetComponent (ent.id, scene_animation,
ent.reg);
constants.blend = R_IQMGetLerpedFrames (animation, iqm);
frame = R_IQMBlendFrames (iqm, animation->pose1, animation->pose2,
constants.blend, 0);
vec4f_t *bone_data;
dfunc->vkMapMemory (device->dev, mesh->bones->memory, 0, VK_WHOLE_SIZE,
0, (void **)&bone_data);
for (int i = 0; i < iqm->num_joints; i++) {
vec4f_t *b = bone_data + (ctx->curFrame * iqm->num_joints + i) * 3;
mat4f_t f;
// R_IQMBlendFrames sets up the frame as a 4x4 matrix for m * v, but
// the shader wants a 3x4 (column x row) matrix for v * m, which is
// just a transpose (and drop of the 4th column) away.
mat4ftranspose (f, (vec4f_t *) &frame[i]);
// copy only the first 3 columns
memcpy (b, f, 3 * sizeof (vec4f_t));
}
#define a(x) ((x) & ~0x3f)
VkMappedMemoryRange range = {
VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, 0,
mesh->bones->memory,
a(3 * ctx->curFrame * iqm->num_joints * sizeof (vec4f_t)),
a(3 * iqm->num_joints * sizeof (vec4f_t) + 0x3f),
};
#undef a
dfunc->vkFlushMappedMemoryRanges (device->dev, 1, &range);
dfunc->vkUnmapMemory (device->dev, mesh->bones->memory);
transform_t transform = Entity_Transform (ent);
qfv_push_constants_t push_constants[] = {
{ VK_SHADER_STAGE_VERTEX_BIT,
field_offset (iqm_push_constants_t, mat),
sizeof (mat4f_t), Transform_GetWorldMatrixPtr (transform) },
{ VK_SHADER_STAGE_VERTEX_BIT,
field_offset (iqm_push_constants_t, blend),
sizeof (float), &constants.blend },
{ VK_SHADER_STAGE_FRAGMENT_BIT,
field_offset (iqm_push_constants_t, colorA),
sizeof (constants.colorA), constants.colorA },
{ VK_SHADER_STAGE_FRAGMENT_BIT,
field_offset (iqm_push_constants_t, colorB),
sizeof (constants.colorB), constants.colorB },
{ VK_SHADER_STAGE_FRAGMENT_BIT,
field_offset (iqm_push_constants_t, base_color),
sizeof (constants.base_color), &constants.base_color },
{ VK_SHADER_STAGE_FRAGMENT_BIT,
field_offset (iqm_push_constants_t, fog),
sizeof (constants.fog), &constants.fog },
};
QuatCopy (renderer->colormod, constants.base_color);
QuatCopy (skins[0].colora, constants.colorA);
QuatCopy (skins[0].colorb, constants.colorB);
QuatZero (constants.fog);
emit_commands (taskctx->cmd, animation->pose1, animation->pose2,
pass ? skins : 0,
pass ? 6 : 2, push_constants,
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
iqm, taskctx, ent);
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
}
[vulkan] Register task functions for the pipelines They're currently just stubs, but this gets the render info loading working without any errors. The next step is to connect up pipelines and create the image resources, then implementing the task functions will have meaning.
2023-02-13 15:55:22 +00:00
static void
iqm_draw (const exprval_t **params, exprval_t *result, exprctx_t *ectx)
{
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
auto taskctx = (qfv_taskctx_t *) ectx;
int pass = *(int *) params[0]->value;
auto ctx = taskctx->ctx;
auto device = ctx->device;
auto dfunc = device->funcs;
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
auto layout = taskctx->pipeline->layout;
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
auto cmd = taskctx->cmd;
VkDescriptorSet sets[] = {
Vulkan_Matrix_Descriptors (ctx, ctx->curFrame),
};
dfunc->vkCmdBindDescriptorSets (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
[vulkan] Clean out old pipeline and layout refs It's not perfect as some subsystems still create resources from the old system (necessarily), but this cleans up a lot of the mess.
2023-06-24 02:47:01 +00:00
layout, 0, 1, sets, 0, 0);
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
auto queue = r_ent_queue; //FIXME fetch from scene
for (size_t i = 0; i < queue->ent_queues[mod_iqm].size; i++) {
entity_t ent = queue->ent_queues[mod_iqm].a[i];
iqm_draw_ent (taskctx, ent, pass);
}
[vulkan] Register task functions for the pipelines They're currently just stubs, but this gets the render info loading working without any errors. The next step is to connect up pipelines and create the image resources, then implementing the task functions will have meaning.
2023-02-13 15:55:22 +00:00
}
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
static exprtype_t *iqm_draw_params[] = {
&cexpr_int,
};
[vulkan] Register task functions for the pipelines They're currently just stubs, but this gets the render info loading working without any errors. The next step is to connect up pipelines and create the image resources, then implementing the task functions will have meaning.
2023-02-13 15:55:22 +00:00
static exprfunc_t iqm_draw_func[] = {
[vulkan] Get iqm rendering working again It turns out there was a bug in the old iqm push constants spec (I still need to figure out how to use layouts in the new system so I can completely delete the old).
2023-06-23 00:38:41 +00:00
{ .func = iqm_draw, .num_params = 1, .param_types = iqm_draw_params },
[vulkan] Register task functions for the pipelines They're currently just stubs, but this gets the render info loading working without any errors. The next step is to connect up pipelines and create the image resources, then implementing the task functions will have meaning.
2023-02-13 15:55:22 +00:00
{}
};
static exprsym_t iqm_task_syms[] = {
{ "iqm_draw", &cexpr_function, iqm_draw_func },
{}
};
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
void
Vulkan_IQM_Init (vulkan_ctx_t *ctx)
{
qfvPushDebug (ctx, "iqm init");
[vulkan] Register task functions for the pipelines They're currently just stubs, but this gets the render info loading working without any errors. The next step is to connect up pipelines and create the image resources, then implementing the task functions will have meaning.
2023-02-13 15:55:22 +00:00
QFV_Render_AddTasks (ctx, iqm_task_syms);
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
iqmctx_t *ictx = calloc (1, sizeof (iqmctx_t));
ctx->iqm_context = ictx;
[vulkan] Move frames from vulkan_ctx to renderctx Part of the command buffer fix, but also a step towards cleaning up vulkan_ctx.
2023-06-22 07:44:05 +00:00
auto rctx = ctx->render_context;
size_t frames = rctx->frames.size;
[vulkan] Add support for IQM models Despite the base IQM specification not supporting blend-shapes, I think IQM will become the basis for QF's generic model representation (at least for the more advanced renderers). After my experience with .mu models (KSP) and unity mesh objects (both normal and skinned), and reviewing the IQM spec, it looks like with the addition of support for blend-shapes, IQM is actually pretty good. This is just the preliminary work to get standard IQM models loading in vulkan (seems to work, along with unloading), and they very basics into the renderer (most likely not working: not tested yet). The rest of the renderer seems to be unaffected, though, which is good.
2022-05-04 05:07:27 +00:00
DARRAY_INIT (&ictx->frames, frames);
DARRAY_RESIZE (&ictx->frames, frames);
ictx->frames.grow = 0;
ictx->sampler = Vulkan_CreateSampler (ctx, "alias_sampler");
qfvPopDebug (ctx);
}
void
Vulkan_IQM_Shutdown (vulkan_ctx_t *ctx)
{
iqmctx_t *ictx = ctx->iqm_context;
free (ictx->frames.a);
free (ictx);
}
Reference in a new issue Copy permalink