ecker/engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Commit for 2022.07.20 00-37-19.7z

Browse Source
This commit is contained in:
mrq 2022-07-20 00:37:00 -05:00
parent 686a4f5e3e
commit 64dd96692c
56 changed files with 752 additions and 708 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@ -42,7 +42,8 @@ EXT_LIB_NAME += ext
#VULKAN_SDK_PATH += /c/VulkanSDK/1.2.182.0/
#VULKAN_SDK_PATH += /c/VulkanSDK/1.2.198.1/
#VULKAN_SDK_PATH += /c/VulkanSDK/1.3.204.1/
VULKAN_SDK_PATH += /c/VulkanSDK/1.3.211.0/
#VULKAN_SDK_PATH += /c/VulkanSDK/1.3.211.0/
VULKAN_SDK_PATH += /c/VulkanSDK/1.3.216.0/
GLSLC += $(VULKAN_SDK_PATH)/Bin/glslc
SPV_OPTIMIZER += $(VULKAN_SDK_PATH)/Bin/spirv-opt

15
bin/data/config.json
View File

@ -37,7 +37,7 @@
"granularity": 12,
"voxelizeScale": 1,
"occlusionFalloff": 2,
"traceStartOffsetFactor": 2,
"traceStartOffsetFactor": 2.5,
"shadows": 0,
"extents": {
"min": [ -8, -4, -8 ],
@ -97,15 +97,11 @@
"rebuild on tick begin": false,
"dedicated thread": false
},
"invariant": {
// "multithreaded recording": true
"deferred alias output to swapchain": false,
"defaultStageBuffers": true
},
"invariant": {},
"pipelines": {
"deferred": true,
"vsync": false,
"hdr": false,
"hdr": true,
"vxgi": true,
"culling": true,
"bloom": false,
@ -113,7 +109,7 @@
},
"formats": {
"depth": "D32_SFLOAT",
"color": "R8G8B8A8_UNORM", // "R32G32B32A32_SFLOAT",
"color": "R16G16B16A16_SFLOAT", // "R32G32B32A32_SFLOAT",
"normal": "R16G16B16A16_SFLOAT",
"position": "R16G16B16A16_SFLOAT"
},
@ -166,7 +162,8 @@
"VK_KHR_spirv_1_4",
"VK_KHR_shader_float_controls",
"VK_KHR_shader_clock",
"VK_KHR_ray_query"
"VK_KHR_ray_query",
"VK_KHR_fragment_shader_barycentric"
]
}
},

2
bin/data/scenes/scene.json
View File

@ -39,7 +39,7 @@
"ambient": [ 0.0, 0.0, 0.0 ],
// "ambient": [ 0.1, 0.1, 0.2 ],
"exposure": 1.0,
"exposure": 0.25,
"gamma": 2.2,
"brightnessThreshold": 1.2,

2
bin/data/shaders/common/structs.h
View File

@ -196,7 +196,7 @@ struct Surface {
#if MULTISAMPLING
struct MSAA {
int currentID;
uvec2 IDs[MAX_MSAA_SAMPLES];
uvec3 IDs[MAX_MSAA_SAMPLES];
vec4 fragment;
vec4 fragments[MAX_MSAA_SAMPLES];
} msaa;

75
bin/data/shaders/display/renderTarget.h
View File

@ -1,75 +0,0 @@
#include "../common/macros.h"
#define TEXTURES 1
#define CUBEMAPS 1
#if 1
#if !MULTISAMPLING
layout (binding = 1) uniform sampler2D samplerAlbedo;
#else
layout (binding = 1) uniform sampler2DMS samplerAlbedo;
#endif
#include "../common/structs.h"
#include "../common/functions.h"
layout (location = 0) in vec2 inUv;
layout (location = 1) in float inAlpha;
layout (location = 2) in Cursor inCursor;
layout (location = 0) out vec4 outAlbedo;
void main() {
#if !MULTISAMPLING
outAlbedo = texture( samplerAlbedo, inUv );
#else
outAlbedo = resolve( samplerAlbedo, ivec2(inUv * textureSize(samplerAlbedo)) );
#endif
if ( inAlpha < 1.0 ) outAlbedo.a = inAlpha;
}
#else
#if !MULTISAMPLING
layout (binding = 1) uniform usampler2D samplerId;
layout (binding = 2) uniform sampler2D samplerNormals;
#if DEFERRED_SAMPLING
layout (binding = 3) uniform sampler2D samplerUvs;
#else
layout (binding = 3) uniform sampler2D samplerAlbedo;
#endif
#else
layout (binding = 1) uniform usampler2DMS samplerId;
layout (binding = 2) uniform sampler2DMS samplerNormals;
#if DEFERRED_SAMPLING
layout (binding = 3) uniform sampler2DMS samplerUvs;
#else
layout (binding = 3) uniform sampler2DMS samplerAlbedo;
#endif
#endif
#include "../common/structs.h"
#include "../common/functions.h"
layout (location = 0) in vec2 inUv;
layout (location = 1) in float inAlpha;
layout (location = 2) in Cursor inCursor;
layout (location = 0) out vec4 outAlbedo;
void main() {
#if DEFERRED_SAMPLING
#else
#if !MULTISAMPLING
outAlbedo = texture( samplerAlbedo, inUv );
#else
outAlbedo = resolve( samplerAlbedo, ivec2(inUv * textureSize(samplerId)) );
#endif
#endif
if ( inCursor.radius.x <= 0 || inCursor.radius.y <= 0 ) return;
float dist = pow(inUv.x - inCursor.position.x, 2) / pow(inCursor.radius.x, 2) + pow(inUv.y - inCursor.position.y, 2) / pow(inCursor.radius.y, 2);
if ( dist <= 1 ) {
float attenuation = dist;
outAlbedo.rgb = mix( inCursor.color.rgb * inCursor.color.a, outAlbedo.rgb, attenuation );
}
if ( inAlpha < 1.0 ) outAlbedo.a = inAlpha;
}
#endif

265
bin/data/shaders/display/renderTarget.postProcess.frag.glsl Normal file
View File

@ -0,0 +1,265 @@
#version 450
#pragma shader_stage(fragment)
#extension GL_EXT_samplerless_texture_functions : require
layout (location = 0) in vec2 inUv;
layout (location = 1) flat in uint inPass;
layout (location = 0) out vec4 fragColor;
layout (binding = 0) uniform sampler2D samplerAlbedo;
layout (binding = 1) uniform UBO {
float curTime;
} ubo;
#define PI 3.14159265358
#if 0
float iTime = 0;
float noise(vec2 p) {
float s = (fract(sin(dot(p * sin( iTime * 0.5 ), vec2(12.9898,78.233)*2.0)) * 43758.5453)); // texture(iChannel1,vec2(1.,2.*cos(iTime))*iTime*8. + p*1.).x;
s *= s;
return s;
}
float onOff(float a, float b, float c) {
return step(c, sin(iTime + a*cos(iTime*b)));
}
float ramp(float y, float start, float end) {
float inside = step(start,y) - step(end,y);
float fact = (y-start)/(end-start)*inside;
return (1.-fact) * inside;
}
float stripes(vec2 uv) {
float noi = noise(uv*vec2(0.5,1.) + vec2(1.,3.));
return ramp(mod(uv.y*4. + iTime/2.+sin(iTime + sin(iTime*0.63)),1.),0.5,0.6)*noi;
}
vec3 getVideo(vec2 uv) {
vec2 look = uv;
float window = 1./(1.+20.*(look.y-mod(iTime/4.,1.))*(look.y-mod(iTime/4.,1.)));
look.x = look.x + sin(look.y*10. + iTime)/50.*onOff(4.,4.,.3)*(1.+cos(iTime*80.))*window;
float vShift = 0.4*onOff(2.,3.,.9)*(sin(iTime)*sin(iTime*20.) +
(0.5 + 0.1*sin(iTime*200.)*cos(iTime)));
look.y = mod(look.y + vShift, 1.);
vec3 video = vec3(texture(samplerAlbedo,look));
return video;
}
vec2 screenDistort(vec2 uv) {
uv -= vec2(.5,.5);
uv = uv*1.2*(1./1.2+2.*uv.x*uv.x*uv.y*uv.y);
uv += vec2(.5,.5);
return uv;
}
void main() {
vec2 uv = inUv.xy; // fragCoord.xy / iResolution.xy;
iTime = ubo.curTime;
uv = screenDistort(uv);
vec3 video = getVideo(uv);
float vigAmt = 3.+.3*sin(iTime + 5.*cos(iTime*5.));
float vignette = (1.-vigAmt*(uv.y-.5)*(uv.y-.5))*(1.-vigAmt*(uv.x-.5)*(uv.x-.5));
video += stripes(uv);
video += noise(uv*2.)/2.;
video *= vignette;
video *= (12.+mod(uv.y*30.+iTime,1.))/13.;
fragColor = vec4(video,1.0);
}
#endif
#if 1
vec2 curveRemapUV(vec2 uv, vec2 curvature) {
uv = uv * 2.0 - 1.0;
vec2 offset = abs(uv.yx) / vec2(curvature.x, curvature.y);
uv = uv + uv * offset * offset;
uv = uv * 0.5 + 0.5;
return uv;
}
vec4 scanLineIntensity(float uv, float resolution, float opacity) {
float intensity = sin(uv * resolution * PI * 2.0);
intensity = ((0.5 * intensity) + 0.5) * 0.9 + 0.1;
return vec4(vec3(pow(intensity, opacity)), 1.0);
}
vec4 vignetteIntensity(vec2 uv, vec2 resolution, float opacity, float roundness) {
float intensity = uv.x * uv.y * (1.0 - uv.x) * (1.0 - uv.y);
return vec4(vec3(clamp(pow((resolution.x / roundness) * intensity, opacity), 0.0, 1.0)), 1.0);
}
void main(void) {
const vec2 screenResolution = textureSize( samplerAlbedo, 0 ) * 0.75;
const vec2 scanLineOpacity = vec2(1,1);
const float brightness = 1;
const float vignetteOpacity = 1;
const float vignetteRoundness = 1;
const vec2 curvature = vec2(3.0, 3.0);
const vec2 remappedUV = curveRemapUV(vec2(inUv.x, inUv.y), curvature);
vec4 baseColor = texture(samplerAlbedo, remappedUV);
baseColor *= vignetteIntensity(remappedUV, screenResolution, vignetteOpacity, vignetteRoundness);
baseColor *= scanLineIntensity(remappedUV.x, screenResolution.y, scanLineOpacity.x);
baseColor *= scanLineIntensity(remappedUV.y, screenResolution.x, scanLineOpacity.y);
baseColor *= vec4(vec3(brightness), 1.0);
if (remappedUV.x < 0.0 || remappedUV.y < 0.0 || remappedUV.x > 1.0 || remappedUV.y > 1.0){
fragColor = vec4(0.0, 0.0, 0.0, 1.0);
} else {
fragColor = baseColor;
}
}
#endif
#if 0
vec2 fragCoord = vec2(0,0);
vec2 iResolution = vec2(640,480);
// Emulated input resolution.
#if 0
// Fix resolution to set amount.
#define res (vec2(320.0/1.0,160.0/1.0))
#else
// Optimize for resize.
#define res (iResolution.xy/6.0)
#endif
// Hardness of scanline.
// -8.0 = soft
// -16.0 = medium
float hardScan=-8.0;
// Hardness of pixels in scanline.
// -2.0 = soft
// -4.0 = hard
float hardPix=-3.0;
// Display warp.
// 0.0 = none
// 1.0/8.0 = extreme
vec2 warp=vec2(1.0/32.0,1.0/24.0);
// Amount of shadow mask.
float maskDark=0.5;
float maskLight=1.5;
//------------------------------------------------------------------------
// sRGB to Linear.
// Assuing using sRGB typed textures this should not be needed.
float ToLinear1(float c){return(c<=0.04045)?c/12.92:pow((c+0.055)/1.055,2.4);}
vec3 ToLinear(vec3 c){return vec3(ToLinear1(c.r),ToLinear1(c.g),ToLinear1(c.b));}
// Linear to sRGB.
// Assuing using sRGB typed textures this should not be needed.
float ToSrgb1(float c){return(c<0.0031308?c*12.92:1.055*pow(c,0.41666)-0.055);}
vec3 ToSrgb(vec3 c){return vec3(ToSrgb1(c.r),ToSrgb1(c.g),ToSrgb1(c.b));}
// Nearest emulated sample given floating point position and texel offset.
// Also zero's off screen.
vec3 Fetch(vec2 pos,vec2 off){
pos=floor(pos*res+off)/res;
if(max(abs(pos.x-0.5),abs(pos.y-0.5))>0.5)return vec3(0.0,0.0,0.0);
return ToLinear(texture(samplerAlbedo,pos.xy,-16.0).rgb);}
// Distance in emulated pixels to nearest texel.
vec2 Dist(vec2 pos){pos=pos*res;return -((pos-floor(pos))-vec2(0.5));}
// 1D Gaussian.
float Gaus(float pos,float scale){return exp2(scale*pos*pos);}
// 3-tap Gaussian filter along horz line.
vec3 Horz3(vec2 pos,float off){
vec3 b=Fetch(pos,vec2(-1.0,off));
vec3 c=Fetch(pos,vec2( 0.0,off));
vec3 d=Fetch(pos,vec2( 1.0,off));
float dst=Dist(pos).x;
// Convert distance to weight.
float scale=hardPix;
float wb=Gaus(dst-1.0,scale);
float wc=Gaus(dst+0.0,scale);
float wd=Gaus(dst+1.0,scale);
// Return filtered sample.
return (b*wb+c*wc+d*wd)/(wb+wc+wd);}
// 5-tap Gaussian filter along horz line.
vec3 Horz5(vec2 pos,float off){
vec3 a=Fetch(pos,vec2(-2.0,off));
vec3 b=Fetch(pos,vec2(-1.0,off));
vec3 c=Fetch(pos,vec2( 0.0,off));
vec3 d=Fetch(pos,vec2( 1.0,off));
vec3 e=Fetch(pos,vec2( 2.0,off));
float dst=Dist(pos).x;
// Convert distance to weight.
float scale=hardPix;
float wa=Gaus(dst-2.0,scale);
float wb=Gaus(dst-1.0,scale);
float wc=Gaus(dst+0.0,scale);
float wd=Gaus(dst+1.0,scale);
float we=Gaus(dst+2.0,scale);
// Return filtered sample.
return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);}
// Return scanline weight.
float Scan(vec2 pos,float off){
float dst=Dist(pos).y;
return Gaus(dst+off,hardScan);}
// Allow nearest three lines to effect pixel.
vec3 Tri(vec2 pos){
vec3 a=Horz3(pos,-1.0);
vec3 b=Horz5(pos, 0.0);
vec3 c=Horz3(pos, 1.0);
float wa=Scan(pos,-1.0);
float wb=Scan(pos, 0.0);
float wc=Scan(pos, 1.0);
return a*wa+b*wb+c*wc;}
// Distortion of scanlines, and end of screen alpha.
vec2 Warp(vec2 pos){
pos=pos*2.0-1.0;
pos*=vec2(1.0+(pos.y*pos.y)*warp.x,1.0+(pos.x*pos.x)*warp.y);
return pos*0.5+0.5;}
// Shadow mask.
vec3 Mask(vec2 pos){
pos.x+=pos.y*3.0;
vec3 mask=vec3(maskDark,maskDark,maskDark);
pos.x=fract(pos.x/6.0);
if(pos.x<0.333)mask.r=maskLight;
else if(pos.x<0.666)mask.g=maskLight;
else mask.b=maskLight;
return mask;}
void main() {
iResolution = textureSize( samplerAlbedo, 0 );
fragCoord = inUv * iResolution;
vec2 pos = Warp(fragCoord.xy / iResolution.xy);
hardScan = -12.0;
maskDark = maskLight = 1.0;
fragColor.rgb = Tri(pos) * Mask(fragCoord.xy);
fragColor.rgb = ToSrgb(fragColor.rgb);
fragColor.a = 1.0;
}
#endif
#if 0
void main() {
const vec2 uv = 0.025 * sin( ubo.curTime ) * inUv.xy;
const float mdf = 0.5;
const float noise = (fract(sin(dot(uv, vec2(12.9898,78.233)*2.0)) * 43758.5453));
const vec4 sampled = texture( samplerAlbedo, inUv );
fragColor = sampled - noise * mdf;
}
#endif

