From 0081887f197083933abfc9461020bc39cb5d608d Mon Sep 17 00:00:00 2001
From: matthew <matthew@sleepy.day>
Date: Mon, 4 Aug 2025 11:05:47 +1000
Subject: [PATCH] add alpha to shaders, fix vulkan cleanup

---
 assets/shaders/gradient.comp.spv | Bin 3944 -> 4096 bytes
 assets/shaders/gui.frag.spv      | Bin 2716 -> 2868 bytes
 assets/shaders/gui.vert.spv      | Bin 5204 -> 5356 bytes
 assets/shaders/pbr.frag.spv      | Bin 5072 -> 6156 bytes
 assets/shaders/pbr.vert.spv      | Bin 4184 -> 4336 bytes
 assets/shaders/triangle.frag.spv | Bin 2664 -> 2816 bytes
 assets/shaders/triangle.vert.spv | Bin 3556 -> 3708 bytes
 src/gears/game.d                 |   9 ++--
 src/gears/renderer.d             |  81 ++++++++++++++++++++++++++++++-
 src/gears/vulkan.d               |  80 +++++++++++++++++++++++++++++-
 src/shaders/pbr.frag.glsl        |  11 ++++-
 src/shaders/structures.layout    |   3 ++
 src/shared/assets.d              |   3 ++
 13 files changed, 179 insertions(+), 8 deletions(-)

diff --git a/assets/shaders/gradient.comp.spv b/assets/shaders/gradient.comp.spv
index 1d9f82ad8972914e6c0d7d1dc314cf75a9745e31..18575bcb9069e4e18141c323c255d4f462b2a4a2 100644
GIT binary patch
delta 214
zcmaDM*PyVWh*_DPA&G&3fenZga|$vN<4aO2N=l1T!D1X>Irhnw%<_yJlV<`+&dEEO
zW!)j-TyQ-ZiNz@T*ueU@f%3%}nR%Icsl~-$^H{;+JTQHmUoy)xTY4}+gh9qB1F;Vf
n!^A*FfW!ij#6a3XVj-JZ*$tT)`6rumX-<yd;@O<Q#lZ>y4)i68

delta 96
zcmZorcp<l;h?$*(A&G&3fo<|sW_d>T$y=G_4LN}P;)2xV(wxMi_>9Ej_>$C$lG377
spfCd)5Q5Zmg4ASW=4Ixk78h@}WRYjyJcV74nUQDmVJ^+hKe#wp0igyM)&Kwi

