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/qfpipeline.plist

950 lines
22 KiB
Text
Raw Normal View History

[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
{
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
samplers = {
quakepic = {
magFilter = nearest;
minFilter = nearest;
mipmapMode = nearest;
addressModeU = clamp_to_edge;
addressModeV = clamp_to_edge;
addressModeW = clamp_to_edge;
mipLodBias = 0;
[vulkan] Parse VkBool32 correctly as bool type This makes it much clearer whether something is just a flag or an index of some sort.
2021-01-12 04:07:51 +00:00
anisotropyEnable = false;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
maxAnisotropy = 0;
[vulkan] Parse VkBool32 correctly as bool type This makes it much clearer whether something is just a flag or an index of some sort.
2021-01-12 04:07:51 +00:00
compareEnable = false;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
compareOp = always;
minLod = 0;
[vulkan] Get the 2D pipeline up and running First pixels! This was a nightmare of little issues that the validation layers couldn't help with: incorrect input assembly, incorrect vertex attribute specs. Though the layers did help with getting the queues working. Still, lots of work to go but this is a major breakthrough as I now have access to visual debugging for textures and the like.
2021-01-12 02:27:41 +00:00
maxLod = 0;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
borderColor = float_transparent_black;
[vulkan] Switch to float/normalized for pics It gives better results when pics are squished or expanded.
2021-01-12 04:51:41 +00:00
unnormalizedCoordinates = false;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
};
[vulkan] 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
quakebsp_sampler = {
[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
magFilter = linear;
minFilter = linear;
mipmapMode = linear;
addressModeU = repeat;
addressModeV = repeat;
addressModeW = repeat;
mipLodBias = 0;
anisotropyEnable = false;
maxAnisotropy = 0;
compareEnable = false;
compareOp = always;
minLod = 0;
[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
maxLod = 4;
[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
borderColor = float_transparent_black;
unnormalizedCoordinates = false;
};
[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
alias_sampler = {
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
magFilter = linear;
minFilter = linear;
mipmapMode = linear;
addressModeU = clamp_to_edge;
addressModeV = clamp_to_edge;
addressModeW = clamp_to_edge;
mipLodBias = 0;
anisotropyEnable = false;
maxAnisotropy = 0;
compareEnable = false;
compareOp = always;
minLod = 0;
maxLod = 1000;
borderColor = float_transparent_black;
unnormalizedCoordinates = false;
};
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
shadow_sampler = {
magFilter = linear;
minFilter = linear;
mipmapMode = linear;
addressModeU = clamp_to_edge;
addressModeV = clamp_to_edge;
addressModeW = clamp_to_edge;
mipLodBias = 0;
anisotropyEnable = false;
maxAnisotropy = 0;
compareEnable = true;
compareOp = greater_or_equal;
minLod = 0;
maxLod = 1000;
borderColor = float_transparent_black;
unnormalizedCoordinates = false;
};
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
};
descriptorPools = {
[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
twod_pool = {
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
flags = 0;
[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
maxSets = $frames.size;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
bindings = (
{
type = uniform_buffer;
[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
descriptorCount = $frames.size;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
},
{
type = combined_image_sampler;
[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
descriptorCount = $frames.size;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
},
);
};
[vulkan] 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
alias_pool = {
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
flags = 0;
[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
maxSets = "2z * $frames.size";
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
bindings = (
{
type = uniform_buffer;
[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
descriptorCount = "2z * $frames.size";
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
},
);
};
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
lighting_attach_pool = {
flags = 0;
maxSets = $frames.size;
bindings = (
{
type = input_attachment;
[vulkan] Implement deferred emission (fullbrights) That was... easier than expected. A little more tedious that I would have liked, but my scripting system isn't perfect (I suspect it's best suited as the output of a code generator), and the C side could do with a little more automation.
2021-03-22 10:08:16 +00:00
descriptorCount = "5z * $frames.size";
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
},
);
};
lighting_lights_pool = {
flags = 0;
maxSets = $frames.size;
bindings = (
{
type = uniform_buffer;
descriptorCount = $frames.size;
},
);
};
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
lighting_shadow_pool = {
flags = 0;
maxSets = $frames.size;
bindings = (
{
type = combined_image_sampler;
descriptorCount = "$frames.size * 256z";
},
);
};
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
compose_attach_pool = {
flags = 0;
maxSets = $frames.size;
bindings = (
{
type = input_attachment;
descriptorCount = "2z * $frames.size";
},
);
};
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
};
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
setLayouts = {
[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
twod_set = {
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
bindings = (
{
binding = 0;
descriptorType = uniform_buffer;
descriptorCount = 1;
stageFlags = vertex;
},
{
binding = 1;
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
);
};
[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
quakebsp_set = {
[vulkan] Use vkCmdPushDescriptorSetKHR for bsp This makes switching textures on the fly much easier.
2021-01-21 03:39:08 +00:00
flags = push_descriptor;
[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
bindings = (
{
binding = 0;
descriptorType = uniform_buffer;
descriptorCount = 1;
[vulkan] Add a position buffer to the g-buffer While I could reconstruct the position from the screen coords and depth, this is easier and good enough for now. Reconstruction is an optimization thing.
2021-02-25 04:46:33 +00:00
stageFlags = vertex|geometry;
[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
},
{
binding = 1;
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
{
binding = 2;
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
{
binding = 3;
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
[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] 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
binding = 4;
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
[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
{
[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
binding = 5;
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
[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] 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] 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
alias_set = {
[vulkan] Switch over to pushed descriptors I don't really know why (I need to do some research), but this fixes the lockups when accessing the matrices UBO. It has made a mess of my carefully designed uniform binding layout, so I hope I can get bound descriptor sets working the way I want, but I really need to progress on the rest of the project.
2021-01-28 01:49:23 +00:00
flags = push_descriptor;
bindings = (
{
binding = 0;
descriptorType = uniform_buffer;
descriptorCount = 1;
stageFlags = vertex;
},
{
binding = 1;
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
);
};
[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
alias_matrices = {
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
bindings = (
{
binding = 0;
descriptorType = uniform_buffer;
descriptorCount = 1;
stageFlags = vertex;
},
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
);
};
[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
alias_textures = {
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
flags = push_descriptor;
bindings = (
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
{
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
binding = 0;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
{
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
binding = 1;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
{
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
binding = 2;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
{
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
binding = 3;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
descriptorType = combined_image_sampler;
descriptorCount = 1;
stageFlags = fragment;
},
);
};
[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
alias_lights = {
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
bindings = (
{
binding = 0;
descriptorType = uniform_buffer;
descriptorCount = 1;
stageFlags = fragment;
},
);
};
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
lighting_attach = {
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
bindings = (
{
binding = 0;
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
descriptorType = input_attachment;
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
descriptorCount = 1;
stageFlags = fragment;
},
{
binding = 1;
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
descriptorType = input_attachment;
descriptorCount = 1;
stageFlags = fragment;
},
{
binding = 2;
descriptorType = input_attachment;
descriptorCount = 1;
stageFlags = fragment;
},
[vulkan] Add a position buffer to the g-buffer While I could reconstruct the position from the screen coords and depth, this is easier and good enough for now. Reconstruction is an optimization thing.
2021-02-25 04:46:33 +00:00
{
binding = 3;
descriptorType = input_attachment;
descriptorCount = 1;
stageFlags = fragment;
},
[vulkan] Implement deferred emission (fullbrights) That was... easier than expected. A little more tedious that I would have liked, but my scripting system isn't perfect (I suspect it's best suited as the output of a code generator), and the C side could do with a little more automation.
2021-03-22 10:08:16 +00:00
{
binding = 4;
descriptorType = input_attachment;
descriptorCount = 1;
stageFlags = fragment;
},
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
);
};
lighting_lights = {
bindings = (
{
binding = 0;
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
descriptorType = uniform_buffer;
descriptorCount = 1;
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
stageFlags = fragment;
},
);
};
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
lighting_shadow = {
bindings = (
{
binding = 0;
descriptorType = combined_image_sampler;
descriptorCount = 256;
stageFlags = fragment;
},
);
};
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
compose_attach = {
bindings = (
{
binding = 0;
descriptorType = input_attachment;
descriptorCount = 1;
stageFlags = fragment;
},
{
binding = 1;
descriptorType = input_attachment;
descriptorCount = 1;
stageFlags = fragment;
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
},
);
};
};
pipelineLayouts = {
[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
twod_layout = {
setLayouts = (twod_set);
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
};
[vulkan] 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
quakebsp_layout = {
setLayouts = (quakebsp_set);
[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
pushConstantRanges = (
{
stageFlags = vertex;
offset = 0;
size = "16 * 4";
},
{
stageFlags = fragment;
[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
offset = 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
size = 32;
},
);
};
[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
alias_layout = {
//setLayouts = (alias_matrices, alias_lights, alias_textures);
setLayouts = (alias_set);
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
pushConstantRanges = (
{
stageFlags = vertex;
offset = 0;
size = "16 * 4 + 4";
},
{
stageFlags = fragment;
[vulkan] Implement team colors It's not quite as expected, but that may be due to one of msaa, the 0-15 range in the palette not being all the way to white, the color gradients being not quite linear (haven't checked yet) or some combination of the above. However, it's that what should be yellow is more green. At least the zombies are no longer white and the ogres don't look like they're wearing skeleton suits.
2021-02-02 10:53:36 +00:00
offset = 68;
size = "3 * 4 + 2 * 4 * 4";
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
},
);
};
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
lighting_layout = {
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
setLayouts = (lighting_attach, lighting_lights, lighting_shadow);
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
};
compose_layout = {
setLayouts = (compose_attach);
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
};
};
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
depthStencil = {
test_and_write = {
depthTestEnable = true;
depthWriteEnable = true;
depthCompareOp = less_or_equal;
depthBoundsTestEnable = false;
stencilTestEnable = false;
};
test_only = {
depthTestEnable = true;
depthWriteEnable = false;
depthCompareOp = less_or_equal;
depthBoundsTestEnable = false;
stencilTestEnable = false;
};
disable = {
depthTestEnable = false;
depthWriteEnable = false;
depthCompareOp = less_or_equal;
depthBoundsTestEnable = false;
stencilTestEnable = false;
};
};
inputAssembly = {
alias = {
topology = triangle_list;
primitiveRestartEnable = false;
};
brush = {
topology = triangle_fan;
primitiveRestartEnable = true;
};
twod = {
topology = triangle_strip;
primitiveRestartEnable = true;
};
};
vertexInput = {
alias = {
bindings = (
{ binding = 0; stride = "2 * 4 * 4"; inputRate = vertex; },
{ binding = 1; stride = "2 * 4 * 4"; inputRate = vertex; },
{ binding = 2; stride = "2 * 4"; inputRate = vertex; },
);
attributes = (
{ location = 0; binding = 0; format = r32g32b32a32_sfloat; offset = 0; },
{ location = 1; binding = 0; format = r32g32b32a32_sfloat; offset = 16; },
{ location = 2; binding = 1; format = r32g32b32a32_sfloat; offset = 0; },
{ location = 3; binding = 1; format = r32g32b32a32_sfloat; offset = 16; },
{ location = 4; binding = 2; format = r32g32_sfloat; offset = 0; },
);
};
brush = {
bindings = (
{ binding = 0; stride = "2 * 4 * 4"; inputRate = vertex; },
);
attributes = (
{ location = 0; binding = 0; format = r32g32b32a32_sfloat; offset = 0; },
{ location = 1; binding = 0; format = r32g32b32a32_sfloat; offset = 16; },
);
};
twod = {
bindings = (
{ binding = 0; stride = "2 * 4 * 4"; inputRate = vertex; },
);
attributes = (
{ location = 0; binding = 0; format = r32g32_sfloat; offset = 0; },
{ location = 1; binding = 0; format = r32g32_sfloat; offset = 8; },
{ location = 2; binding = 0; format = r32g32b32a32_sfloat; offset = 16; },
);
};
};
rasterization = {
cw_cull_back = {
depthClampEnable = false;
rasterizerDiscardEnable = false;
polygonMode = fill;
cullMode = back;
frontFace = clockwise;
depthBiasEnable = false;
lineWidth = 1;
};
counter_cw_cull_back = {
depthClampEnable = false;
rasterizerDiscardEnable = false;
polygonMode = fill;
cullMode = back;
frontFace = counter_clockwise;
depthBiasEnable = false;
lineWidth = 1;
};
};
multisample = {
rasterizationSamples = $msaaSamples;
sampleShadingEnable = false;
minSampleShading = 0.5f;
alphaToCoverageEnable = false;
alphaToOneEnable = false;
};
viewport = {
viewports = (
{
x = 0; y = 0;
width = 640; height = 480;
minDepth = 0; maxDepth = 1;
}
);
scissors = (
{
offset = { x = 0; y = 0 };
extent = { width = 640; height = 480; };
},
);
};
attachmentBlendOp = {
disabled = {
blendEnable = false;
srcColorBlendFactor = src_alpha;
dstColorBlendFactor = one_minus_src_alpha;
colorBlendOp = add;
srcAlphaBlendFactor = src_alpha;
dstAlphaBlendFactor = one_minus_src_alpha;
alphaBlendOp = add;
colorWriteMask = r|g|b|a;
};
alpha_blend = {
blendEnable = true;
srcColorBlendFactor = src_alpha;
dstColorBlendFactor = one_minus_src_alpha;
colorBlendOp = add;
srcAlphaBlendFactor = src_alpha;
dstAlphaBlendFactor = one_minus_src_alpha;
alphaBlendOp = add;
colorWriteMask = r|g|b|a;
};
};
fsquad = {
vertexInput = {
bindings = (
{ binding = 0; stride = "4 * 4"; inputRate = vertex; },
);
attributes = (
{ location = 0; binding = 0; format = r32g32b32a32_sfloat; offset = 0; },
);
};
inputAssembly = {
topology = triangle_strip;
primitiveRestartEnable = false;
};
colorBlend = {
logicOpEnable = false;
attachments = ($properties.attachmentBlendOp.disabled);
};
};
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
pipelines = {
[vulkan] Start work on shadows This gets the shaders needed for creating shadow maps, and the changes to the lighting pipeline for binding the shadow maps, but no generation or reading is done yet. It feels like parts of various systems are getting a little big for their britches and I need to do an audit of various things.
2021-04-24 01:40:39 +00:00
alias_shadow = {
subpass = 0;
stages = (
{
stage = vertex;
name = main;
module = $builtin/alias_shadow.vert;
},
);
vertexInput = {
bindings = (
"$properties.vertexInput.alias.bindings[0]",
"$properties.vertexInput.alias.bindings[1]",
);
attributes = (
"$properties.vertexInput.alias.attributes[0]",
"$properties.vertexInput.alias.attributes[1]",
"$properties.vertexInput.alias.attributes[2]",
"$properties.vertexInput.alias.attributes[3]",
);
};
inputAssembly = $properties.inputAssembly.alias;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_and_write;
colorBlend = $properties.pipelines.alias_gbuf.colorBlend;
dynamic = {
dynamicState = ( viewport, scissor );
};
layout = alias_layout;
};
bsp_shadow = {
subpass = 0;
stages = (
{
stage = vertex;
name = main;
module = $builtin/bsp_shadow.vert;
},
);
vertexInput = {
bindings = (
"$properties.vertexInput.brush.bindings[0]",
);
attributes = (
"$properties.vertexInput.brush.attributes[0]",
);
};
inputAssembly = $properties.inputAssembly.brush;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_and_write;
colorBlend = $properties.pipelines.bsp_gbuf.colorBlend;
dynamic = {
dynamicState = ( viewport, scissor );
};
layout = quakebsp_layout;
//renderPass = renderpass;
};
[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
alias_depth = {
[vulkan] Specify subpass number in pipeline def This gets the alias model render pass and pipeline passing validation. I don't know why I didn't add the subpass field to the VkGraphicsPipelineCreateInfo parser def, though it could be I simply missed it, or I thought I wouldn't need it at the time.
2021-02-17 04:50:36 +00:00
subpass = 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
stages = (
{
stage = vertex;
name = main;
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
module = $builtin/alias_depth.vert;
[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
},
);
vertexInput = {
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
// depth pass doesn't use UVs
[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
bindings = (
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
"$properties.vertexInput.alias.bindings[0]",
"$properties.vertexInput.alias.bindings[1]",
[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
);
attributes = (
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
"$properties.vertexInput.alias.attributes[0]",
"$properties.vertexInput.alias.attributes[1]",
"$properties.vertexInput.alias.attributes[2]",
"$properties.vertexInput.alias.attributes[3]",
[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 the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
inputAssembly = $properties.inputAssembly.alias;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_and_write;
colorBlend = $properties.pipelines.alias_gbuf.colorBlend;
[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
dynamic = {
dynamicState = ( viewport, scissor );
};
layout = alias_layout;
//renderPass = renderpass;
};
alias_gbuf = {
[vulkan] Fix sky depth issues There were actually several problems: translucency wasn't using or depending on the depth buffer, and the depth buffer wasn't marked as read-only in the g-buffer pass. Getting that correct seems to have given bigass1 a 0.5% boost (hard to say, could be the usual noise).
2021-03-23 02:26:24 +00:00
subpass = 2;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
stages = (
[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
{
stage = vertex;
name = main;
module = $builtin/alias.vert;
},
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
{
stage = fragment;
name = main;
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
module = $builtin/alias_gbuf.frag;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
specializationInfo = {
mapEntries = (
{ size = 4; offset = 0; constantID = 0; },
);
[vulkan] Start work on alias model rendering
2021-01-26 11:58:24 +00:00
data = <00000008>;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
};
},
);
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
vertexInput = $properties.vertexInput.alias;
inputAssembly = $properties.inputAssembly.alias;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_only;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
colorBlend = {
logicOpEnable = false;
[vulkan] Specify subpass number in pipeline def This gets the alias model render pass and pipeline passing validation. I don't know why I didn't add the subpass field to the VkGraphicsPipelineCreateInfo parser def, though it could be I simply missed it, or I thought I wouldn't need it at the time.
2021-02-17 04:50:36 +00:00
attachments = (
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
$properties.attachmentBlendOp.disabled,
$properties.attachmentBlendOp.disabled,
$properties.attachmentBlendOp.disabled,
$properties.attachmentBlendOp.disabled,
[vulkan] Specify subpass number in pipeline def This gets the alias model render pass and pipeline passing validation. I don't know why I didn't add the subpass field to the VkGraphicsPipelineCreateInfo parser def, though it could be I simply missed it, or I thought I wouldn't need it at the time.
2021-02-17 04:50:36 +00:00
);
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
};
dynamic = {
dynamicState = ( viewport, scissor, blend_constants );
};
[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
layout = alias_layout;
[vulkan] Start work on the alias pipeline
2021-01-25 15:55:45 +00:00
//renderPass = renderpass;
};
[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_depth = {
[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
subpass = 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
stages = (
{
stage = vertex;
name = main;
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
module = $builtin/bsp_depth.vert;
[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
},
);
vertexInput = {
bindings = (
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
"$properties.vertexInput.brush.bindings[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
);
attributes = (
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
"$properties.vertexInput.brush.attributes[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
);
};
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
inputAssembly = $properties.inputAssembly.brush;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_and_write;
colorBlend = $properties.pipelines.bsp_gbuf.colorBlend;
[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
dynamic = {
dynamicState = ( viewport, scissor );
};
layout = quakebsp_layout;
//renderPass = renderpass;
};
bsp_gbuf = {
[vulkan] Fix sky depth issues There were actually several problems: translucency wasn't using or depending on the depth buffer, and the depth buffer wasn't marked as read-only in the g-buffer pass. Getting that correct seems to have given bigass1 a 0.5% boost (hard to say, could be the usual noise).
2021-03-23 02:26:24 +00:00
subpass = 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
stages = (
[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
{
stage = vertex;
name = main;
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
module = $builtin/bsp_gbuf.vert;
[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
},
[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
{
stage = geometry;
name = main;
module = $builtin/bsp_gbuf.geom;
},
[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
{
stage = fragment;
name = main;
[vulkan] Create shaders for alias deferred rendering A simple (no uv output) vertex shader that still blends the two frames, and the relevant g-buffer fragment shader.
2021-02-17 04:35:19 +00:00
module = $builtin/bsp_gbuf.frag;
[vulkan] Implement deferred lighting for dlights Static lights are yet to come (so the screen is black most of the time), but dynamic lights work very nicely (and look very good) despite the falloff being incorrect.
2021-02-25 06:51:54 +00:00
specializationInfo = {
mapEntries = (
{ size = 4; offset = 0; constantID = 0; },
{ size = 4; offset = 0; constantID = 1; },
{ size = 4; offset = 0; constantID = 2; },
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
{ size = 4; offset = 0; constantID = 3; },
[vulkan] Implement deferred lighting for dlights Static lights are yet to come (so the screen is black most of the time), but dynamic lights work very nicely (and look very good) despite the falloff being incorrect.
2021-02-25 06:51:54 +00:00
);
data = <00000000ffffffff>;
};
[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
},
[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] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
vertexInput = $properties.vertexInput.brush;
inputAssembly = $properties.inputAssembly.brush;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_only;
[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
colorBlend = {
logicOpEnable = false;
[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
attachments = (
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
$properties.attachmentBlendOp.disabled,
$properties.attachmentBlendOp.disabled,
$properties.attachmentBlendOp.disabled,
$properties.attachmentBlendOp.disabled,
[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
);
[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
};
dynamic = {
dynamicState = ( viewport, scissor, blend_constants );
};
[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
layout = quakebsp_layout;
[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
//renderPass = renderpass;
};
[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_skybox = {
subpass = 1;
stages = (
{
stage = vertex;
name = main;
module = $builtin/quakebsp.vert;
},
{
stage = fragment;
name = main;
module = $builtin/bsp_sky.frag;
specializationInfo = {
mapEntries = (
{ size = 4; offset = 0; constantID = 1; },
{ size = 4; offset = 4; constantID = 0; },
);
data = <00000000ffffffff>;
};
},
);
vertexInput = $properties.vertexInput.brush;
inputAssembly = $properties.inputAssembly.brush;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_only;
colorBlend = {
logicOpEnable = false;
attachments = ($properties.attachmentBlendOp.disabled);
};
dynamic = {
dynamicState = ( viewport, scissor );
};
layout = quakebsp_layout;
//renderPass = renderpass;
};
[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_skysheet = {
[vulkan] Fix sky depth issues There were actually several problems: translucency wasn't using or depending on the depth buffer, and the depth buffer wasn't marked as read-only in the g-buffer pass. Getting that correct seems to have given bigass1 a 0.5% boost (hard to say, could be the usual noise).
2021-03-23 02:26:24 +00:00
subpass = 1;
[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
stages = (
[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
{
stage = vertex;
name = main;
[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
module = $builtin/quakebsp.vert;
[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
},
[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
{
stage = fragment;
name = main;
[vulkan] Fix up commands for deferred rendering Nothing gets output yet (lighting and composite passes not implemented), but everything passes validation until exit (not destroying everything).
2021-02-23 06:43:02 +00:00
module = $builtin/bsp_sky.frag;
[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
specializationInfo = {
mapEntries = (
[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
{ size = 4; offset = 0; constantID = 0; },
{ size = 4; offset = 4; constantID = 1; },
);
data = <00000000ffffffff>;
};
},
);
vertexInput = $properties.vertexInput.brush;
inputAssembly = $properties.inputAssembly.brush;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_only;
colorBlend = {
logicOpEnable = false;
attachments = ($properties.attachmentBlendOp.disabled);
};
dynamic = {
dynamicState = ( viewport, scissor );
};
layout = quakebsp_layout;
//renderPass = renderpass;
};
bsp_turb = {
subpass = 1;
stages = (
{
stage = vertex;
name = main;
module = $builtin/quakebsp.vert;
},
{
stage = fragment;
name = main;
module = $builtin/bsp_turb.frag;
specializationInfo = {
mapEntries = (
[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
{ size = 4; offset = 0; constantID = 0; },
[vulkan] Fix up commands for deferred rendering Nothing gets output yet (lighting and composite passes not implemented), but everything passes validation until exit (not destroying everything).
2021-02-23 06:43:02 +00:00
{ size = 4; offset = 4; constantID = 1; },
[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
);
data = <00000000ffffffff>;
};
},
);
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
vertexInput = $properties.vertexInput.brush;
inputAssembly = $properties.inputAssembly.brush;
viewport = $properties.viewport;
rasterization = $properties.rasterization.cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.test_only;
[vulkan] Fix up commands for deferred rendering Nothing gets output yet (lighting and composite passes not implemented), but everything passes validation until exit (not destroying everything).
2021-02-23 06:43:02 +00:00
colorBlend = {
logicOpEnable = false;
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
attachments = ($properties.attachmentBlendOp.disabled);
[vulkan] Fix up commands for deferred rendering Nothing gets output yet (lighting and composite passes not implemented), but everything passes validation until exit (not destroying everything).
2021-02-23 06:43:02 +00:00
};
[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
dynamic = {
[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
dynamicState = ( viewport, scissor );
[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] 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
layout = quakebsp_layout;
[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
//renderPass = renderpass;
};
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
twod = {
[vulkan] Fix sky depth issues There were actually several problems: translucency wasn't using or depending on the depth buffer, and the depth buffer wasn't marked as read-only in the g-buffer pass. Getting that correct seems to have given bigass1 a 0.5% boost (hard to say, could be the usual noise).
2021-03-23 02:26:24 +00:00
subpass = 1;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
stages = (
[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
{
stage = vertex;
name = main;
module = $builtin/twod.vert;
},
{
stage = fragment;
name = main;
module = $builtin/twod.frag;
},
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
);
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
vertexInput = $properties.vertexInput.twod;
inputAssembly = $properties.inputAssembly.twod;
viewport = $properties.viewport;
rasterization = $properties.rasterization.counter_cw_cull_back;
multisample = $properties.multisample;
[vulkan] Fix sky depth issues There were actually several problems: translucency wasn't using or depending on the depth buffer, and the depth buffer wasn't marked as read-only in the g-buffer pass. Getting that correct seems to have given bigass1 a 0.5% boost (hard to say, could be the usual noise).
2021-03-23 02:26:24 +00:00
depthStencil = $properties.depthStencil.test_only;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
colorBlend = {
[vulkan] Parse VkBool32 correctly as bool type This makes it much clearer whether something is just a flag or an index of some sort.
2021-01-12 04:07:51 +00:00
logicOpEnable = false;
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
attachments = ($properties.attachmentBlendOp.alpha_blend);
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
};
dynamic = {
dynamicState = ( viewport, scissor );
};
[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
layout = twod_layout;
[vulkan] Make a start on the 2D pipeline Short wrappers for Draw functins are in vid_render_vulkan.c so the vulkan context can be passed on to the actual functions. The 2D shaders are set up similar to those in glsl, but with full 32-bit color (rgba) support instead of paletted. However, the textures are not loaded yet, nor is anything bound.
2021-01-10 06:52:27 +00:00
//renderPass = renderpass;
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
};
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
lighting = {
[vulkan] Fix sky depth issues There were actually several problems: translucency wasn't using or depending on the depth buffer, and the depth buffer wasn't marked as read-only in the g-buffer pass. Getting that correct seems to have given bigass1 a 0.5% boost (hard to say, could be the usual noise).
2021-03-23 02:26:24 +00:00
subpass = 3;
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
stages = (
{
stage = vertex;
name = main;
module = $builtin/passthrough.vert;
},
{
stage = fragment;
name = main;
module = $builtin/lighting.frag;
},
);
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
vertexInput = $properties.fsquad.vertexInput;
inputAssembly = $properties.fsquad.inputAssembly;
viewport = $properties.viewport;
rasterization = $properties.rasterization.counter_cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.disable;
colorBlend = $properties.fsquad.colorBlend;
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
dynamic = {
dynamicState = ( viewport, scissor );
};
layout = lighting_layout;
//renderPass = renderpass;
};
compose = {
subpass = 4;
stages = (
{
stage = vertex;
name = main;
module = $builtin/passthrough.vert;
},
{
stage = fragment;
name = main;
module = $builtin/compose.frag;
},
);
[vulkan] Clean up the pipeline specifications While being able to write pipeline specs like this was the end goal of the parsing sub-project, I didn't realize it was already usable. This sure makes going through the pipeline specs much easier.
2021-03-23 01:01:13 +00:00
vertexInput = $properties.fsquad.vertexInput;
inputAssembly = $properties.fsquad.inputAssembly;
viewport = $properties.viewport;
rasterization = $properties.rasterization.counter_cw_cull_back;
multisample = $properties.multisample;
depthStencil = $properties.depthStencil.disable;
colorBlend = $properties.fsquad.colorBlend;
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
dynamic = {
dynamicState = ( viewport, scissor );
};
layout = compose_layout;
//renderPass = renderpass;
};
[vulkan] Remove renderpass from generated code The creation of a render pass seems to need special handling.
2021-01-05 08:43:26 +00:00
};
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
}
Reference in a new issue Copy permalink