14
bin/data/shaders/display/renderTargetSimple.frag.glsl
View File

@ -1,14 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#extension GL_EXT_samplerless_texture_functions : require
layout (location = 0) in vec2 inUv;
layout (location = 1) flat in uint inPass;
layout (location = 0) out vec4 outAlbedo;
layout (binding = 0) uniform sampler2D samplerAlbedo;
void main() {
outAlbedo = texture( samplerAlbedo, inUv );
}

16
bin/data/shaders/display/renderTargetSimple.vert.glsl
View File

@ -1,16 +0,0 @@
#version 450
#pragma shader_stage(vertex)
layout (location = 0) out vec2 outUv;
layout (location = 1) out flat uint outPass;
layout( push_constant ) uniform PushBlock {
uint pass;
uint draw;
} PushConstant;
void main() {
outUv = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
outPass = PushConstant.pass;
gl_Position = vec4(outUv * 2.0f + -1.0f, 0.0f, 1.0f);
}

8
bin/data/shaders/display/rendertarget.deferredSampling.frag.glsl
View File

@ -1,8 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#extension GL_EXT_samplerless_texture_functions : require
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 0
#include "./renderTarget.h"

12
bin/data/shaders/display/rendertarget.frag.glsl
View File

@ -2,7 +2,13 @@
#pragma shader_stage(fragment)
#extension GL_EXT_samplerless_texture_functions : require
#define DEFERRED_SAMPLING 0
#define MULTISAMPLING 0
layout (location = 0) in vec2 inUv;
layout (location = 1) flat in uint inPass;
#include "./renderTarget.h"
layout (location = 0) out vec4 outAlbedo;
layout (binding = 0) uniform sampler2D samplerAlbedo;
void main() {
outAlbedo = texture( samplerAlbedo, inUv );
}

8
bin/data/shaders/display/rendertarget.msaa.deferredSampling.frag.glsl
View File

@ -1,8 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#extension GL_EXT_samplerless_texture_functions : require
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#include "./renderTarget.h"

8
bin/data/shaders/display/rendertarget.msaa.frag.glsl
View File

@ -1,8 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#extension GL_EXT_samplerless_texture_functions : require
#define DEFERRED_SAMPLING 0
#define MULTISAMPLING 1
#include "./renderTarget.h"

24
bin/data/shaders/display/rendertarget.vert.glsl
View File

@ -1,34 +1,16 @@
#version 450
#pragma shader_stage(vertex)
struct Cursor {
vec2 position;
vec2 radius;
vec4 color;
};
layout (location = 0) out vec2 outUv;
layout (location = 1) out float outAlpha;
layout (location = 2) out flat Cursor outCursor;
layout (location = 1) out flat uint outPass;
layout( push_constant ) uniform PushBlock {
uint pass;
uint draw;
} PushConstant;
struct Matrices {
mat4 model[2];
};
layout (binding = 0) uniform UBO {
Matrices matrices;
Cursor cursor;
// float alpha;
// float padding;
} ubo;
void main() {
outUv = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
outCursor = ubo.cursor;
outAlpha = 1;
gl_Position = ubo.matrices.model[PushConstant.pass] * vec4(outUv * 2.0f + -1.0f, 0.0f, 1.0f);
outPass = PushConstant.pass;
gl_Position = vec4(outUv * 2.0f + -1.0f, 0.0f, 1.0f);
}

13
bin/data/shaders/display/subpass.deferredSampling.frag.glsl
View File

@ -1,13 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 0
#include "./subpass.h"
void main() {
populateSurface();
directLighting();
postProcess();
}

2
bin/data/shaders/display/subpass.frag.glsl
View File

@ -1,7 +1,7 @@
#version 450
#pragma shader_stage(fragment)
#define DEFERRED_SAMPLING 0
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 0
#include "./subpass.h"

80
bin/data/shaders/display/subpass.h
View File