diff --git a/assets/shaders/gui.frag.spv b/assets/shaders/gui.frag.spv
index c490d3e99eb0f4369a15a4862af525fbe7ac5d25..8a6d9702cd764d626a61f3613e717eb5a50790b4 100644
GIT binary patch
delta 222
zcmbOux<zb*9kVh!gAxM+0~-)0<`iTk#+Rg4l#~{wg2gz%a_o~`ndKQdCZ{sX3vdF(
ziwjbdOLG#7;xiJ9CmS$}IC8-?14U2_U;`V#4bqg6nU|TDT3ie^m=!F}1Jk#8E3-4R
yr3V8<7-XC>5c>czOblcMNGt$J45S?-7P9#(+e{`#{>lBEnv*wh@=V^r`2+xx2PzBz

delta 69
zcmdlYHb-=W9rNUU%xsKolM|Wc8QCW{0!fa^3z=nw*%*`<7#KK#xHuy-FEcN-xOg)w
Xi!<})7WQdOj69R2xilvSa6JJ4OVJT7

diff --git a/assets/shaders/gui.vert.spv b/assets/shaders/gui.vert.spv
index 39374c1405cbd22681e6dd463845e5572179ff2d..5e968bf288777f0406c6aaaf646f756eab186e9e 100644
GIT binary patch
delta 223
zcmcbj@kVn)9*Z(NLq7up0~-)0<`iTk#+Rg4l#~{wg2gz%a_o~!S>zcxCQoIN7vKbn
z7Z;=^m*ylE#b+cIPflPFapZz)28y5<zy>ye8>A^CGcPkQwYV5;Fe_M`2c~cHQ<mGz
zmL3ccVUTgkK<op=Ffou3Ah7@>F_3nUSjgtR9Gt9-{F9IKYEFK^%d`0dZwea#NQ5rI

delta 70
zcmaE(c|~JG9?Rr+ENqNylP9vsGqO+K2qZZsUu2OLW@G4QU|`?`;^K_Vyv)4R;^NJw
Ythbpr`*5<cGV)9g=F{BV!I#1Y0MQN;N&o-=

diff --git a/assets/shaders/pbr.frag.spv b/assets/shaders/pbr.frag.spv
index 5d4e833c4305f35976feaac2a4c802cefee14e23..4f0dc6384393ae06ac739025201b204e0dc9e18f 100644
GIT binary patch
delta 1900
zcmZ9M+e=hY6vp>Bj^kw}361DMvm_!a=rM@`2{N#vsO+V%L5DOZN5&Dlk7i|dGdtbv
zp5-mew6WBnKcKh%f&PRZBBJc6?{_@AP9FGXt?yfF?Y;JGKCiyIAsWo744b@wDKb&>
zp)Z;#cx#M#FU(Hf{z`0@{5&C+Xl;tsr{l-d?Wwq{<-4)4(-T}C$ahBdTi|>OmetJb
zg@0?BVr~D`<+*i5inld2w=}oJ+uGdmLarXMb<SMyTPD|>5Kp$J>l=~@6EeBxw0LVQ
z6+0#iKf8c;EZ|)Wc=vxiWS)r6uZ<ZPGi2C<ZK>Fit&wCRnR3NEGv(|FEnPJw#@CvN
zHN=~eiN<(J1wnVq_DZLGHhV1;&Z*iim)&D0Duo?_)mS~+ZlA`=(e`Eg!c~Dx&|DXp
zDmA7?<M;Xen?C=J&%fvM`+fd^&wt_b2YvpK&mYFmcoUEO4dlA}QZCL%Q*1_#z^d%V
zumZjsoelSBg%I%ZmGb$B&&m>K49jgiyRo1y5GZzf3)eUkg^}z`VLFgmt0D?c3L(Mr
zQ}X#L6hAM^fCV1EBufKuo8K#+?I!<*Ecsk=8^0@`V=GnUzNfD<=BRlf!e<ko%cqcm
zCS`*{SlHxoZW3C#w_7&%oirw8*T{vlTWHJF>a_DQQn_SCjBi>X3qI@oh}6b-6?UF{
z`Me50=T-Q5hmW(ct_8f?#~JTQwlkUxWX{OlDQr>uOab4lMi@FH92AH#9lTnnQYqUh
zR0xfN%|9m}o%{}2IQg8{1))OVT*>FGE;1wm3g}mYTfl+#2x)<Xw*{9yoqW~<uhLL7
zdqr3*un3y%5Ezp@^4U*vXsAy1s<6*EccP1$uX%K@`qCY6UnN?#4xYQi%iQDX+$-AQ
zn0ckd7_vmx5twGZz?5)u?3A~hzGzA2wv=0fosIX6#%ys}-Z-<Nb4!_xuKERHW15W{
z`_R+4us=21V_Cl6$|v?nK>MXDhwpWfW1hNgJd^ZPux$*;N3(6bkWU-v&js7YpnPJs
zZb&{F!#B$g3x@@CY7WVc2<Y&H>?jA{BBxG8t+Fo#k`!<UYL^`oxB&YF3d>|)3Frq@
z$DzL#s6}VT`Kw2>Co(P{jT2!EPVJ2_ZfgG}O-S$`8=Ry$ZJgaeECVoURv@1VdHvb!
Im*VfiKUS;rLjV8(

delta 891
zcmZ8fOG_J36uvj}N@8MZQA#&4nuVyFb|aQjA@pHO(T%t($Y4ejFb`%Du+K5tN7ST^
zGj!n(@CV5J2G{xrx^eHqA0YUB$qdBY;p3d|obR4{?zz)`dO4j|VmU+TQjCbS@Q>4O
z;<FIqFW{a1yN(%gu>xQBPn8L2_~**RvpBd@vo;#rroCP?o%Oo4Q*YQ7!a~PKeS(@|
zsZy#~j^n>qZ(L2V?pxd3dR5)7+VC}@if^zr(>BW?cZYa$i2oSkt$SP-9q`qnS+MN2
zN@=rdmz{o39sj@fIL%wF0vbLqkh&2IUdQL<hT7{bgACV_P<nM@@ZUknnq0ZQL0;|6
zXA)cj5uX~!d+?cO4d%U|oHV6O`4=NIUP=w(shV`NNPL1o0Sw?p$T=v+=D=Cx3!n|~
zukg9J|0gUD;lRlcU}eZN;YIW?_Xn0*UI=GB5)5!A3_d}Lu5XU!#*e|cx&T`u_xzL5
z4|%>;)F}S~zSbab4)7#=zE+ecZv}52RHgeJ?lQ25{#cUyB@Uu=7x)M;$MWQP+@8bV
z1F}E?i1hpL8K<7dlT**R`~tE7=SMwf^qXBX!42#Wf!+oV?hvR09B{PZD2!9jzm5Dk
kO0n5C@DSi7*en}hP3oxULsD~#Cs_dI(U>8E*|96-4&Bmm+5i9m

diff --git a/assets/shaders/pbr.vert.spv b/assets/shaders/pbr.vert.spv
index c369eaafc8d000777bcff731898c856ae93aaca9..09f599096fedc900708294420b8dcd787218c646 100644
GIT binary patch
delta 214
zcmcbi@Ii4y7mG4GLkt500~-)0<`iTk#+Rg4l#~{wg2gz%a_o~QvdA-XOx_42IVWFa
zk#&cNbHVjwBo?FSV*~5s2Fe#_Waee&r4|>1&0__N^T70NW@J6iZ0W%O5e6Bj48%S_
n3=;zx0TK&95(8-miG^%F$`Q%J$Uj-0S97uhFVAKVUIAtRiRmVk

delta 72
zcmeyMctc@B7YjQFLkt501KZ@aEb@%(lg|Q4j>&IXWQEzl;+#Oa;*89^%)Hd%;?04q
X$C)>WaE7rk@=RXMtGW3BuK+Uur_K`;

diff --git a/assets/shaders/triangle.frag.spv b/assets/shaders/triangle.frag.spv
index 1dd2a8e5d78f2a89cb35502f4e1a5506d479a55b..821a69b7299af023408cd642297065b69c38c888 100644
GIT binary patch
delta 215
zcmaDM(jd0Mh*_DPL7jntfenZga|$vN<4aO2N=l1T!D1X>Irhnx%<_yJlOus7=j2Le
zS$Bvy7hF$9Vlj$7Hn2W!pnP#gW?p7qYH=~xJXWwc4@}?YmCW+YmL3ccVUTgkK<op=
oFfou3Ah7@>F_3nUSjgt1Y_&{`{F9wIH76%<axk(@&gA?L0G}fyR{#J2

delta 98
zcmZn=dm*yHh?$*(L7jntfo*aqvpggF<WgpNLk=LnxF9vTG$*krJ|nR>z9hAxq_ij%
uD9peHgdp{tAT=48d6{{s#l@R{GRre>4q>liV&s{8o>OxY7t3T0t{(t=ni$*w

diff --git a/assets/shaders/triangle.vert.spv b/assets/shaders/triangle.vert.spv
index 97265db928df52d799554304202c2a8925902d31..1524706744a81e931418787a46b3c197ebdf4c24 100644
GIT binary patch
delta 216
zcmaDN{YPfQD`sVO26qMq1~wp0%qhr7j4w&8C@C#U1&eWj<=7{GWR_>-m@LR5&&WC1
zkVV!VBF+WZlaW}AqK^%%j~ggooROKAnU`8z3^tDyEY1Vdw>goen%UBW0U``CP8o=O
qfEXqQG6EzPfFuUe4iXF5e3Lzsg^_=<Gmqxv1Rf4Xw#}J5)r<gTY9@RD

delta 75
zcmew(^F(^XD`s{M26qMq2DZt(Eb@%(lXZb4$7Ej?Sz$J?I44l9I3qJJGcUEcc=JY<
aYUa%u9BC|!Jd@A!Xinl~+04OP!UzDCfD!!w

diff --git a/src/gears/game.d b/src/gears/game.d
index b99caf5..21e2a74 100644
--- a/src/gears/game.d
+++ b/src/gears/game.d
@@ -89,6 +89,10 @@ InitGame(PlatformWindow* window)
 
 	g.model = LoadModel(&g.rd, "models/Tree01.m3d");
 
+	SetClearColor(&g.rd, Vec4(0.3, 0.5, 0.9, 1.0));
+
+	ClearColorEnabled(&g.rd, true);
+
 	return g;
 }
 
@@ -169,13 +173,14 @@ Destroy(Game* g)
 	Destroy(&g.rd, &g.triangle_pipeline);
 	Destroy(&g.rd, &g.ui_pipeline);
 	Destroy(&g.rd, &g.compute_pipeline);
+	Destroy(&g.rd, &g.model);
 	Destroy(&g.rd);
 }
 
 struct Camera
 {
 	Vec3 velocity = Vec3(0.0);
-	Vec3 pos = Vec3(0.0, 0.0, 5.0);
+	Vec3 pos = Vec3(0.0, 0.0, 2.0);
 	f32 pitch = 0.0;
 	f32 yaw = 0.0;
 }
@@ -183,8 +188,6 @@ struct Camera
 pragma(inline): void
 HandleInputs(Camera* cam, Inputs* inputs)
 {
-	Logf("%.04f %.04f", cam.pitch, cam.yaw);
-
 	foreach(i; 0 .. inputs.count)
 	{
 		InputEvent event = inputs.events[i];
diff --git a/src/gears/renderer.d b/src/gears/renderer.d
index 338d205..e089c93 100644
--- a/src/gears/renderer.d
+++ b/src/gears/renderer.d
@@ -4,7 +4,7 @@ import assets;
 import util;
 import alloc;
 import vulkan;
-import vulkan : Destroy, Init, Draw, DrawIndexed, Bind, BindUIBuffers, BeginRender, SetUniform, PrepComputeDrawImage, Dispatch, FinishFrame, BeginFrame, WaitIdle, PushConstants, BindBuffers;
+import vulkan : Destroy, Init, Draw, DrawIndexed, Bind, BindUIBuffers, BeginRender, SetUniform, PrepComputeDrawImage, Dispatch, FinishFrame, BeginFrame, WaitIdle, PushConstants, BindBuffers, SetClearColor;
 import assets;
 import std.math.traits : isNaN;
 import util : Logf;
@@ -345,6 +345,7 @@ LoadModel(Renderer* rd, string name)
 
 	u32[] tex_lookup = AllocArray!(u32)(&rd.temp_arena, m3d.numtexture);
 	model.textures = AllocArray!(ImageView)(&rd.arena, m3d.numtexture);
+	Logf("numtexture %s", m3d.numtexture);
 	foreach(i; 0 .. m3d.numtexture)
 	{
 		u32 w = m3d.texture[i].w; u32 h = m3d.texture[i].h; u32 ch = m3d.texture[i].f;
@@ -359,6 +360,7 @@ LoadModel(Renderer* rd, string name)
 	Material[] mats = AllocArray!(Material)(&rd.temp_arena, m3d.nummaterial);
 	u32[] mat_lookup = AllocArray!(u32)(&rd.temp_arena, m3d.nummaterial);
 	model.materials = AllocArray!(Buffer)(&rd.arena, m3d.nummaterial);
+	Logf("nummaterial %s", m3d.nummaterial);
 	foreach(i; 0 .. m3d.nummaterial)
 	{
 		const(char)[] mat_name = m3d.material[i].name[0 .. strlen(m3d.material[i].name)];
@@ -371,6 +373,7 @@ LoadModel(Renderer* rd, string name)
 			case m3dp_Ka: ConvertColor(&mats[i].ambient, m3d.material[i].prop[j].value.color); break;
 			case m3dp_Ks: ConvertColor(&mats[i].specular, m3d.material[i].prop[j].value.color); break;
 			case m3dp_Ns: mats[i].shininess = m3d.material[i].prop[j].value.fnum; break;
+			case m3dp_d:  mats[i].alpha = m3d.material[i].prop[j].value.fnum; break;
 			case m3dp_map_Kd:
 				{
 					mats[i].albedo_texture = tex_lookup[m3d.material[i].prop[j].value.textureid];
@@ -386,7 +389,13 @@ LoadModel(Renderer* rd, string name)
 					mats[i].specular_texture = tex_lookup[m3d.material[i].prop[j].value.textureid];
 					mats[i].specular_has_texture = true;
 				} break;
-			default: break;
+			case m3dp_map_D:
+				{
+					Logf("alpha %s", i);
+					mats[i].alpha_texture = tex_lookup[m3d.material[i].prop[j].value.textureid];
+					mats[i].alpha_has_texture = true;
+				} break;
+			default: Logf("Unsupported property: %s", M3DPropToStr(m3d.material[i].prop[j].type)); break;
 			}
 		}
 
@@ -525,6 +534,46 @@ LoadModel(Renderer* rd, string name)
 	return model;
 }
 
+string
+M3DPropToStr(u8 type)
+{
+	string result = "Unknown";
+	switch(type)
+	{
+		case m3dp_Kd: result = "Diffuse"; break;
+		case m3dp_Ka: result = "Ambient"; break;
+		case m3dp_Ks: result = "Specular Color"; break;
+		case m3dp_Ns: result = "Specular Exponent"; break;
+		case m3dp_Ke: result = "Emissive"; break;
+		case m3dp_Tf: result = "Transmission"; break;
+		case m3dp_Km: result = "Bump Strength"; break;
+		case m3dp_d: result = "Alpha"; break;
+		case m3dp_il: result = "Illumination"; break;
+		case m3dp_Pr: result = "Roughness"; break;
+		case m3dp_Pm: result = "Metallic"; break;
+		case m3dp_Ps: result = "Sheen"; break;
+		case m3dp_Ni: result = "Refraction"; break;
+		case m3dp_Nt: result = "Face Thickness"; break;
+		case m3dp_map_Kd: result = "Diffuse Texture"; break;
+		case m3dp_map_Ka: result = "Ambient Texture"; break;
+		case m3dp_map_Ks: result = "Specular Texture"; break;
+		case m3dp_map_Ns: result = "Specular Exponent Texture"; break;
+		case m3dp_map_Ke: result = "Emissive Texture"; break;
+		case m3dp_map_Tf: result = "Transmission Texture"; break;
+		case m3dp_map_Km: result = "Bump Map"; break;
+		case m3dp_map_D: result = "Alpha Map"; break;
+		case m3dp_map_N: result = "Normal Map"; break;
+		case m3dp_map_Pr: result = "Roughness Map"; break;
+		case m3dp_map_Pm: result = "Metallic Map"; break;
+		case m3dp_map_Ps: result = "Sheen Map"; break;
+		case m3dp_map_Ni: result = "Refraction Map"; break;
+		case m3dp_map_Nt: result = "Thickness Map"; break;
+		default: break;
+	}
+
+	return result;
+}
+
 pragma(inline): void
 CopyVertex(Vec3* dst, m3dv_t* src)
 {
@@ -557,3 +606,31 @@ PrintShader(Renderer* rd, Pipeline* pipeline, VkShaderStageFlagBits stage)
 	PrintShaderDisassembly(&rd.vk, pipeline, stage);
 }
 
+void
+SetClearColor(Renderer* rd, Vec4 color)
+{
+	SetClearColor(&rd.vk, color);
+}
+
+void
+ClearColorEnabled(Renderer* rd, bool enabled)
+{
+	rd.vk.enable_clear_color = enabled;
+}
+
+void
+Destroy(Renderer* rd, Model* model)
+{
+	Destroy(&rd.vk, &model.vertex_buffer);
+	Destroy(&rd.vk, &model.index_buffer);
+	
+	foreach(i, mat; model.materials)
+	{
+		Destroy(&rd.vk, model.materials.ptr + i);
+	}
+
+	foreach(i, view; model.textures)
+	{
+		Destroy(model.textures.ptr + i, rd.vk.device, rd.vk.vma);
+	}
+}
diff --git a/src/gears/vulkan.d b/src/gears/vulkan.d
index f3ced11..9d673bc 100644
--- a/src/gears/vulkan.d
+++ b/src/gears/vulkan.d
@@ -93,6 +93,7 @@ enum StepInitialized : u32
 	Swapchain,
 	DrawImages,
 	Descriptors,
+	Pipelines,
 }
 
 alias SI = StepInitialized;
@@ -220,6 +221,9 @@ struct Vulkan
 	VkPipeline										 last_comp_pipeline;
 	bool													 compute_pass_started;
 
+	bool													 enable_clear_color;
+	VkClearColorValue							 clear_color;
+
 	alias queues this;
 }
 
@@ -294,6 +298,8 @@ Init(PlatformWindow* window, u64 permanent_mem, u64 frame_mem)
 bool
 InitConversionPipeline(Vulkan* vk)
 {
+	Push(vk, SI.Pipelines);
+
 	VkDescriptorBindingFlags[] binding_flags;
 	binding_flags[] = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT;
 
@@ -432,6 +438,7 @@ InitBuffers(Vulkan* vk)
 	Push(vk, SI.Buffers);
 
 	vk.global_buf = CreateMappedBuffer!(GlobalUniforms)(vk, BT.Uniform, 1);
+	vk.shader_buf = CreateMappedBuffer!(ShaderUniforms)(vk, BT.Uniform, 1);
 
 	u64 transfer_size = MB(64);
 	vk.transfer_buf = CreateMappedBuffer!(u8)(vk, BT.Staging, transfer_size);
@@ -540,8 +547,11 @@ BeginRender(Vulkan* vk)
 		sType: VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
 		imageView: vk.draw_image.view,
 		imageLayout: vk.draw_image.layout,
-		loadOp: VK_ATTACHMENT_LOAD_OP_CLEAR, // CLEAR instead of LOAD if wanting to clear colors, also clearColor value (or whatever)
+		loadOp: (vk.enable_clear_color ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD), // CLEAR instead of LOAD if wanting to clear colors, also clearColor value (or whatever)
 		storeOp: VK_ATTACHMENT_STORE_OP_STORE,
+		clearValue: {
+			color: vk.clear_color,
+		},
 	};
 
 	VkRenderingAttachmentInfo depth_attach = {
@@ -569,6 +579,15 @@ BeginRender(Vulkan* vk)
 	vkCmdBeginRendering(vk.cmds[vk.frame_index], &render_info);
 }
 
+void
+SetClearColor(Vulkan* vk, Vec4 color)
+{
+	vk.clear_color.float32[0] = color.r;
+	vk.clear_color.float32[1] = color.g;
+	vk.clear_color.float32[2] = color.b;
+	vk.clear_color.float32[3] = color.a;
+}
+
 void
 PrepComputeDrawImage(Vulkan* vk)
 {
@@ -1321,7 +1340,13 @@ CreateGraphicsPipeline(Vulkan* vk, GfxPipelineInfo* build_info)
 
 	VkPipelineColorBlendAttachmentState blend_state = {
 		colorWriteMask: VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
-		blendEnable: VK_FALSE,
+		blendEnable: VK_TRUE,
+		srcColorBlendFactor: VK_BLEND_FACTOR_SRC_ALPHA,
+		dstColorBlendFactor: VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+		colorBlendOp: VK_BLEND_OP_ADD,
+		srcAlphaBlendFactor: VK_BLEND_FACTOR_SRC_ALPHA,
+		dstAlphaBlendFactor: VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+		alphaBlendOp: VK_BLEND_OP_ADD,
 	};
 
 	VkPipelineColorBlendStateCreateInfo blend_info = {
@@ -1558,6 +1583,13 @@ Destroy(Vulkan* vk)
 			break;
 		case SI.Buffers:
 			Destroy(vk, &vk.transfer_buf);
+			Destroy(vk, &vk.ui_vert_buf);
+			Destroy(vk, &vk.ui_index_buf);
+			Destroy(vk, &vk.global_buf);
+			Destroy(vk, &vk.shader_buf);
+			break;
+		case SI.Pipelines:
+			DestroyPipelines(vk);
 			break;
 		default:
 			break;
@@ -1565,6 +1597,35 @@ Destroy(Vulkan* vk)
 	}
 }
 
+void
+DestroyPipelines(Vulkan* vk)
+{
+	if (vk.conv_pipeline_layout)
+	{
+		vkDestroyPipelineLayout(vk.device, vk.conv_pipeline_layout, null);
+	}
+
+	if (vk.conv_desc_layout)
+	{
+		vkDestroyDescriptorSetLayout(vk.device, vk.conv_desc_layout, null);
+	}
+
+	if (vk.r_to_rgba_pipeline.handle)
+	{
+		vkDestroyPipeline(vk.device, vk.r_to_rgba_pipeline.handle, null);
+	}
+
+	if (vk.rg_to_rgba_pipeline.handle)
+	{
+		vkDestroyPipeline(vk.device, vk.rg_to_rgba_pipeline.handle, null);
+	}
+
+	if (vk.rgb_to_rgba_pipeline.handle)
+	{
+		vkDestroyPipeline(vk.device, vk.rgb_to_rgba_pipeline.handle, null);
+	}
+}
+
 void
 Destroy(T)(Vulkan* vk, MappedBuffer!(T)* buf)
 {
@@ -2789,6 +2850,21 @@ DestroyFS(Vulkan* vk)
 		vkDestroyCommandPool(vk.device, vk.imm_pool, null);
 	}
 
+	if (vk.comp_cmd)
+	{
+		vkFreeCommandBuffers(vk.device, vk.comp_cmd_pool, 1, &vk.comp_cmd);
+	}
+
+	if (vk.comp_cmd_pool)
+	{
+		vkDestroyCommandPool(vk.device, vk.comp_cmd_pool, null);
+	}
+
+	if (vk.comp_fence)
+	{
+		vkDestroyFence(vk.device, vk.comp_fence, null);
+	}
+
 	foreach(sem; vk.submit_sems)
 	{
 		if (sem)
diff --git a/src/shaders/pbr.frag.glsl b/src/shaders/pbr.frag.glsl
index 75542f5..d1170ed 100644
--- a/src/shaders/pbr.frag.glsl
+++ b/src/shaders/pbr.frag.glsl
@@ -30,5 +30,14 @@ void main()
 	vec4 col = Materials[nonuniformEXT(PC.mat_id)].diffuse;
 	vec4 tex_col = texture(sampler2D(Textures[nonuniformEXT(Materials[nonuniformEXT(PC.mat_id)].albedo_texture)], SamplerNearest), FragData.uv);
 
-	FragColor = CalculateDirectionalLight(col, tex_col, G.light_color, G.light_direction, FragData.normal);
+	vec4 out_col = CalculateDirectionalLight(col, tex_col, G.light_color, G.light_direction, FragData.normal);
+	out_col.a = Materials[nonuniformEXT(PC.mat_id)].alpha;
+
+	if (Materials[nonuniformEXT(PC.mat_id)].alpha_has_texture)
+	{
+		vec4 alpha_col = texture(sampler2D(Textures[nonuniformEXT(Materials[nonuniformEXT(PC.mat_id)].alpha_texture)], SamplerNearest), FragData.uv);
+		out_col.a = alpha_col.a;
+	}
+
+	FragColor = out_col;
 }
diff --git a/src/shaders/structures.layout b/src/shaders/structures.layout
index 5def1fa..ca31899 100644
--- a/src/shaders/structures.layout
+++ b/src/shaders/structures.layout
@@ -29,10 +29,13 @@ layout (set = 2, binding = 0) uniform Material {
 	uint albedo_texture;
 	uint ambient_texture;
 	uint specular_texture;
+	uint alpha_texture;
 	bool albedo_has_texture;
 	bool ambient_has_texture;
 	bool specular_has_texture;
+	bool alpha_has_texture;
 	float shininess;
+	float alpha;
 } Materials[];
 
 layout (push_constant) uniform Constants {
diff --git a/src/shared/assets.d b/src/shared/assets.d
index 574aab6..0148607 100644
--- a/src/shared/assets.d
+++ b/src/shared/assets.d
@@ -73,10 +73,13 @@ struct Material
 	u32 albedo_texture;
 	u32 ambient_texture;
 	u32 specular_texture;
+	u32 alpha_texture;
 	b32 albedo_has_texture;
 	b32 ambient_has_texture;
 	b32 specular_has_texture;
+	b32 alpha_has_texture;
 	f32 shininess = 0.0;
+	f32 alpha = 0.0;
 }
 
 struct TextureInfo