mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-12-11 13:21:10 +00:00
360 lines
10 KiB
C
360 lines
10 KiB
C
/*
|
|
vulkan_alias.c
|
|
|
|
Vulkan alias model pipeline
|
|
|
|
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/26
|
|
|
|
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/skin.h"
|
|
#include "QF/sys.h"
|
|
#include "QF/va.h"
|
|
|
|
#include "QF/scene/entity.h"
|
|
|
|
#include "QF/Vulkan/qf_alias.h"
|
|
#include "QF/Vulkan/qf_matrices.h"
|
|
#include "QF/Vulkan/qf_texture.h"
|
|
#include "QF/Vulkan/buffer.h"
|
|
#include "QF/Vulkan/command.h"
|
|
#include "QF/Vulkan/debug.h"
|
|
#include "QF/Vulkan/descriptor.h"
|
|
#include "QF/Vulkan/device.h"
|
|
#include "QF/Vulkan/instance.h"
|
|
#include "QF/Vulkan/renderpass.h"
|
|
|
|
#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;
|
|
} alias_push_constants_t;
|
|
|
|
static const char * __attribute__((used)) alias_pass_names[] = {
|
|
"depth",
|
|
"g-buffer",
|
|
"translucent",
|
|
};
|
|
|
|
static QFV_Subpass subpass_map[] = {
|
|
QFV_passDepth, // QFV_aliasDepth
|
|
QFV_passGBuffer, // QFV_aliasGBuffer
|
|
QFV_passTranslucent, // QFV_aliasTranslucent
|
|
};
|
|
|
|
static void
|
|
emit_commands (VkCommandBuffer cmd, int pose1, int pose2,
|
|
qfv_alias_skin_t *skin,
|
|
uint32_t numPC, qfv_push_constants_t *constants,
|
|
aliashdr_t *hdr, qfv_renderframe_t *rFrame)
|
|
{
|
|
vulkan_ctx_t *ctx = rFrame->vulkan_ctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
aliasctx_t *actx = ctx->alias_context;
|
|
|
|
__auto_type mesh = (qfv_alias_mesh_t *) ((byte *) hdr + hdr->commands);
|
|
|
|
VkDeviceSize offsets[] = {
|
|
pose1 * hdr->poseverts * sizeof (aliasvrt_t),
|
|
pose2 * hdr->poseverts * sizeof (aliasvrt_t),
|
|
0,
|
|
};
|
|
VkBuffer buffers[] = {
|
|
mesh->vertex_buffer,
|
|
mesh->vertex_buffer,
|
|
mesh->uv_buffer,
|
|
};
|
|
int bindingCount = skin ? 3 : 2;
|
|
|
|
dfunc->vkCmdBindVertexBuffers (cmd, 0, bindingCount, buffers, offsets);
|
|
dfunc->vkCmdBindIndexBuffer (cmd, mesh->index_buffer, 0,
|
|
VK_INDEX_TYPE_UINT32);
|
|
QFV_PushConstants (device, cmd, actx->layout, numPC, constants);
|
|
if (skin) {
|
|
VkDescriptorSet sets[] = {
|
|
skin->descriptor,
|
|
};
|
|
dfunc->vkCmdBindDescriptorSets (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
actx->layout, 1, 1, sets, 0, 0);
|
|
}
|
|
dfunc->vkCmdDrawIndexed (cmd, 3 * hdr->mdl.numtris, 1, 0, 0, 0);
|
|
}
|
|
|
|
void
|
|
Vulkan_DrawAlias (entity_t *ent, qfv_renderframe_t *rFrame)
|
|
{
|
|
vulkan_ctx_t *ctx = rFrame->vulkan_ctx;
|
|
aliasctx_t *actx = ctx->alias_context;
|
|
aliasframe_t *aframe = &actx->frames.a[ctx->curFrame];
|
|
model_t *model = ent->renderer.model;
|
|
aliashdr_t *hdr;
|
|
qfv_alias_skin_t *skin;
|
|
animation_t *animation = &ent->animation;
|
|
alias_push_constants_t constants = {};
|
|
|
|
if (!(hdr = model->aliashdr)) {
|
|
hdr = Cache_Get (&model->cache);
|
|
}
|
|
|
|
constants.blend = R_AliasGetLerpedFrames (animation, hdr);
|
|
|
|
qfv_push_constants_t push_constants[] = {
|
|
{ VK_SHADER_STAGE_VERTEX_BIT,
|
|
field_offset (alias_push_constants_t, mat),
|
|
sizeof (mat4f_t), Transform_GetWorldMatrixPtr (ent->transform) },
|
|
{ VK_SHADER_STAGE_VERTEX_BIT,
|
|
field_offset (alias_push_constants_t, blend),
|
|
sizeof (float), &constants.blend },
|
|
{ VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
field_offset (alias_push_constants_t, colorA),
|
|
sizeof (constants.colorA), constants.colorA },
|
|
{ VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
field_offset (alias_push_constants_t, colorB),
|
|
sizeof (constants.colorB), constants.colorB },
|
|
{ VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
field_offset (alias_push_constants_t, base_color),
|
|
sizeof (constants.base_color), &constants.base_color },
|
|
{ VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
field_offset (alias_push_constants_t, fog),
|
|
sizeof (constants.fog), &constants.fog },
|
|
};
|
|
|
|
if (0/*XXX ent->skin && ent->skin->tex*/) {
|
|
//skin = ent->skin->tex;
|
|
} else {
|
|
maliasskindesc_t *skindesc;
|
|
skindesc = R_AliasGetSkindesc (animation, ent->renderer.skinnum, hdr);
|
|
skin = (qfv_alias_skin_t *) ((byte *) hdr + skindesc->skin);
|
|
}
|
|
QuatCopy (ent->renderer.colormod, constants.base_color);
|
|
QuatCopy (skin->colora, constants.colorA);
|
|
QuatCopy (skin->colorb, constants.colorB);
|
|
QuatZero (constants.fog);
|
|
|
|
emit_commands (aframe->cmdSet.a[QFV_aliasDepth],
|
|
ent->animation.pose1, ent->animation.pose2,
|
|
0, 2, push_constants, hdr, rFrame);
|
|
emit_commands (aframe->cmdSet.a[QFV_aliasGBuffer],
|
|
ent->animation.pose1, ent->animation.pose2,
|
|
skin, 6, push_constants, hdr, rFrame);
|
|
}
|
|
|
|
static void
|
|
alias_begin_subpass (QFV_AliasSubpass subpass, VkPipeline pipeline,
|
|
qfv_renderframe_t *rFrame)
|
|
{
|
|
vulkan_ctx_t *ctx = rFrame->vulkan_ctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
aliasctx_t *actx = ctx->alias_context;
|
|
__auto_type cframe = &ctx->frames.a[ctx->curFrame];
|
|
aliasframe_t *aframe = &actx->frames.a[ctx->curFrame];
|
|
VkCommandBuffer cmd = aframe->cmdSet.a[subpass];
|
|
|
|
dfunc->vkResetCommandBuffer (cmd, 0);
|
|
VkCommandBufferInheritanceInfo inherit = {
|
|
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, 0,
|
|
rFrame->renderpass->renderpass, subpass_map[subpass],
|
|
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,
|
|
};
|
|
dfunc->vkBeginCommandBuffer (cmd, &beginInfo);
|
|
|
|
QFV_duCmdBeginLabel (device, cmd, va (ctx->va_ctx, "alias:%s",
|
|
alias_pass_names[subpass]),
|
|
{ 0.6, 0.5, 0, 1});
|
|
|
|
dfunc->vkCmdBindPipeline (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
|
|
VkDescriptorSet sets[] = {
|
|
Vulkan_Matrix_Descriptors (ctx, ctx->curFrame),
|
|
};
|
|
dfunc->vkCmdBindDescriptorSets (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
actx->layout, 0, 1, sets, 0, 0);
|
|
dfunc->vkCmdSetViewport (cmd, 0, 1, &ctx->viewport);
|
|
dfunc->vkCmdSetScissor (cmd, 0, 1, &ctx->scissor);
|
|
|
|
//XXX glsl_Fog_GetColor (fog);
|
|
//XXX fog[3] = glsl_Fog_GetDensity () / 64.0;
|
|
}
|
|
|
|
static void
|
|
alias_end_subpass (VkCommandBuffer cmd, vulkan_ctx_t *ctx)
|
|
{
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
QFV_duCmdEndLabel (device, cmd);
|
|
dfunc->vkEndCommandBuffer (cmd);
|
|
}
|
|
|
|
void
|
|
Vulkan_AliasBegin (qfv_renderframe_t *rFrame)
|
|
{
|
|
vulkan_ctx_t *ctx = rFrame->vulkan_ctx;
|
|
aliasctx_t *actx = ctx->alias_context;
|
|
aliasframe_t *aframe = &actx->frames.a[ctx->curFrame];
|
|
|
|
//XXX quat_t fog;
|
|
DARRAY_APPEND (&rFrame->subpassCmdSets[QFV_passDepth],
|
|
aframe->cmdSet.a[QFV_aliasDepth]);
|
|
DARRAY_APPEND (&rFrame->subpassCmdSets[QFV_passGBuffer],
|
|
aframe->cmdSet.a[QFV_aliasGBuffer]);
|
|
|
|
alias_begin_subpass (QFV_aliasDepth, actx->depth, rFrame);
|
|
alias_begin_subpass (QFV_aliasGBuffer, actx->gbuf, rFrame);
|
|
}
|
|
|
|
void
|
|
Vulkan_AliasEnd (qfv_renderframe_t *rFrame)
|
|
{
|
|
vulkan_ctx_t *ctx = rFrame->vulkan_ctx;
|
|
aliasctx_t *actx = ctx->alias_context;
|
|
aliasframe_t *aframe = &actx->frames.a[ctx->curFrame];
|
|
|
|
alias_end_subpass (aframe->cmdSet.a[QFV_aliasDepth], ctx);
|
|
alias_end_subpass (aframe->cmdSet.a[QFV_aliasGBuffer], ctx);
|
|
}
|
|
|
|
void
|
|
Vulkan_AliasDepthRange (qfv_renderframe_t *rFrame,
|
|
float minDepth, float maxDepth)
|
|
{
|
|
vulkan_ctx_t *ctx = rFrame->vulkan_ctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
aliasctx_t *actx = ctx->alias_context;
|
|
aliasframe_t *aframe = &actx->frames.a[ctx->curFrame];
|
|
|
|
VkViewport viewport = ctx->viewport;
|
|
viewport.minDepth = minDepth;
|
|
viewport.maxDepth = maxDepth;
|
|
|
|
dfunc->vkCmdSetViewport (aframe->cmdSet.a[QFV_aliasDepth], 0, 1,
|
|
&viewport);
|
|
dfunc->vkCmdSetViewport (aframe->cmdSet.a[QFV_aliasGBuffer], 0, 1,
|
|
&viewport);
|
|
}
|
|
|
|
void
|
|
Vulkan_AliasAddSkin (vulkan_ctx_t *ctx, qfv_alias_skin_t *skin)
|
|
{
|
|
aliasctx_t *actx = ctx->alias_context;
|
|
skin->descriptor = Vulkan_CreateCombinedImageSampler (ctx, skin->view,
|
|
actx->sampler);
|
|
}
|
|
|
|
void
|
|
Vulkan_AliasRemoveSkin (vulkan_ctx_t *ctx, qfv_alias_skin_t *skin)
|
|
{
|
|
Vulkan_FreeTexture (ctx, skin->descriptor);
|
|
skin->descriptor = 0;
|
|
}
|
|
|
|
void
|
|
Vulkan_Alias_Init (vulkan_ctx_t *ctx)
|
|
{
|
|
qfv_device_t *device = ctx->device;
|
|
|
|
qfvPushDebug (ctx, "alias init");
|
|
|
|
aliasctx_t *actx = calloc (1, sizeof (aliasctx_t));
|
|
ctx->alias_context = actx;
|
|
|
|
size_t frames = ctx->frames.size;
|
|
DARRAY_INIT (&actx->frames, frames);
|
|
DARRAY_RESIZE (&actx->frames, frames);
|
|
actx->frames.grow = 0;
|
|
|
|
actx->depth = Vulkan_CreateGraphicsPipeline (ctx, "alias_depth");
|
|
actx->gbuf = Vulkan_CreateGraphicsPipeline (ctx, "alias_gbuf");
|
|
actx->layout = Vulkan_CreatePipelineLayout (ctx, "alias_layout");
|
|
actx->sampler = Vulkan_CreateSampler (ctx, "alias_sampler");
|
|
|
|
for (size_t i = 0; i < frames; i++) {
|
|
__auto_type aframe = &actx->frames.a[i];
|
|
|
|
DARRAY_INIT (&aframe->cmdSet, QFV_aliasNumPasses);
|
|
DARRAY_RESIZE (&aframe->cmdSet, QFV_aliasNumPasses);
|
|
aframe->cmdSet.grow = 0;
|
|
|
|
QFV_AllocateCommandBuffers (device, ctx->cmdpool, 1, &aframe->cmdSet);
|
|
|
|
for (int j = 0; j < QFV_aliasNumPasses; j++) {
|
|
QFV_duSetObjectName (device, VK_OBJECT_TYPE_COMMAND_BUFFER,
|
|
aframe->cmdSet.a[j],
|
|
va (ctx->va_ctx, "cmd:alias:%zd:%s", i,
|
|
alias_pass_names[j]));
|
|
}
|
|
}
|
|
qfvPopDebug (ctx);
|
|
}
|
|
|
|
void
|
|
Vulkan_Alias_Shutdown (vulkan_ctx_t *ctx)
|
|
{
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
aliasctx_t *actx = ctx->alias_context;
|
|
|
|
for (size_t i = 0; i < actx->frames.size; i++) {
|
|
__auto_type aframe = &actx->frames.a[i];
|
|
free (aframe->cmdSet.a);
|
|
}
|
|
|
|
dfunc->vkDestroyPipeline (device->dev, actx->depth, 0);
|
|
dfunc->vkDestroyPipeline (device->dev, actx->gbuf, 0);
|
|
free (actx->frames.a);
|
|
free (actx);
|
|
}
|