@ -19,68 +19,58 @@ layout (constant_id = 1) const uint CUBEMAPS = 128;
#if !MULTISAMPLING
layout (input_attachment_index = 0, binding = 0) uniform usubpassInput samplerId;
layout (input_attachment_index = 1, binding = 1) uniform subpassInput samplerNormal;
#if DEFERRED_SAMPLING
layout (input_attachment_index = 2, binding = 2) uniform subpassInput samplerUv;
#else
layout (input_attachment_index = 2, binding = 2) uniform subpassInput samplerAlbedo;
#endif
layout (input_attachment_index = 3, binding = 3) uniform subpassInput samplerDepth;
#if DEFERRED_SAMPLING
layout (input_attachment_index = 4, binding = 4) uniform subpassInput samplerMips;
#endif
layout (input_attachment_index = 1, binding = 1) uniform usubpassInput samplerBary;
layout (input_attachment_index = 2, binding = 2) uniform subpassInput samplerMips;
layout (input_attachment_index = 3, binding = 3) uniform subpassInput samplerNormal;
layout (input_attachment_index = 4, binding = 4) uniform subpassInput samplerUv;
layout (input_attachment_index = 5, binding = 5) uniform subpassInput samplerDepth;
#else
layout (input_attachment_index = 0, binding = 0) uniform usubpassInputMS samplerId;
layout (input_attachment_index = 1, binding = 1) uniform subpassInputMS samplerNormal;
#if DEFERRED_SAMPLING
layout (input_attachment_index = 2, binding = 2) uniform subpassInputMS samplerUv;
#else
layout (input_attachment_index = 2, binding = 2) uniform subpassInputMS samplerAlbedo;
#endif
layout (input_attachment_index = 3, binding = 3) uniform subpassInputMS samplerDepth;
#if DEFERRED_SAMPLING
layout (input_attachment_index = 4, binding = 4) uniform subpassInputMS samplerMips;
#endif
layout (input_attachment_index = 1, binding = 1) uniform usubpassInputMS samplerBary;
layout (input_attachment_index = 2, binding = 2) uniform subpassInputMS samplerMips;
layout (input_attachment_index = 3, binding = 3) uniform subpassInputMS samplerNormal;
layout (input_attachment_index = 4, binding = 4) uniform subpassInputMS samplerUv;
layout (input_attachment_index = 5, binding = 5) uniform subpassInputMS samplerDepth;
#endif
#include "../common/structs.h"
layout (binding = 5) uniform UBO {
layout (binding = 6) uniform UBO {
EyeMatrices eyes[2];
Settings settings;
} ubo;
/*
*/
layout (std140, binding = 6) readonly buffer DrawCommands {
layout (std140, binding = 7) readonly buffer DrawCommands {
DrawCommand drawCommands[];
};
layout (std140, binding = 7) readonly buffer Instances {
layout (std140, binding = 8) readonly buffer Instances {
Instance instances[];
};
layout (std140, binding = 8) readonly buffer InstanceAddresseses {
layout (std140, binding = 9) readonly buffer InstanceAddresseses {
InstanceAddresses instanceAddresses[];
};
layout (std140, binding = 9) readonly buffer Materials {
layout (std140, binding = 10) readonly buffer Materials {
Material materials[];
};
layout (std140, binding = 10) readonly buffer Textures {
layout (std140, binding = 11) readonly buffer Textures {
Texture textures[];
};
layout (std140, binding = 11) readonly buffer Lights {
layout (std140, binding = 12) readonly buffer Lights {
Light lights[];
};
layout (binding = 12) uniform sampler2D samplerTextures[TEXTURES];
layout (binding = 13) uniform samplerCube samplerCubemaps[CUBEMAPS];
layout (binding = 14) uniform sampler3D samplerNoise;
layout (binding = 13) uniform sampler2D samplerTextures[TEXTURES];
layout (binding = 14) uniform samplerCube samplerCubemaps[CUBEMAPS];
layout (binding = 15) uniform sampler3D samplerNoise;
#if VXGI
layout (binding = 15) uniform usampler3D voxelId[CASCADES];
layout (binding = 16) uniform sampler3D voxelNormal[CASCADES];
layout (binding = 17) uniform sampler3D voxelRadiance[CASCADES];
layout (binding = 16) uniform usampler3D voxelId[CASCADES];
layout (binding = 17) uniform sampler3D voxelNormal[CASCADES];
layout (binding = 18) uniform sampler3D voxelRadiance[CASCADES];
#endif
#if RAYTRACE
layout (binding = 18) uniform accelerationStructureEXT tlas;
layout (binding = 19) uniform accelerationStructureEXT tlas;
#endif
layout (location = 0) in vec2 inUv;
@ -180,16 +170,14 @@ void populateSurface() {
#if !MULTISAMPLING
surface.normal.world = decodeNormals( subpassLoad(samplerNormal).xy );
const uvec2 ID = subpassLoad(samplerId).xy;
const uvec3 ID = subpassLoad(samplerId).xyz;
#else
surface.normal.world = decodeNormals( subpassLoad(samplerNormal, msaa.currentID).xy ); // decodeNormals( resolve(samplerNormal, ubo.settings.mode.msaa).xy );
const uvec2 ID = msaa.IDs[msaa.currentID]; // subpassLoad(samplerId, msaa.currentID).xy; //resolve(samplerId, ubo.settings.mode.msaa).xy;
const uvec3 ID = msaa.IDs[msaa.currentID]; // subpassLoad(samplerId, msaa.currentID).xy; //resolve(samplerId, ubo.settings.mode.msaa).xy;
#endif
surface.normal.eye = vec3( ubo.eyes[surface.pass].view * vec4(surface.normal.world, 0.0) );
const uint drawID = ID.x - 1;
const uint instanceID = ID.y - 1;
if ( ID.x == 0 || ID.y == 0 ) {
if ( ID.x == 0 || ID.y == 0 || ID.z == 0 ) {
if ( 0 <= ubo.settings.lighting.indexSkybox && ubo.settings.lighting.indexSkybox < CUBEMAPS ) {
surface.fragment.rgb = texture( samplerCubemaps[ubo.settings.lighting.indexSkybox], surface.ray.direction ).rgb;
}
@ -197,6 +185,10 @@ void populateSurface() {
postProcess();
return;
}
const uint drawID = ID.x - 1;
const uint triangleID = ID.y - 1;
const uint instanceID = ID.z - 1;
const DrawCommand drawCommand = drawCommands[drawID];
const Instance instance = instances[instanceID];
surface.instance = instance;
@ -208,7 +200,6 @@ void populateSurface() {
surface.material.occlusion = material.factorOcclusion;
surface.fragment = material.colorEmissive;
#if DEFERRED_SAMPLING
{
#if !MULTISAMPLING
const vec4 uv = subpassLoad(samplerUv);
@ -258,13 +249,6 @@ void populateSurface() {
surface.material.metallic = samp.r;
surface.material.roughness = samp.g;
}
#else
#if !MULTISAMPLING
surface.material.albedo *= subpassLoad(samplerAlbedo);
#else
surface.material.albedo *= subpassLoad(samplerAlbedo, msaa.currentID); // resolve(samplerAlbedo, ubo.settings.mode.msaa);
#endif
#endif
}
void directLighting() {
@ -284,7 +268,7 @@ void directLighting() {
void resolveSurfaceFragment() {
for ( int i = 0; i < ubo.settings.mode.msaa; ++i ) {
msaa.currentID = i;
msaa.IDs[i] = subpassLoad(samplerId, msaa.currentID).xy;
msaa.IDs[i] = subpassLoad(samplerId, msaa.currentID).xyz;
// check if ID is already used
bool unique = true;

11
bin/data/shaders/display/subpass.msaa.deferredSampling.frag.glsl
View File

@ -1,11 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#include "./subpass.h"
void main() {
resolveSurfaceFragment();
postProcess();
}

12
bin/data/shaders/display/subpass.msaa.deferredSampling.rt.frag.glsl
View File

@ -1,12 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#define RAYTRACE 1
#include "./subpass.h"
void main() {
resolveSurfaceFragment();
postProcess();
}

2
bin/data/shaders/display/subpass.msaa.frag.glsl
View File

@ -1,7 +1,7 @@
#version 450
#pragma shader_stage(fragment)
#define DEFERRED_SAMPLING 0
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#include "./subpass.h"

2
bin/data/shaders/display/subpass.msaa.rt.frag.glsl
View File

@ -1,7 +1,7 @@
#version 450
#pragma shader_stage(fragment)
#define DEFERRED_SAMPLING 0
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#define RAYTRACE 1
#include "./subpass.h"

4
bin/data/shaders/display/subpass.deferredSampling.rt.frag.glsl → bin/data/shaders/display/subpass.rt.frag.glsl
View File

@ -1,11 +1,9 @@
#version 450
#pragma shader_stage(fragment)
#define VXGI 0
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 0
#define VXGI 0
#define RT 1
#include "./subpass.h"
void main() {

14
bin/data/shaders/display/subpass.vxgi.deferredSampling.frag.glsl
View File

@ -1,14 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#define VXGI 1
#define MULTISAMPLING 0
#define DEFERRED_SAMPLING 1
#include "./subpass.h"
void main() {
populateSurface();
indirectLighting();
directLighting();
postProcess();
}

15
bin/data/shaders/display/subpass.vxgi.deferredSampling.rt.frag.glsl
View File

@ -1,15 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#define VXGI 1
#define RAYTRACE 1
#define MULTISAMPLING 0
#define DEFERRED_SAMPLING 1
#include "./subpass.h"
void main() {
populateSurface();
indirectLighting();
directLighting();
postProcess();
}

2
bin/data/shaders/display/subpass.vxgi.frag.glsl
View File

@ -2,7 +2,7 @@
#pragma shader_stage(fragment)
#define VXGI 1
#define DEFERRED_SAMPLING 0
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 0
#include "./subpass.h"

12
bin/data/shaders/display/subpass.vxgi.msaa.deferredSampling.frag.glsl
View File

@ -1,12 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#define VXGI 1
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#include "./subpass.h"
void main() {
resolveSurfaceFragment();
postProcess();
}

13
bin/data/shaders/display/subpass.vxgi.msaa.deferredSampling.rt.frag.glsl
View File

@ -1,13 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#define VXGI 1
#define RAYTRACE 1
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#include "./subpass.h"
void main() {
resolveSurfaceFragment();
postProcess();
}

2
bin/data/shaders/display/subpass.vxgi.msaa.frag.glsl
View File

@ -2,7 +2,7 @@
#pragma shader_stage(fragment)
#define VXGI 1
#define DEFERRED_SAMPLING 0
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#include "./subpass.h"

2
bin/data/shaders/display/subpass.vxgi.msaa.rt.frag.glsl
View File

@ -3,7 +3,7 @@
#define VXGI 1
#define RAYTRACE 1
#define DEFERRED_SAMPLING 0
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 1
#include "./subpass.h"

2
bin/data/shaders/display/subpass.vxgi.rt.frag.glsl
View File

@ -3,7 +3,7 @@
#define VXGI 1
#define RAYTRACE 1
#define DEFERRED_SAMPLING 0
#define DEFERRED_SAMPLING 1
#define MULTISAMPLING 0
#include "./subpass.h"

4
bin/data/shaders/display/vxgi.comp.h
View File

@ -46,9 +46,9 @@ layout (binding = 9) uniform sampler3D samplerNoise;
layout (binding = 10, rg16ui) uniform volatile coherent uimage3D voxelId[CASCADES];
layout (binding = 11, rg16f) uniform volatile coherent image3D voxelNormal[CASCADES];
#if VXGI_HDR
layout (binding = 12, rgba16f) uniform volatile coherent image3D voxelRadiance[CASCADES];
layout (binding = 12, rgba32f) uniform volatile coherent image3D voxelRadiance[CASCADES];
#else
layout (binding = 12, rgba8) uniform volatile coherent image3D voxelRadiance[CASCADES];
layout (binding = 12, rgba16f) uniform volatile coherent image3D voxelRadiance[CASCADES];
#endif
#include "../common/functions.h"

1
bin/data/shaders/graph/baking/bake.frag.glsl
View File

@ -157,6 +157,7 @@ void main() {
surface.light.a += light.power * La * Ls;
}
}
#endif
#define EXPOSURE 0
#define GAMMA 0

5
bin/data/shaders/graph/base.deferredSampling.frag.glsl
View File

@ -1,5 +0,0 @@
#version 450
#pragma shader_stage(fragment)
#define DEFERRED_SAMPLING 1
#include "./base.frag.h"

4
bin/data/shaders/graph/base.frag.glsl
View File

@ -1,6 +1,6 @@
#version 450
#pragma shader_stage(fragment)
#define DEFERRED_SAMPLING 0
#define QUERY_MIPMAP 1
#define DEFERRED_SAMPLING 1
#define QUERY_MIPMAP 0
#include "./base.frag.h"

53
bin/data/shaders/graph/base.frag.h
View File

@ -1,4 +1,6 @@
//#extension GL_EXT_nonuniform_qualifier : enable
#extension GL_EXT_fragment_shader_barycentric : enable
#define CUBEMAPS 1
#define FRAGMENT 1
// #define MAX_TEXTURES TEXTURES
@ -8,6 +10,7 @@ layout (constant_id = 0) const uint TEXTURES = 1;
#include "../common/macros.h"
#include "../common/structs.h"
layout (binding = 5) uniform sampler2D samplerTextures[TEXTURES];
layout (std140, binding = 6) readonly buffer DrawCommands {
DrawCommand drawCommands[];
@ -38,19 +41,17 @@ layout (location = 4) in mat3 inTBN;
layout (location = 7) in vec3 inPosition;
layout (location = 8) flat in uvec4 inId;
layout (location = 0) out uvec2 outId;
layout (location = 1) out vec2 outNormals;
#if DEFERRED_SAMPLING
layout (location = 2) out vec4 outUvs;
layout (location = 3) out vec2 outMips;
#else
layout (location = 2) out vec4 outAlbedo;
#endif
layout (location = 0) out uvec4 outId;
layout (location = 1) out vec2 outBary;
layout (location = 2) out vec2 outMips;
layout (location = 3) out vec2 outNormals;
layout (location = 4) out vec4 outUvs;
void main() {
const uint drawID = uint(inId.x);
const uint instanceID = uint(inId.y);
const uint materialID = uint(inId.z);
const uint triangleID = uint(inId.y);
const uint instanceID = uint(inId.z);
const vec2 uv = wrap(inUv.xy);
const vec3 P = inPosition;
@ -61,12 +62,10 @@ void main() {
vec3 N = inNormal;
vec4 A = vec4(0, 0, 0, 0);
#if DEFERRED_SAMPLING
vec4 outAlbedo = vec4(0,0,0,0);
#endif
#if !DEFERRED_SAMPLING || CAN_DISCARD
#if CAN_DISCARD
const DrawCommand drawCommand = drawCommands[drawID];
const Instance instance = instances[instanceID];
const Material material = materials[materialID];
const Material material = materials[instance.materialID];
A = material.colorBase;
float M = material.factorMetallic;
@ -95,35 +94,19 @@ void main() {
if ( light.a > 0.001 ) A.rgb *= light.rgb;
}
#endif
#endif
// sample normal
if ( validTextureIndex( material.indexNormal ) ) {
N = inTBN * normalize( sampleTexture( material.indexNormal ).xyz * 2.0 - vec3(1.0));
}
#if !DEFERRED_SAMPLING
#if 0
// sample metallic/roughness
if ( validTextureIndex( material.indexMetallicRoughness ) ) {
Texture t = textures[material.indexMetallicRoughness];
const vec4 sampled = textureLod( samplerTextures[nonuniformEXT((useAtlas)?textureAtlas.index:t.index)], ( useAtlas ) ? mix( t.lerp.xy, t.lerp.zw, uv ) : uv, mipUv );
M = sampled.b;
R = sampled.g;
}
// sample ao
AO = material.factorOcclusion;
if ( validTextureIndex( material.indexOcclusion ) ) {
Texture t = textures[material.indexOcclusion];
AO = textureLod( samplerTextures[nonuniformEXT((useAtlas)?textureAtlas.index:t.index)], ( useAtlas ) ? mix( t.lerp.xy, t.lerp.zw, uv ) : uv ).r;
}
#endif
outAlbedo = A * inColor;
#else
outUvs.xy = surface.uv.xy;
outUvs.zw = surface.st.xy;
outMips.x = surface.uv.z;
outMips.y = surface.st.z;
#endif
outNormals = encodeNormals( N );
outId = uvec2(drawID + 1, instanceID + 1);
outId = uvec4(drawID + 1, triangleID + 1, instanceID + 1, 0);
outBary = gl_BaryCoordEXT.yz;
}

6
bin/data/shaders/graph/base.vert.h
View File

@ -65,8 +65,10 @@ void main() {
outUv = inUv;
outSt = inSt;
const uint drawID = gl_DrawIDARB;
const DrawCommand drawCommand = drawCommands[drawID];
const uint triangleID = gl_VertexIndex / 3;
const uint instanceID = gl_InstanceIndex;
const DrawCommand drawCommand = drawCommands[drawID];
const Instance instance = instances[instanceID];
const uint materialID = instance.materialID;
const uint jointID = instance.jointID;
@ -86,7 +88,7 @@ void main() {
// const mat4 model = instances.length() <= 0 ? skinned : (instance.model * skinned);
const mat4 model = instance.model * skinned;
outId = ivec4(drawID, instanceID, materialID, PushConstant.pass);
outId = uvec4(drawID, triangleID, instanceID, PushConstant.pass);
outColor = instance.color;
outPosition = vec3(model * vec4(inPos.xyz, 1.0));
outNormal = vec3(model * vec4(inNormal.xyz, 0.0));

16
bin/data/shaders/graph/voxelize.frag.h
View File

@ -52,16 +52,6 @@ layout (location = 8) flat in uvec4 inId;
#include "../common/functions.h"
#if 0
layout (location = 0) out uvec2 outId;
layout (location = 1) out vec2 outNormals;
#if DEFERRED_SAMPLING
layout (location = 2) out vec4 outUvs;
#else
layout (location = 2) out vec4 outAlbedo;
#endif
#endif
void main() {
const uint CASCADE = inId.w;
if ( CASCADES <= CASCADE ) discard;
@ -69,8 +59,8 @@ void main() {
if ( abs(P.x) > 1 || abs(P.y) > 1 || abs(P.z) > 1 ) discard;
const uint drawID = uint(inId.x);
const uint instanceID = uint(inId.y);
const uint materialID = uint(inId.z);
const uint triangleID = uint(inId.y);
const uint instanceID = uint(inId.z);
const vec2 uv = wrap(inUv.xy);
surface.uv.xy = uv;
@ -81,7 +71,7 @@ void main() {
vec3 N = inNormal;
const Instance instance = instances[instanceID];
const Material material = materials[materialID];
const Material material = materials[instance.materialID];
surface.instance = instance;
vec4 A = material.colorBase;

2
bin/data/shaders/raytrace/shader.ray-gen.glsl
View File

@ -31,7 +31,7 @@ layout( push_constant ) uniform PushBlock {
layout (binding = 0) uniform accelerationStructureEXT tlas;
layout (binding = 1, rgba8) uniform volatile coherent image2D outImage;
layout (binding = 1, rgba32f) uniform volatile coherent image2D outImage;
layout (binding = 2) uniform UBO {
EyeMatrices eyes[2];

2
engine/inc/uf/ext/vulkan/buffer.h
View File

@ -48,7 +48,7 @@ namespace ext {
void initialize( ext::vulkan::Device& device, size_t = {} );
void initialize( const void*, VkDeviceSize, VkBufferUsageFlags, VkMemoryPropertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, bool = VK_DEFAULT_STAGE_BUFFERS );
bool update( const void*, VkDeviceSize, bool = VK_DEFAULT_STAGE_BUFFERS ) const;
void destroy();
void destroy(bool = VK_DEFAULT_DEFER_BUFFER_DESTROY);
void swap( Buffer& );
Buffer alias() const;

5
engine/inc/uf/ext/vulkan/device.h
View File

@ -18,6 +18,8 @@ namespace ext {
bool immediate{true};
QueueEnum queueType{QueueEnum::TRANSFER};
VkCommandBuffer handle{VK_NULL_HANDLE};
operator VkCommandBuffer() { return handle; }
};
struct UF_API Device {
@ -91,7 +93,8 @@ namespace ext {
VkCommandBuffer createCommandBuffer( VkCommandBufferLevel level, QueueEnum queue, bool begin = true );
void flushCommandBuffer( VkCommandBuffer commandBuffer, QueueEnum queue, bool wait = false );
CommandBuffer fetchCommandBuffer( QueueEnum queue, bool waits = true );
// CommandBuffer fetchCommandBuffer( QueueEnum queue );
CommandBuffer fetchCommandBuffer( QueueEnum queue, bool waits = VK_DEFAULT_COMMAND_BUFFER_WAIT );
void flushCommandBuffer( CommandBuffer commandBuffer );
VkResult createBuffer(

4
engine/inc/uf/ext/vulkan/vk.h
View File

@ -16,11 +16,15 @@
#define VK_FLAGS_NONE 0
#define VK_DEFAULT_FENCE_TIMEOUT ext::vulkan::settings::defaultTimeout
#define VK_DEFAULT_STAGE_BUFFERS ext::vulkan::settings::defaultStageBuffers
#define VK_DEFAULT_DEFER_BUFFER_DESTROY ext::vulkan::settings::defaultDeferBufferDestroy
#define VK_DEFAULT_COMMAND_BUFFER_WAIT ext::vulkan::settings::defaultCommandBufferWait
namespace ext {
namespace vulkan {
namespace settings {
extern UF_API bool defaultStageBuffers;
extern UF_API bool defaultDeferBufferDestroy;
extern UF_API bool defaultCommandBufferWait;
}
}
}

2
engine/inc/uf/ext/vulkan/vulkan.h
View File

@ -110,8 +110,6 @@ namespace ext {
extern UF_API VkColorSpaceKHR colorSpace;
extern UF_API ext::vulkan::enums::Format::type_t color;
extern UF_API ext::vulkan::enums::Format::type_t depth;
extern UF_API ext::vulkan::enums::Format::type_t normal;
extern UF_API ext::vulkan::enums::Format::type_t position;
}
}
namespace states {

51
engine/src/engine/graph/graph.cpp
View File

@ -163,10 +163,12 @@ void uf::graph::initializeGraphics( pod::Graph& graph, uf::Object& entity, uf::M
}
uf::stl::string geometryShaderFilename = graph.metadata["shaders"]["geometry"].as<uf::stl::string>("");
uf::stl::string fragmentShaderFilename = graph.metadata["shaders"]["fragment"].as<uf::stl::string>("/graph/base.frag.spv"); {
#if 0
std::pair<bool, uf::stl::string> settings[] = {
{ uf::renderer::settings::invariant::deferredSampling, "deferredSampling.frag" },
};
FOR_ARRAY(settings) if ( settings[i].first ) fragmentShaderFilename = uf::string::replace( fragmentShaderFilename, "frag", settings[i].second );
#endif
fragmentShaderFilename = entity.resolveURI( fragmentShaderFilename, root );
}
{
@ -852,6 +854,37 @@ void uf::graph::process( pod::Graph& graph ) {
}
}
// remap instance variables
#if 0
UF_DEBUG_TIMER_MULTITRACE("Remapping drawCommands");
for ( auto& name : graph.drawCommands ) {
auto& drawCommands = uf::graph::storage.drawCommands[name];
for ( auto& drawCommand : drawCommands ) {
if ( 0 <= drawCommand.instanceID && drawCommand.instanceID < graph.instances.size() ) {
auto& keys = /*graph.storage*/uf::graph::storage.instances.keys;
auto& indices = /*graph.storage*/uf::graph::storage.instances.indices;
if ( !(0 <= drawCommand.instanceID && drawCommand.instanceID < graph.instances.size()) ) continue;
auto& needle = graph.instances[drawCommand.instanceID];
#if 1
drawCommand.instanceID = indices[needle];
#elif 1
for ( size_t i = 0; i < keys.size(); ++i ) {
if ( keys[i] != needle ) continue;
drawCommand.instanceID = i;
break;
}
#else
auto it = std::find( keys.begin(), keys.end(), needle );
UF_ASSERT( it != keys.end() );
drawCommand.instanceID = it - keys.begin();
#endif
}
}
}
#endif
if ( graph.metadata["debug"]["print"]["lights"].as<bool>() ) for ( auto& pair : graph.lights ) UF_MSG_DEBUG("Light: {}", pair.first);
if ( graph.metadata["debug"]["print"]["meshes"].as<bool>() ) for ( auto& name : graph.meshes ) UF_MSG_DEBUG("Mesh: {}", name);
if ( graph.metadata["debug"]["print"]["materials"].as<bool>() ) for ( auto& name : graph.materials ) UF_MSG_DEBUG("Material: {}", name);
@ -910,25 +943,7 @@ void uf::graph::process( pod::Graph& graph ) {
{
auto& graphic = graph.root.entity->getComponent<uf::renderer::Graphic>();
uf::graph::initializeGraphics( graph, *graph.root.entity, mesh );
/*
if ( uf::renderer::settings::pipelines::rt ) {
uf::stl::vector<uf::renderer::Graphic*> graphics = { &graphic };
graphic.generateTopAccelerationStructure( graphics, uf::graph::storage.instances.flatten() );
}
*/
}
} else if ( uf::renderer::settings::pipelines::rt ) {
/*
auto& graphic = graph.root.entity->getComponent<uf::renderer::Graphic>();
graphic.initialize("Compute");
uf::stl::vector<uf::renderer::Graphic*> graphics;
for ( auto& node : graph.nodes ) {
if ( !node.entity || !node.entity->hasComponent<uf::renderer::Graphic>() ) continue;
graphics.emplace_back(node.entity->getComponentPointer<uf::renderer::Graphic>());
}
graphic.generateTopAccelerationStructure( graphics, uf::graph::storage.instances.flatten() );
*/
}
uf::graph::storage.instanceAddresses.keys = uf::graph::storage.instances.keys;

6
engine/src/ext/imgui/imgui.cpp
View File

@ -463,9 +463,9 @@ void ext::imgui::initialize() {
}
{
// Use any command queue
VkCommandBuffer commandBuffer = uf::renderer::device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, uf::renderer::QueueEnum::TRANSFER);
ImGui_ImplVulkan_CreateFontsTexture(commandBuffer);
uf::renderer::device.flushCommandBuffer(commandBuffer, uf::renderer::QueueEnum::TRANSFER);
auto commandBuffer = uf::renderer::device.fetchCommandBuffer(uf::renderer::QueueEnum::TRANSFER);
ImGui_ImplVulkan_CreateFontsTexture(commandBuffer.handle);
uf::renderer::device.flushCommandBuffer(commandBuffer);
ImGui_ImplVulkan_DestroyFontUploadObjects();
}

32
engine/src/ext/vulkan/buffer.cpp
View File

@ -115,8 +115,13 @@ void ext::vulkan::Buffer::initialize( ext::vulkan::Device& device, size_t alignm
this->device = &device;
this->alignment = alignment;
}
void ext::vulkan::Buffer::destroy() {
void ext::vulkan::Buffer::destroy(bool defer) {
if ( !device || aliased ) return;
if ( defer ) {
device->transient.buffers.emplace_back(*this);
this->aliased = true;
return;
}
if ( buffer ) {
vmaDestroyBuffer( allocator, buffer, allocation );
@ -159,36 +164,17 @@ bool ext::vulkan::Buffer::update( const void* data, VkDeviceSize length, bool st
}
ext::vulkan::Device* device = this->device ? this->device : &ext::vulkan::device;
#if 1
Buffer staging = device->fetchTransientBuffer(
data,
length,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
);
VkCommandBuffer copyCommand = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::TRANSFER);
auto commandBuffer = device->fetchCommandBuffer(QueueEnum::TRANSFER, true); // waits on finish
VkBufferCopy region = {};
region.size = length;
vkCmdCopyBuffer(copyCommand, staging.buffer, buffer, 1, &region);
device->flushCommandBuffer(copyCommand, QueueEnum::TRANSFER);
#else
Buffer staging;
device->createBuffer(
data,
length,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
staging
);
// Copy to staging buffer
VkCommandBuffer copyCommand = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::TRANSFER);
VkBufferCopy region = {};
region.size = length;
vkCmdCopyBuffer(copyCommand, staging.buffer, buffer, 1, &region);
device->flushCommandBuffer(copyCommand, QueueEnum::TRANSFER);
staging.destroy();
#endif
vkCmdCopyBuffer(commandBuffer, staging.buffer, buffer, 1, &region);
device->flushCommandBuffer(commandBuffer);
return false;
}

11
engine/src/ext/vulkan/device.cpp
View File

@ -586,6 +586,11 @@ void ext::vulkan::Device::flushCommandBuffer( VkCommandBuffer commandBuffer, Que
this->transient.commandBuffers[queueType].emplace_back(commandBuffer);
}
}
/*
ext::vulkan::CommandBuffer ext::vulkan::Device::fetchCommandBuffer( ext::vulkan::QueueEnum queueType ){
return fetchCommandBuffer( queueType, ext::vulkan::settings::defaultCommandBufferWait );
}
*/
ext::vulkan::CommandBuffer ext::vulkan::Device::fetchCommandBuffer( ext::vulkan::QueueEnum queueType, bool immediate ){
return {
.immediate = immediate,
@ -1048,6 +1053,7 @@ void ext::vulkan::Device::initialize() {
VkPhysicalDeviceRayQueryFeaturesKHR rayQueryFeatures{};
VkPhysicalDeviceAccelerationStructureFeaturesKHR accelerationStructureFeatures{};
VkPhysicalDeviceShaderClockFeaturesKHR shaderClockFeatures{};
VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR fragmentShaderBarycentricFeatures{};
VkPhysicalDeviceVulkan12Features enabledPhysicalDeviceVulkan12Features{};
VkPhysicalDeviceFeatures2 enabledDeviceFeatures2{}; {
@ -1107,6 +1113,10 @@ void ext::vulkan::Device::initialize() {
shaderClockFeatures.shaderSubgroupClock = VK_TRUE;
shaderClockFeatures.shaderDeviceClock = VK_TRUE;
}
{
fragmentShaderBarycentricFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
fragmentShaderBarycentricFeatures.fragmentShaderBarycentric = VK_TRUE;
}
deviceCreateInfo.pNext = &physicalDeviceFeatures2;
physicalDeviceFeatures2.pNext = &physicalDeviceVulkan12Features;
@ -1118,6 +1128,7 @@ void ext::vulkan::Device::initialize() {
rayTracingPipelineFeatures.pNext = &rayQueryFeatures;
rayQueryFeatures.pNext = &accelerationStructureFeatures;
accelerationStructureFeatures.pNext = &shaderClockFeatures;
shaderClockFeatures.pNext = &fragmentShaderBarycentricFeatures;
if ( settings::experimental::enableMultiGPU ) {
UF_MSG_DEBUG("Multiple devices supported, using {} devices...", groupDeviceCreateInfo.physicalDeviceCount);

40
engine/src/ext/vulkan/graphic.cpp
View File

@ -627,7 +627,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: {
ext::vulkan::enums::Image::viewType_t imageType = shader->metadata.definitions.textures.at(layout.binding).type;
if ( imageType == ext::vulkan::enums::Image::VIEW_TYPE_2D ) {
UF_ASSERT_BREAK_MSG( image2DInfo != infos.image2D.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( image2DInfo != infos.image2D.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -637,7 +637,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
));
image2DInfo += layout.descriptorCount;
} else if ( imageType == ext::vulkan::enums::Image::VIEW_TYPE_2D_ARRAY ) {
UF_ASSERT_BREAK_MSG( image2DAInfo != infos.image2DA.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( image2DAInfo != infos.image2DA.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -647,7 +647,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
));
image2DAInfo += layout.descriptorCount;
} else if ( imageType == ext::vulkan::enums::Image::VIEW_TYPE_CUBE ) {
UF_ASSERT_BREAK_MSG( imageCubeInfo != infos.imageCube.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( imageCubeInfo != infos.imageCube.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -657,7 +657,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
));
imageCubeInfo += layout.descriptorCount;
} else if ( imageType == ext::vulkan::enums::Image::VIEW_TYPE_3D ) {
UF_ASSERT_BREAK_MSG( image3DInfo != infos.image3D.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( image3DInfo != infos.image3D.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -667,7 +667,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
));
image3DInfo += layout.descriptorCount;
} else {
UF_ASSERT_BREAK_MSG( imageUnknownInfo != infos.imageUnknown.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( imageUnknownInfo != infos.imageUnknown.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -679,7 +679,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
}
} break;
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: {
UF_ASSERT_BREAK_MSG( inputInfo != infos.input.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( inputInfo != infos.input.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -690,7 +690,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
inputInfo += layout.descriptorCount;
} break;
case VK_DESCRIPTOR_TYPE_SAMPLER: {
UF_ASSERT_BREAK_MSG( samplerInfo != infos.sampler.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( samplerInfo != infos.sampler.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -701,7 +701,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
samplerInfo += layout.descriptorCount;
} break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: {
UF_ASSERT_BREAK_MSG( uniformBufferInfo != infos.uniform.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( uniformBufferInfo != infos.uniform.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -712,7 +712,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
uniformBufferInfo += layout.descriptorCount;
} break;
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: {
UF_ASSERT_BREAK_MSG( storageBufferInfo != infos.storage.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( storageBufferInfo != infos.storage.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -723,7 +723,7 @@ void ext::vulkan::Pipeline::update( const Graphic& graphic, const GraphicDescrip
storageBufferInfo += layout.descriptorCount;
} break;
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: {
UF_ASSERT_BREAK_MSG( accelerationStructureInfo != infos.accelerationStructure.end(), "Filename: {}\tCount: {}", shader->filename, layout.descriptorCount )
UF_ASSERT_BREAK_MSG( accelerationStructureInfo != infos.accelerationStructure.end(), ::fmt::format("Filename: {}\tCount: {}", shader->filename, layout.descriptorCount) )
auto& writeDescriptorSet = writeDescriptorSets.emplace_back(ext::vulkan::initializers::writeDescriptorSet(
descriptorSet,
layout.descriptorType,
@ -1357,7 +1357,7 @@ void ext::vulkan::Graphic::generateBottomAccelerationStructures() {
scratchBuffer.alignment = acclerationStructureProperties.minAccelerationStructureScratchOffsetAlignment;
scratchBuffer.update( NULL, maxScratchBufferSize );
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, uf::renderer::QueueEnum::COMPUTE);
auto commandBuffer = device.fetchCommandBuffer(uf::renderer::QueueEnum::COMPUTE);
for ( auto& blasData : blasDatas ) {
blasData.as.buffer = this->buffers[blasBufferIndex].alias();
blasData.as.buffer.descriptor.offset = blasBufferOffset;
@ -1402,7 +1402,7 @@ void ext::vulkan::Graphic::generateBottomAccelerationStructures() {
queryCount++
);
}
device.flushCommandBuffer(commandBuffer, uf::renderer::QueueEnum::COMPUTE);
device.flushCommandBuffer(commandBuffer);
}
// compact
if ( queryPool ) {
@ -1426,7 +1426,7 @@ void ext::vulkan::Graphic::generateBottomAccelerationStructures() {
this->buffers[blasBufferIndex].swap(oldBuffer);
size_t blasBufferOffset{};
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, uf::renderer::QueueEnum::COMPUTE);
auto commandBuffer = device.fetchCommandBuffer(uf::renderer::QueueEnum::COMPUTE);
for ( auto& blasData : blasDatas ) {
blasData.as.buffer = this->buffers[blasBufferIndex].alias();
blasData.as.buffer.descriptor.offset = blasBufferOffset;
@ -1452,7 +1452,7 @@ void ext::vulkan::Graphic::generateBottomAccelerationStructures() {
uf::renderer::vkCmdCopyAccelerationStructureKHR(commandBuffer, &copyInfo);
}
device.flushCommandBuffer(commandBuffer, uf::renderer::QueueEnum::COMPUTE);
device.flushCommandBuffer(commandBuffer);
oldBuffer.destroy();
}
@ -1644,7 +1644,7 @@ void ext::vulkan::Graphic::generateTopAccelerationStructure( const uf::stl::vect
VkAccelerationStructureBuildRangeInfoKHR buildOffsetInfo{countInstance, 0, 0, 0};
const VkAccelerationStructureBuildRangeInfoKHR* rangeInfo = &buildOffsetInfo;
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, uf::renderer::QueueEnum::COMPUTE);
auto commandBuffer = device.fetchCommandBuffer(uf::renderer::QueueEnum::COMPUTE);
uf::renderer::vkCmdBuildAccelerationStructuresKHR(
commandBuffer,
1,
@ -1661,7 +1661,7 @@ void ext::vulkan::Graphic::generateTopAccelerationStructure( const uf::stl::vect
0
);
device.flushCommandBuffer(commandBuffer, uf::renderer::QueueEnum::COMPUTE);
device.flushCommandBuffer(commandBuffer);
}
#if TLAS_FRONT_AND_BACK
@ -1671,9 +1671,9 @@ void ext::vulkan::Graphic::generateTopAccelerationStructure( const uf::stl::vect
copyInfo.dst = tlasBack.handle;
copyInfo.mode = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR;
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, uf::renderer::QueueEnum::COMPUTE);
auto commandBuffer = device.fetchCommandBuffer(uf::renderer::QueueEnum::COMPUTE);
uf::renderer::vkCmdCopyAccelerationStructureKHR(commandBuffer, &copyInfo);
device.flushCommandBuffer(commandBuffer, uf::renderer::QueueEnum::COMPUTE);
device.flushCommandBuffer(commandBuffer);
}
#endif
@ -1711,9 +1711,9 @@ void ext::vulkan::Graphic::generateTopAccelerationStructure( const uf::stl::vect
copyInfo.dst = tlas.handle;
copyInfo.mode = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR;
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, uf::renderer::QueueEnum::COMPUTE);
auto commandBuffer = device.fetchCommandBuffer(uf::renderer::QueueEnum::COMPUTE);
uf::renderer::vkCmdCopyAccelerationStructureKHR(commandBuffer, &copyInfo);
device.flushCommandBuffer(commandBuffer, uf::renderer::QueueEnum::COMPUTE);
device.flushCommandBuffer(commandBuffer);
uf::renderer::vkDestroyAccelerationStructureKHR(device, cleanup.handle, nullptr);
oldBuffer.destroy();

18
engine/src/ext/vulkan/rendermode.cpp
View File

@ -77,7 +77,7 @@ uf::Image ext::vulkan::RenderMode::screenshot( size_t attachmentID, size_t layer
VK_CHECK_RESULT(vmaCreateImage(allocator, &imageCreateInfo, &allocationCreateInfo, &temporary, &allocation, &allocationInfo));
VkDeviceMemory temporaryMemory = allocationInfo.deviceMemory;
VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::GRAPHICS);
auto commandBuffer = device->fetchCommandBuffer(QueueEnum::GRAPHICS, true); // waits on flush
VkImageMemoryBarrier imageMemoryBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
@ -93,13 +93,13 @@ uf::Image ext::vulkan::RenderMode::screenshot( size_t attachmentID, size_t layer
imageMemoryBarrier.image = temporary;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
imageMemoryBarrier.image = attachment.image;
imageMemoryBarrier.subresourceRange.baseArrayLayer = layerID;
imageMemoryBarrier.oldLayout = attachment.descriptor.layout;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
if ( attachment.descriptor.samples > 1 ) {
VkOffset3D blitSize;
@ -118,7 +118,7 @@ uf::Image ext::vulkan::RenderMode::screenshot( size_t attachmentID, size_t layer
// imageResolveRegion.dstOffsets[1] = blitSize;
imageResolveRegion.extent = { renderTarget.width, renderTarget.height, 1 };
vkCmdResolveImage( copyCmd, attachment.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageResolveRegion );
vkCmdResolveImage( commandBuffer, attachment.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageResolveRegion );
} else if ( blitting ) {
VkOffset3D blitSize;
blitSize.x = renderTarget.width;
@ -135,7 +135,7 @@ uf::Image ext::vulkan::RenderMode::screenshot( size_t attachmentID, size_t layer
imageBlit.dstSubresource.layerCount = 1;
imageBlit.dstOffsets[1] = blitSize;
vkCmdBlitImage( copyCmd, attachment.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageBlit, VK_FILTER_NEAREST);
vkCmdBlitImage( commandBuffer, attachment.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageBlit, VK_FILTER_NEAREST);
} else {
VkImageCopy imageCopy{};
imageCopy.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@ -146,7 +146,7 @@ uf::Image ext::vulkan::RenderMode::screenshot( size_t attachmentID, size_t layer
imageCopy.dstSubresource.layerCount = 1;
imageCopy.extent = { renderTarget.width, renderTarget.height, 1 };
vkCmdCopyImage( copyCmd, attachment.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopy );
vkCmdCopyImage( commandBuffer, attachment.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopy );
}
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
@ -155,14 +155,14 @@ uf::Image ext::vulkan::RenderMode::screenshot( size_t attachmentID, size_t layer
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
imageMemoryBarrier.image = attachment.image;
imageMemoryBarrier.subresourceRange.baseArrayLayer = layerID;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
imageMemoryBarrier.newLayout = attachment.descriptor.layout;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
device->flushCommandBuffer(copyCmd, QueueEnum::GRAPHICS);
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
device->flushCommandBuffer(commandBuffer);
const uint8_t* data;
vmaMapMemory( allocator, allocation, (void**)&data );

4
engine/src/ext/vulkan/rendermodes/base.cpp
View File

@ -474,7 +474,7 @@ void ext::vulkan::BaseRenderMode::initialize( Device& device ) {
}
#if 0
if ( true ) {
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, uf::renderer::QueueEnum::TRANSFER);
auto commandBuffer = device.fetchCommandBuffer(uf::renderer::QueueEnum::TRANSFER);
for ( size_t i = 0; i < images.size(); ++i ) {
VkImageMemoryBarrier imageMemoryBarrier = {};
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@ -496,7 +496,7 @@ void ext::vulkan::BaseRenderMode::initialize( Device& device ) {
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
}
device.flushCommandBuffer(commandBuffer, uf::renderer::QueueEnum::TRANSFER);
device.flushCommandBuffer(uf::renderer::QueueEnum::TRANSFER);
}
#endif
/*

311
engine/src/ext/vulkan/rendermodes/deferred.cpp
View File

@ -50,8 +50,9 @@ void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
renderTarget.views = metadata.eyes;
size_t msaa = ext::vulkan::settings::msaa;
#if 0
struct {
size_t id, normals, uvs, mips, albedo, depth, color, bright, scratch, output;
size_t id, bary, mips, depth, color, bright, scratch;
} attachments = {};
bool blend = true; // !ext::vulkan::settings::invariant::deferredSampling;
@ -62,40 +63,22 @@ void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
/*.blend = */false,
/*.samples = */msaa,
});
attachments.normals = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R16G16_SFLOAT,
/*.format = */VK_FORMAT_R16G16_SNORM,
attachments.bary = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R16G16_SNORM,
/*.format = */VK_FORMAT_R16G16_SFLOAT,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
attachments.mips = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R32G32B32A32_SFLOAT,
/*.format = */VK_FORMAT_R16G16_SFLOAT,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
if ( ext::vulkan::settings::invariant::deferredSampling ) {
attachments.uvs = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R32G32B32A32_SFLOAT,
/*.format = */VK_FORMAT_R16G16B16A16_SFLOAT,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
attachments.mips = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R32G32B32A32_SFLOAT,
/*.format = */VK_FORMAT_R16G16_SFLOAT,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
} else {
attachments.albedo = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format = */ext::vulkan::settings::pipelines::hdr ? HDR_FORMAT : VK_FORMAT_R8G8B8A8_UNORM,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */blend,
/*.samples = */msaa,
});
}
attachments.depth = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format = */ext::vulkan::settings::formats::depth,
/*.layout = */VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
@ -124,44 +107,6 @@ void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
/*.blend =*/ blend,
/*.samples =*/ 1,
});
// Attach swapchain's image as output
if ( settings::invariant::deferredAliasOutputToSwapchain ) {
attachments.output = renderTarget.attachments.size();
auto& swapchainAttachment = renderTarget.attachments.emplace_back();
swapchainAttachment.descriptor.format = ext::vulkan::settings::formats::color; //device.formats.color;
swapchainAttachment.descriptor.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swapchainAttachment.descriptor.layout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
swapchainAttachment.descriptor.aliased = true;
{
VkBool32 blendEnabled = blend;
VkColorComponentFlags writeMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
VkPipelineColorBlendAttachmentState blendAttachmentState = ext::vulkan::initializers::pipelineColorBlendAttachmentState(
writeMask,
blendEnabled
);
if ( blendEnabled == VK_TRUE ) {
blendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
blendAttachmentState.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
blendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD;
blendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
blendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
blendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD;
}
swapchainAttachment.blendState = blendAttachmentState;
}
} else {
attachments.output = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format =*/ ext::vulkan::settings::pipelines::hdr ? HDR_FORMAT : SDR_FORMAT,
/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage =*/ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
/*.blend =*/ blend,
/*.samples =*/ 1,
});
}
metadata.outputs.emplace_back(attachments.color);
// metadata.outputs.emplace_back(attachments.output);
for ( size_t eye = 0; eye < metadata.eyes; ++eye ) {
if ( ext::vulkan::settings::invariant::deferredSampling ) {
// First pass: fill the G-Buffer
@ -215,7 +160,108 @@ void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
}
}
}
#else
struct {
size_t id, bary, mips, normals, uvs, depth, color, bright, scratch, output;
} attachments = {};
bool blend = true; // !ext::vulkan::settings::invariant::deferredSampling;
attachments.id = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format = */VK_FORMAT_R16G16B16A16_UINT,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
attachments.bary = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R32G32B32A32_SFLOAT,
/*.format = */VK_FORMAT_R16G16_SNORM,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
attachments.mips = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R32G32B32A32_SFLOAT,
/*.format = */VK_FORMAT_R16G16_SFLOAT,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
attachments.normals = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R16G16_SFLOAT,
/*.format = */VK_FORMAT_R16G16_SNORM,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
attachments.uvs = renderTarget.attach(RenderTarget::Attachment::Descriptor{
// /*.format = */VK_FORMAT_R32G32B32A32_SFLOAT,
/*.format = */VK_FORMAT_R16G16B16A16_SFLOAT,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
attachments.depth = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format = */ext::vulkan::settings::formats::depth,
/*.layout = */VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */false,
/*.samples = */msaa,
});
attachments.color = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format =*/ ext::vulkan::settings::pipelines::hdr ? HDR_FORMAT : SDR_FORMAT,
/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage =*/ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
/*.blend =*/ blend,
/*.samples =*/ 1,
});
attachments.bright = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format =*/ ext::vulkan::settings::pipelines::hdr ? HDR_FORMAT : SDR_FORMAT,
/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage =*/ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT,
/*.blend =*/ blend,
/*.samples =*/ 1,
});
attachments.scratch = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format =*/ ext::vulkan::settings::pipelines::hdr ? HDR_FORMAT : SDR_FORMAT,
/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage =*/ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT,
/*.blend =*/ blend,
/*.samples =*/ 1,
});
for ( size_t eye = 0; eye < metadata.eyes; ++eye ) {
// First pass: fill the G-Buffer
{
renderTarget.addPass(
/*.*/ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
/*.colors =*/ { attachments.id, attachments.bary, attachments.mips, attachments.normals, attachments.uvs },
/*.inputs =*/ {},
/*.resolve =*/{},
/*.depth = */ attachments.depth,
/*.layer = */eye,
/*.autoBuildPipeline =*/ true
);
}
// Second pass: write to color
{
renderTarget.addPass(
/*.*/ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
/*.colors =*/ { attachments.color, attachments.bright },
/*.inputs =*/ { attachments.id, attachments.bary, attachments.mips, attachments.normals, attachments.uvs, attachments.depth },
/*.resolve =*/{},
/*.depth = */attachments.depth,
/*.layer = */eye,
/*.autoBuildPipeline =*/ false
);
}
}
#endif
metadata.outputs.emplace_back(attachments.color);
renderTarget.initialize( device );
{
@ -245,12 +291,12 @@ void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
blitter.initializeMesh( mesh );
{
uf::stl::string vertexShaderFilename = uf::io::root+"/shaders/display/renderTargetSimple.vert.spv";
uf::stl::string fragmentShaderFilename = uf::io::root+"/shaders/display/renderTargetSimple.frag.spv"; {
uf::stl::string vertexShaderFilename = uf::io::root+"/shaders/display/renderTarget.vert.spv";
uf::stl::string fragmentShaderFilename = uf::io::root+"/shaders/display/renderTarget.frag.spv";
{
std::pair<bool, uf::stl::string> settings[] = {
{ msaa > 1, "msaa.frag" },
// I don't actually have support for deferred sampling within a render target
// { uf::renderer::settings::invariant::deferredSampling, "deferredSampling.frag" },
{ !settings::pipelines::rt, "postProcess.frag" },
// { msaa > 1, "msaa.frag" },
};
FOR_ARRAY( settings ) if ( settings[i].first ) fragmentShaderFilename = uf::string::replace( fragmentShaderFilename, "frag", settings[i].second );
}
@ -265,25 +311,6 @@ void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
auto& shader = blitter.material.getShader("fragment");
shader.textures.clear();
shader.textures.emplace_back().aliasAttachment( renderTarget.attachments[index], (size_t) 0 ); // attachments.color
/*
for ( auto& texture : shader.textures ) {
texture.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
texture.descriptor.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
}
*/
/*
for ( auto& attachment : renderTarget.attachments ) {
if ( !(attachment.descriptor.usage & VK_IMAGE_USAGE_SAMPLED_BIT) ) continue;
Texture2D& texture = shader.textures.emplace_back();
enums::Filter::type_t filter = VK_FILTER_NEAREST;
texture.sampler.descriptor.filter.min = filter;
texture.sampler.descriptor.filter.mag = filter;
texture.aliasAttachment(attachment);
}
*/
}
if ( settings::pipelines::deferred ) {
@ -292,22 +319,28 @@ void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
std::pair<bool, uf::stl::string> settings[] = {
{ uf::renderer::settings::pipelines::vxgi, "vxgi.frag" },
{ msaa > 1, "msaa.frag" },
{ uf::renderer::settings::invariant::deferredSampling, "deferredSampling.frag" },
{ uf::renderer::settings::pipelines::rt, "rt.frag" },
};
FOR_ARRAY( settings ) if ( settings[i].first ) fragmentShaderFilename = uf::string::replace( fragmentShaderFilename, "frag", settings[i].second );
}
UF_MSG_DEBUG("Using fragment shader: {}", fragmentShaderFilename);
/*
blitter.material.initializeShaders({
{uf::io::resolveURI(vertexShaderFilename), VK_SHADER_STAGE_VERTEX_BIT},
{uf::io::resolveURI(fragmentShaderFilename), VK_SHADER_STAGE_FRAGMENT_BIT}
}, "deferred");
*/
blitter.material.attachShader(uf::io::resolveURI(vertexShaderFilename), uf::renderer::enums::Shader::VERTEX, "deferred");
blitter.material.attachShader(uf::io::resolveURI(fragmentShaderFilename), uf::renderer::enums::Shader::FRAGMENT, "deferred");
}
#if 0
if ( settings::pipelines::deferred ) {
uf::stl::string computeShaderFilename = uf::io::root+"/shaders/display/subpass.comp.spv"; {
std::pair<bool, uf::stl::string> settings[] = {
{ uf::renderer::settings::pipelines::vxgi, "vxgi.comp" },
{ msaa > 1, "msaa.comp" },
{ uf::renderer::settings::pipelines::rt, "rt.comp" },
};
FOR_ARRAY( settings ) if ( settings[i].first ) computeShaderFilename = uf::string::replace( computeShaderFilename, "comp", settings[i].second );
}
blitter.material.attachShader(uf::io::resolveURI(computeShaderFilename), uf::renderer::enums::Shader::COMPUTE, "deferred-compute");
}
#endif
if ( settings::pipelines::bloom ) {
uf::stl::string computeShaderFilename = uf::io::resolveURI(uf::io::root+"/shaders/display/bloom.comp.spv");
@ -396,6 +429,15 @@ void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
blitter.initializePipeline( descriptor );
}
}
#if 0
for ( size_t eye = 0; eye < metadata.eyes; ++eye ) {
descriptor.pipeline = "deferred-compute";
descriptor.subpass = 0;
if ( !blitter.hasPipeline( descriptor ) ) {
blitter.initializePipeline( descriptor );
}
}
#endif
}
if ( settings::pipelines::bloom ) {
@ -415,6 +457,19 @@ void ext::vulkan::DeferredRenderMode::tick() {
bool resized = this->width == 0 && this->height == 0 && ext::vulkan::states::resized;
bool rebuild = resized || ext::vulkan::states::rebuild || this->rebuild;
// update post processing
if ( blitter.material.hasShader("fragment") && !settings::pipelines::rt ) {
auto& shader = blitter.material.getShader("fragment");
struct {
float curTime = 0;
} uniforms;
uniforms.curTime = uf::time::current;
shader.updateBuffer( (const void*) &uniforms, sizeof(uniforms), shader.getUniformBuffer("UBO") );
}
if ( resized ) {
renderTarget.initialize( *renderTarget.device );
@ -437,24 +492,6 @@ void ext::vulkan::DeferredRenderMode::tick() {
auto& shader = blitter.material.getShader("fragment");
shader.textures.clear();
shader.textures.emplace_back().aliasAttachment( renderTarget.attachments[index], (size_t) 0 ); // attachments.color
/*
for ( auto& texture : shader.textures ) {
texture.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
texture.descriptor.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
}
*/
/*
for ( auto& attachment : renderTarget.attachments ) {
if ( !(attachment.descriptor.usage & VK_IMAGE_USAGE_SAMPLED_BIT) ) continue;
Texture2D& texture = shader.textures.emplace_back();
enums::Filter::type_t filter = VK_FILTER_NEAREST;
texture.sampler.descriptor.filter.min = filter;
texture.sampler.descriptor.filter.mag = filter;
texture.aliasAttachment(attachment);
}
*/
}
if ( blitter.hasPipeline( blitter.descriptor ) ){
@ -472,6 +509,17 @@ void ext::vulkan::DeferredRenderMode::tick() {
}
}
}
#if 0
if ( settings::pipelines::deferred ) {
for ( size_t eye = 0; eye < metadata.eyes; ++eye ) {
descriptor.pipeline = "deferred-compute";
descriptor.subpass = 0;
if ( blitter.hasPipeline( descriptor ) ) {
blitter.getPipeline( descriptor ).update( blitter, descriptor );
}
}
}
#endif
if ( settings::pipelines::bloom ) {
descriptor.inputs.dispatch = { (width / 8) + 1, (height / 8) + 1, 1 };
@ -547,8 +595,8 @@ void ext::vulkan::DeferredRenderMode::createCommandBuffers( const uf::stl::vecto
cmdBufInfo.pNext = nullptr;
VkImageMemoryBarrier imageMemoryBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device->queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device->queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
imageMemoryBarrier.subresourceRange.levelCount = 1;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
@ -713,10 +761,25 @@ void ext::vulkan::DeferredRenderMode::createCommandBuffers( const uf::stl::vecto
imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
#if 0
if ( device->queueFamilyIndices.graphics != device->queueFamilyIndices.compute ) {
imageMemoryBarrier.srcQueueFamilyIndex = device->queueFamilyIndices.graphics;
imageMemoryBarrier.dstQueueFamilyIndex = device->queueFamilyIndices.compute;
} else {
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
}
#endif
for ( auto& attachment : shader.textures ) {
imageMemoryBarrier.image = attachment.image;
vkCmdPipelineBarrier( commands[i], VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_FLAGS_NONE, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
}
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
#if 0
blitter.record(commands[i], descriptor, 0, 0);
@ -746,6 +809,14 @@ void ext::vulkan::DeferredRenderMode::createCommandBuffers( const uf::stl::vecto
blitter.record(commands[i], descriptor, 0, 3);
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
#if 0
if ( device->queueFamilyIndices.graphics != device->queueFamilyIndices.compute ) {
imageMemoryBarrier.srcQueueFamilyIndex = device->queueFamilyIndices.compute;
imageMemoryBarrier.dstQueueFamilyIndex = device->queueFamilyIndices.graphics;
}
#endif
for ( auto& attachment : shader.textures ) {
imageMemoryBarrier.image = attachment.image;
vkCmdPipelineBarrier( commands[i], VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, VK_FLAGS_NONE, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );

62
engine/src/ext/vulkan/rendermodes/rendertarget.cpp
View File

@ -95,34 +95,35 @@ void ext::vulkan::RenderTargetRenderMode::initialize( Device& device ) {
}
} else {
for ( size_t currentPass = 0; currentPass < metadata.subpasses; ++currentPass ) {
if ( metadata.type == "single" ) {
struct {
size_t albedo, depth;
} attachments = {};
struct {
size_t albedo, depth;
} attachments = {};
attachments.albedo = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format = */VK_FORMAT_R8G8B8A8_UNORM,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */true,
/*.samples = */msaa,
});
attachments.depth = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format = */ ext::vulkan::settings::formats::depth,
/*.layout = */ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
/*.usage = */ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
/*.blend = */ false,
/*.samples = */ 1,
});
renderTarget.addPass(
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
{ attachments.albedo },
{},
{},
attachments.depth,
0,
true
);
attachments.albedo = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format = */VK_FORMAT_R8G8B8A8_UNORM,
/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
/*.blend = */true,
/*.samples = */msaa,
});
attachments.depth = renderTarget.attach(RenderTarget::Attachment::Descriptor{
/*.format = */ ext::vulkan::settings::formats::depth,
/*.layout = */ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
/*.usage = */ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
/*.blend = */ false,
/*.samples = */ 1,
});
renderTarget.addPass(
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
{ attachments.albedo },
{},
{},
attachments.depth,
0,
true
);
#if 0
if ( metadata.type == "single" ) {
} else {
struct {
size_t id, normals, uvs, albedo, depth, output;
@ -226,6 +227,7 @@ void ext::vulkan::RenderTargetRenderMode::initialize( Device& device ) {
}
metadata.outputs.emplace_back(attachments.output);
}
#endif
}
}
@ -299,12 +301,10 @@ void ext::vulkan::RenderTargetRenderMode::initialize( Device& device ) {
// do not attach if we're requesting no blitter shaders
blitter.process = false;
} else {
uf::stl::string vertexShaderFilename = uf::io::root+"/shaders/display/renderTargetSimple.vert.spv";
uf::stl::string fragmentShaderFilename = uf::io::root+"/shaders/display/renderTargetSimple.frag.spv"; {
uf::stl::string vertexShaderFilename = uf::io::root+"/shaders/display/renderTarget.vert.spv";
uf::stl::string fragmentShaderFilename = uf::io::root+"/shaders/display/renderTarget.frag.spv"; {
std::pair<bool, uf::stl::string> settings[] = {
{ msaa > 1, "msaa.frag" },
// I don't actually have support for deferred sampling within a render target
// { uf::renderer::settings::invariant::deferredSampling, "deferredSampling.frag" },
};
FOR_ARRAY( settings ) if ( settings[i].first ) fragmentShaderFilename = uf::string::replace( fragmentShaderFilename, "frag", settings[i].second );
}

93
engine/src/ext/vulkan/texture.cpp
View File

@ -528,7 +528,7 @@ void ext::vulkan::Texture::fromBuffers(
subresourceRange.levelCount = this->mips;
subresourceRange.layerCount = this->layers;
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::GRAPHICS);
auto commandBuffer = device.fetchCommandBuffer(QueueEnum::GRAPHICS);
setImageLayout(
commandBuffer,
image,
@ -536,7 +536,7 @@ void ext::vulkan::Texture::fromBuffers(
imageLayout,
subresourceRange
);
device.flushCommandBuffer(commandBuffer, QueueEnum::GRAPHICS);
device.flushCommandBuffer(commandBuffer);
this->imageLayout = imageLayout;
}
@ -575,11 +575,11 @@ void ext::vulkan::Texture::asRenderTarget( Device& device, uint32_t width, uint3
VK_CHECK_RESULT(vmaCreateImage(allocator, &imageCreateInfo, &allocInfo, &image, &allocation, &allocationInfo));
deviceMemory = allocationInfo.deviceMemory;
VkCommandBuffer layoutCmd = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::GRAPHICS);
auto commandBuffer = device.fetchCommandBuffer(QueueEnum::GRAPHICS);
imageLayout = VK_IMAGE_LAYOUT_GENERAL;
setImageLayout(
layoutCmd,
commandBuffer,
image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
@ -587,7 +587,7 @@ void ext::vulkan::Texture::asRenderTarget( Device& device, uint32_t width, uint3
this->mips
);
device.flushCommandBuffer(layoutCmd, QueueEnum::GRAPHICS);
device.flushCommandBuffer(commandBuffer);
// Create sampler
// sampler.initialize( device );
@ -702,7 +702,6 @@ void ext::vulkan::Texture::update( void* data, VkDeviceSize bufferSize, VkImageL
bufferCopyRegion.imageExtent.depth = depth;
bufferCopyRegion.bufferOffset = 0;
//
#if 1
Buffer staging = device.fetchTransientBuffer(
data,
bufferSize,
@ -711,7 +710,7 @@ void ext::vulkan::Texture::update( void* data, VkDeviceSize bufferSize, VkImageL
);
// Use a separate command buffer for texture loading
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::GRAPHICS);
auto commandBuffer = device.fetchCommandBuffer(QueueEnum::GRAPHICS);
// Image barrier for optimal image (target)
// Optimal image will be used as destination for the copy
@ -731,7 +730,7 @@ void ext::vulkan::Texture::update( void* data, VkDeviceSize bufferSize, VkImageL
1,
&bufferCopyRegion
);
if ( this->mips > 1 ) this->generateMipmaps(commandBuffer, layer);
if ( this->mips > 1 ) this->generateMipmaps(commandBuffer.handle, layer);
setImageLayout(
commandBuffer,
image,
@ -740,51 +739,7 @@ void ext::vulkan::Texture::update( void* data, VkDeviceSize bufferSize, VkImageL
subresourceRange
);
device.flushCommandBuffer(commandBuffer, QueueEnum::GRAPHICS);
#else
Buffer staging;
VK_CHECK_RESULT(device.createBuffer(
data,
bufferSize,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
staging
));
// Use a separate command buffer for texture loading
VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::GRAPHICS);
// Image barrier for optimal image (target)
// Optimal image will be used as destination for the copy
setImageLayout(
commandBuffer,
image,
imageLayout,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
subresourceRange
);
// Copy mip levels from staging buffer
vkCmdCopyBufferToImage(
commandBuffer,
staging.buffer,
image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&bufferCopyRegion
);
if ( this->mips > 1 ) this->generateMipmaps(commandBuffer, layer);
setImageLayout(
commandBuffer,
image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
targetImageLayout,
subresourceRange
);
device.flushCommandBuffer(commandBuffer, QueueEnum::GRAPHICS);
// Clean up staging resources
staging.destroy();
#endif
device.flushCommandBuffer(commandBuffer);
this->imageLayout = targetImageLayout;
@ -908,7 +863,7 @@ uf::Image ext::vulkan::Texture2D::screenshot( uint32_t layerID ) {
VK_CHECK_RESULT(vmaCreateImage(allocator, &imageCreateInfo, &allocationCreateInfo, &temporary, &allocation, &allocationInfo));
VkDeviceMemory temporaryMemory = allocationInfo.deviceMemory;
VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::GRAPHICS);
auto commandBuffer = device->fetchCommandBuffer(QueueEnum::GRAPHICS, true); // waits on flush
VkImageMemoryBarrier imageMemoryBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
@ -924,13 +879,13 @@ uf::Image ext::vulkan::Texture2D::screenshot( uint32_t layerID ) {
imageMemoryBarrier.image = temporary;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
imageMemoryBarrier.image = this->image;
imageMemoryBarrier.subresourceRange.baseArrayLayer = layerID;
imageMemoryBarrier.oldLayout = descriptor.imageLayout;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
if ( blitting ) {
VkOffset3D blitSize;
@ -948,7 +903,7 @@ uf::Image ext::vulkan::Texture2D::screenshot( uint32_t layerID ) {
imageBlit.dstSubresource.layerCount = 1;
imageBlit.dstOffsets[1] = blitSize;
vkCmdBlitImage( copyCmd, this->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageBlit, VK_FILTER_NEAREST);
vkCmdBlitImage( commandBuffer, this->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageBlit, VK_FILTER_NEAREST);
} else {
VkImageCopy imageCopy{};
imageCopy.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@ -959,7 +914,7 @@ uf::Image ext::vulkan::Texture2D::screenshot( uint32_t layerID ) {
imageCopy.dstSubresource.layerCount = 1;
imageCopy.extent = { this->width, this->height, 1 };
vkCmdCopyImage( copyCmd, this->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopy );
vkCmdCopyImage( commandBuffer, this->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopy );
}
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
@ -968,14 +923,14 @@ uf::Image ext::vulkan::Texture2D::screenshot( uint32_t layerID ) {
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
imageMemoryBarrier.image = this->image;
imageMemoryBarrier.subresourceRange.baseArrayLayer = layerID;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
imageMemoryBarrier.newLayout = descriptor.imageLayout;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
device->flushCommandBuffer(copyCmd, QueueEnum::GRAPHICS);
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
device->flushCommandBuffer(commandBuffer);
const uint8_t* data;
vmaMapMemory( allocator, allocation, (void**)&data );
@ -1016,7 +971,7 @@ uf::Image ext::vulkan::Texture3D::screenshot( uint32_t layerID ) {
VK_CHECK_RESULT(vmaCreateImage(allocator, &imageCreateInfo, &allocationCreateInfo, &temporary, &allocation, &allocationInfo));
VkDeviceMemory temporaryMemory = allocationInfo.deviceMemory;
VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, QueueEnum::GRAPHICS);
auto commandBuffer = device->fetchCommandBuffer(QueueEnum::GRAPHICS);
VkImageMemoryBarrier imageMemoryBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
@ -1032,13 +987,13 @@ uf::Image ext::vulkan::Texture3D::screenshot( uint32_t layerID ) {
imageMemoryBarrier.image = temporary;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
imageMemoryBarrier.image = this->image;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.oldLayout = descriptor.imageLayout;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
if ( blitting ) {
VkOffset3D blitSize;
@ -1058,7 +1013,7 @@ uf::Image ext::vulkan::Texture3D::screenshot( uint32_t layerID ) {
imageBlit.dstOffsets[0] = { 0, 0, 0 };
imageBlit.dstOffsets[1] = { this->width, this->height, 1 };
vkCmdBlitImage( copyCmd, this->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageBlit, VK_FILTER_NEAREST);
vkCmdBlitImage( commandBuffer, this->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageBlit, VK_FILTER_NEAREST);
} else {
VkImageCopy imageCopy{};
imageCopy.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@ -1072,7 +1027,7 @@ uf::Image ext::vulkan::Texture3D::screenshot( uint32_t layerID ) {
imageCopy.dstOffset = { 0, 0, 0 };
imageCopy.extent = { this->width, this->height, 1 };
vkCmdCopyImage( copyCmd, this->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopy );
vkCmdCopyImage( commandBuffer, this->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, temporary, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopy );
}
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
@ -1081,14 +1036,14 @@ uf::Image ext::vulkan::Texture3D::screenshot( uint32_t layerID ) {
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
imageMemoryBarrier.image = this->image;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
imageMemoryBarrier.newLayout = descriptor.imageLayout;
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
device->flushCommandBuffer(copyCmd, QueueEnum::GRAPHICS);
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
device->flushCommandBuffer(commandBuffer);
const uint8_t* data;
vmaMapMemory( allocator, allocation, (void**)&data );

41
engine/src/ext/vulkan/vulkan.cpp
View File

@ -23,6 +23,8 @@ uint32_t ext::vulkan::settings::height = 720;
uint8_t ext::vulkan::settings::msaa = 1;
bool ext::vulkan::settings::validation = true;
bool ext::vulkan::settings::defaultStageBuffers = true;
bool ext::vulkan::settings::defaultDeferBufferDestroy = true;
bool ext::vulkan::settings::defaultCommandBufferWait = true;
// constexpr size_t ext::vulkan::settings::maxViews = 6;
size_t ext::vulkan::settings::viewCount = 2;
size_t ext::vulkan::settings::gpuID = -1;
@ -73,8 +75,6 @@ uf::stl::string ext::vulkan::settings::pipelines::names::rt = "rt";
VkColorSpaceKHR ext::vulkan::settings::formats::colorSpace;
ext::vulkan::enums::Format::type_t ext::vulkan::settings::formats::color = ext::vulkan::enums::Format::R8G8B8A8_UNORM;
ext::vulkan::enums::Format::type_t ext::vulkan::settings::formats::depth = ext::vulkan::enums::Format::D32_SFLOAT;
ext::vulkan::enums::Format::type_t ext::vulkan::settings::formats::normal = ext::vulkan::enums::Format::R16G16B16A16_SFLOAT;
ext::vulkan::enums::Format::type_t ext::vulkan::settings::formats::position = ext::vulkan::enums::Format::R16G16B16A16_SFLOAT;
ext::vulkan::Device ext::vulkan::device;
ext::vulkan::Allocator ext::vulkan::allocator;
@ -436,26 +436,18 @@ void ext::vulkan::tick() {
void ext::vulkan::render() {
ext::vulkan::mutex.lock();
// process in-flight resources
{
// cleanup in-flight commands
for ( auto& pair : device.transient.commandBuffers ) {
auto queueType = pair.first;
auto& commandBuffers = pair.second;
auto& queue = device.getQueue( queueType );
auto& commandPool = device.getCommandPool( queueType );
// cleanup in-flight commands
for ( auto& pair : device.transient.commandBuffers ) {
auto queueType = pair.first;
auto& commandBuffers = pair.second;
auto& queue = device.getQueue( queueType );
auto& commandPool = device.getCommandPool( queueType );
VK_CHECK_RESULT(vkQueueWaitIdle( queue ));
vkFreeCommandBuffers(device, commandPool, commandBuffers.size(), commandBuffers.data());
VK_CHECK_RESULT(vkQueueWaitIdle( queue ));
vkFreeCommandBuffers(device, commandPool, commandBuffers.size(), commandBuffers.data());
commandBuffers.clear();
}
// cleanup in-flight buffers
for ( auto& buffer : device.transient.buffers ) {
buffer.destroy();
}
device.transient.buffers.clear();
commandBuffers.clear();
}
#if 0
// process reusable commands
@ -552,14 +544,17 @@ void ext::vulkan::render() {
ext::vulkan::setCurrentRenderMode(NULL);
// renderMode->unlockMutex( renderMode->mostRecentCommandPoolId );
}
for ( auto& renderMode : renderModes ) {
// renderMode->cleanupCommands( renderMode->mostRecentCommandPoolId );
}
// for ( auto& renderMode : renderModes ) renderMode->cleanupCommands( renderMode->mostRecentCommandPoolId );
}
if ( ext::vulkan::settings::invariant::waitOnRenderEnd ) synchronize();
// if ( ext::openvr::context ) ext::openvr::postSubmit();
// cleanup in-flight buffers
for ( auto& buffer : device.transient.buffers ) buffer.destroy(false);
device.transient.buffers.clear();
ext::vulkan::mutex.unlock();
}
void ext::vulkan::destroy() {

9
ext/behaviors/raytrace/behavior.cpp
View File

@ -30,8 +30,8 @@ void ext::RayTraceSceneBehavior::initialize( uf::Object& self ) {
if ( !uf::renderer::hasRenderMode("Compute", true) ) {
auto* renderMode = new uf::renderer::RenderTargetRenderMode;
renderMode->setTarget("Compute");
renderMode->metadata.json["shaders"]["vertex"] = "/shaders/display/renderTargetSimple.vert.spv";
renderMode->metadata.json["shaders"]["fragment"] = "/shaders/display/renderTargetSimple.frag.spv";
renderMode->metadata.json["shaders"]["vertex"] = "/shaders/display/renderTarget.vert.spv";
renderMode->metadata.json["shaders"]["fragment"] = "/shaders/display/renderTarget.postProcess.frag.spv";
renderMode->blitter.descriptor.renderMode = "Swapchain";
renderMode->blitter.descriptor.subpass = 0;
@ -114,10 +114,13 @@ void ext::RayTraceSceneBehavior::tick( uf::Object& self ) {
if ( size.y == 0 ) size.y = uf::renderer::settings::height * metadata.renderer.scale;
UF_MSG_DEBUG("Size: {}", uf::vector::toString( size ));
auto HDR_FORMAT = uf::renderer::enums::Format::R32G32B32A32_SFLOAT;
auto SDR_FORMAT = uf::renderer::enums::Format::R16G16B16A16_SFLOAT; // uf::renderer::enums::Format::R8G8B8A8_UNORM
auto& image = shader.textures.emplace_back();
image.fromBuffers(
NULL, 0,
uf::renderer::enums::Format::R8G8B8A8_UNORM,
uf::renderer::settings::pipelines::hdr ? HDR_FORMAT : SDR_FORMAT,
size.x, size.y, 1, 1,
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_LAYOUT_GENERAL
);

13
ext/behaviors/scene/behavior.cpp
View File

@ -691,6 +691,19 @@ void ext::ExtSceneBehavior::Metadata::deserialize( uf::Object& self, uf::Seriali
/*this->*/shader.parameters = uf::vector::decode( serializer["system"]["renderer"]["shader"]["parameters"], /*this->*/shader.parameters );
/*this->*/shader.frameAccumulateLimit = serializer["system"]["renderer"]["shader"]["frame accumulate limit"].as(/*this->*/shader.frameAccumulateLimit);
#if UF_AUDIO_MAPPED_VOLUMES
ext::json::forEach( serializer["volumes"], []( const uf::stl::string& key, ext::json::Value& value ){
float volume; volume = value.as(volume);
uf::audio::volumes[key] = volume;
});
#else
if ( ext::json::isObject( serializer["volumes"] ) ) {
uf::audio::volumes::bgm = serializer["volumes"]["bgm"].as(uf::audio::volumes::bgm);
uf::audio::volumes::sfx = serializer["volumes"]["sfx"].as(uf::audio::volumes::sfx);
uf::audio::volumes::voice = serializer["volumes"]["voice"].as(uf::audio::volumes::voice);
}
#endif
ext::json::forEach( serializer["system"]["renderer"]["shader"]["parameters"], [&]( uint32_t i, const ext::json::Value& value ){
if ( value.as<uf::stl::string>() == "time" ) /*this->*/shader.time = i;
});

9
ext/behaviors/voxelizer/behavior.cpp
View File

@ -78,13 +78,16 @@ void ext::VoxelizerSceneBehavior::initialize( uf::Object& self ) {
auto& radiance = sceneTextures.voxels.radiance.emplace_back();
// auto& depth = sceneTextures.voxels.depth.emplace_back();
id.sampler.descriptor.filter.min = VK_FILTER_NEAREST;
id.sampler.descriptor.filter.mag = VK_FILTER_NEAREST;
id.sampler.descriptor.filter.min = uf::renderer::enums::Filter::NEAREST;
id.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::NEAREST;
auto HDR_FORMAT = uf::renderer::enums::Format::R32G32B32A32_SFLOAT;
auto SDR_FORMAT = uf::renderer::enums::Format::R16G16B16A16_SFLOAT; // uf::renderer::enums::Format::R8G8B8A8_UNORM
id.fromBuffers( NULL, 0, uf::renderer::enums::Format::R16G16_UINT, metadata.voxelSize.x, metadata.voxelSize.y, metadata.voxelSize.z, 1, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_LAYOUT_GENERAL );
// uv.fromBuffers( NULL, 0, uf::renderer::enums::Format::R16G16_SFLOAT, metadata.voxelSize.x, metadata.voxelSize.y, metadata.voxelSize.z, 1, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_LAYOUT_GENERAL );
normal.fromBuffers( NULL, 0, uf::renderer::enums::Format::R16G16_SFLOAT, metadata.voxelSize.x, metadata.voxelSize.y, metadata.voxelSize.z, 1, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_LAYOUT_GENERAL );
radiance.fromBuffers( NULL, 0, HDR ? uf::renderer::enums::Format::R16G16B16A16_SFLOAT : uf::renderer::enums::Format::R8G8B8A8_UNORM, metadata.voxelSize.x, metadata.voxelSize.y, metadata.voxelSize.z, 1, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_LAYOUT_GENERAL );
radiance.fromBuffers( NULL, 0, uf::renderer::settings::pipelines::hdr ? HDR_FORMAT : SDR_FORMAT, metadata.voxelSize.x, metadata.voxelSize.y, metadata.voxelSize.z, 1, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_LAYOUT_GENERAL );
// depth.fromBuffers( (void*) empty.data(), empty.size(), uf::renderer::enums::Format::R16_SFLOAT, metadata.voxelSize.x, metadata.voxelSize.y, metadata.voxelSize.z, 1, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_LAYOUT_GENERAL );
}
// initialize render mode

16
ext/main.cpp
View File

@ -306,9 +306,11 @@ void EXT_API ext::initialize() {
uf::audio::volumes[key] = volume;
});
#else
uf::audio::volumes::bgm = configEngineAudioJson["volumes"]["bgm"].as(uf::audio::volumes::bgm);
uf::audio::volumes::sfx = configEngineAudioJson["volumes"]["sfx"].as(uf::audio::volumes::sfx);
uf::audio::volumes::voice = configEngineAudioJson["volumes"]["voice"].as(uf::audio::volumes::voice);
if ( ext::json::isObject( configEngineAudioJson["volumes"] ) ) {
uf::audio::volumes::bgm = configEngineAudioJson["volumes"]["bgm"].as(uf::audio::volumes::bgm);
uf::audio::volumes::sfx = configEngineAudioJson["volumes"]["sfx"].as(uf::audio::volumes::sfx);
uf::audio::volumes::voice = configEngineAudioJson["volumes"]["voice"].as(uf::audio::volumes::voice);
}
#endif
}
@ -364,7 +366,9 @@ void EXT_API ext::initialize() {
uf::renderer::settings::validation = configRenderJson["validation"]["enabled"].as( uf::renderer::settings::validation );
uf::renderer::settings::msaa = configRenderJson["framebuffer"]["msaa"].as( uf::renderer::settings::msaa );
uf::renderer::settings::defaultStageBuffers = configRenderJson["invariant"]["defaultStageBuffers"].as( uf::renderer::settings::defaultStageBuffers );
uf::renderer::settings::defaultStageBuffers = configRenderJson["invariant"]["default stage buffers"].as( uf::renderer::settings::defaultStageBuffers );
uf::renderer::settings::defaultDeferBufferDestroy = configRenderJson["invariant"]["default defer buffer destroy"].as( uf::renderer::settings::defaultDeferBufferDestroy );
uf::renderer::settings::defaultCommandBufferWait = configRenderJson["invariant"]["default command buffer wait"].as( uf::renderer::settings::defaultCommandBufferWait );
if ( configRenderJson["framebuffer"]["size"].is<float>() ) {
float scale = configRenderJson["framebuffer"]["size"].as(1.0f);
@ -421,7 +425,7 @@ void EXT_API ext::initialize() {
uf::renderer::settings::invariant::individualPipelines = configRenderInvariantJson["individual pipelines"].as( uf::renderer::settings::invariant::individualPipelines );
uf::renderer::settings::invariant::deferredMode = configRenderInvariantJson["deferred mode"].as( uf::renderer::settings::invariant::deferredMode );
uf::renderer::settings::invariant::deferredAliasOutputToSwapchain = configRenderInvariantJson["deferred alias output to swapchain"].as( uf::renderer::settings::invariant::deferredAliasOutputToSwapchain );
uf::renderer::settings::invariant::deferredSampling = configRenderInvariantJson["deferred sampling"].as( uf::renderer::settings::invariant::deferredSampling );
uf::renderer::settings::invariant::deferredSampling = true; // configRenderInvariantJson["deferred sampling"].as( uf::renderer::settings::invariant::deferredSampling );
uf::renderer::settings::pipelines::deferred = configRenderPipelinesJson["deferred"].as( uf::renderer::settings::pipelines::deferred );
uf::renderer::settings::pipelines::vsync = configRenderPipelinesJson["vsync"].as( uf::renderer::settings::pipelines::vsync );
@ -449,8 +453,6 @@ void EXT_API ext::initialize() {
JSON_TO_VKFORMAT(color);
JSON_TO_VKFORMAT(depth);
JSON_TO_VKFORMAT(normal);
JSON_TO_VKFORMAT(position);
#endif
}