diff --git a/armorpaint/shaders/dilate_map.frag.glsl b/armorpaint/shaders/dilate_map.frag.glsl
index 83abcf12..5083ea61 100644
--- a/armorpaint/shaders/dilate_map.frag.glsl
+++ b/armorpaint/shaders/dilate_map.frag.glsl
@@ -1,5 +1,6 @@
 #version 450
 
+in float dummy;
 out float frag_color;
 
 void main() {
diff --git a/armorpaint/shaders/dilate_map.vert.glsl b/armorpaint/shaders/dilate_map.vert.glsl
index 760c11c9..f88a85cc 100644
--- a/armorpaint/shaders/dilate_map.vert.glsl
+++ b/armorpaint/shaders/dilate_map.vert.glsl
@@ -3,6 +3,7 @@
 in vec4 pos;
 in vec2 nor;
 in vec2 tex;
+out float dummy;
 
 void main() {
 	#if defined(HLSL) || defined(METAL) || defined(SPIRV)
diff --git a/armorpaint/shaders/dilate_pass.frag.glsl b/armorpaint/shaders/dilate_pass.frag.glsl
index 58ec11eb..060cf3b8 100644
--- a/armorpaint/shaders/dilate_pass.frag.glsl
+++ b/armorpaint/shaders/dilate_pass.frag.glsl
@@ -7,7 +7,7 @@ uniform float dilate_radius;
 in vec2 tex_coord;
 out vec4 frag_color;
 
-const vec2 offsets[8] = vec2[] (
+const vec2 offsets[8] = {
 	vec2(-1, 0),
 	vec2( 1, 0),
 	vec2( 0, 1),
@@ -16,7 +16,7 @@ const vec2 offsets[8] = vec2[] (
 	vec2( 1, 1),
 	vec2( 1,-1),
 	vec2(-1,-1)
-);
+};
 
 void main() {
 	// Based on https://shaderbits.com/blog/uv-dilation by Ryan Brucks
diff --git a/armorpaint/shaders/layer_invert.frag.glsl b/armorpaint/shaders/layer_invert.frag.glsl
index 27d7089f..01968c5f 100644
--- a/armorpaint/shaders/layer_invert.frag.glsl
+++ b/armorpaint/shaders/layer_invert.frag.glsl
@@ -7,5 +7,5 @@ in vec4 color;
 out vec4 frag_color;
 
 void main() {
-	frag_color = vec4(1.0) - textureLod(tex, tex_coord, 0).rgba * color;
+	frag_color = vec4(1.0, 1.0, 1.0, 1.0) - textureLod(tex, tex_coord, 0).rgba * color;
 }
diff --git a/armorpaint/shaders/mask_colorid.frag.glsl b/armorpaint/shaders/mask_colorid.frag.glsl
index 0178021a..99fd94df 100644
--- a/armorpaint/shaders/mask_colorid.frag.glsl
+++ b/armorpaint/shaders/mask_colorid.frag.glsl
@@ -11,6 +11,6 @@ out vec4 frag_color;
 void main() {
 	vec3 colorid_c1 = texelFetch(texpaint_colorid, ivec2(0, 0), 0).rgb;
 	vec3 colorid_c2 = textureLod(texcolorid, tex_coord, 0).rgb;
-	if (colorid_c1 != colorid_c2) discard;
+	if (colorid_c1.x != colorid_c2.x || colorid_c1.y != colorid_c2.y || colorid_c1.z != colorid_c2.z) discard;
 	frag_color = vec4(1.0, 1.0, 1.0, 1.0);
 }
diff --git a/armorpaint/shaders/mesh_posnor.vert.glsl b/armorpaint/shaders/mesh_posnor.vert.glsl
index ce13d117..987d2a1b 100644
--- a/armorpaint/shaders/mesh_posnor.vert.glsl
+++ b/armorpaint/shaders/mesh_posnor.vert.glsl
@@ -12,8 +12,8 @@ out vec4 prevwvpposition;
 
 void main() {
 	vec4 spos = vec4(pos.xyz, 1.0);
-	wnormal = normalize(N * vec3(nor.xy, pos.w));
-	gl_Position = WVP * spos;
+	wnormal = normalize(mul(vec3(nor.xy, pos.w), N));
+	gl_Position = mul(spos, WVP);
 	wvpposition = gl_Position;
-	prevwvpposition = prevWVP * spos;
+	prevwvpposition = mul(spos, prevWVP);
 }
diff --git a/armorsculpt/shaders/layer_invert.frag.glsl b/armorsculpt/shaders/layer_invert.frag.glsl
index 27d7089f..01968c5f 100644
--- a/armorsculpt/shaders/layer_invert.frag.glsl
+++ b/armorsculpt/shaders/layer_invert.frag.glsl
@@ -7,5 +7,5 @@ in vec4 color;
 out vec4 frag_color;
 
 void main() {
-	frag_color = vec4(1.0) - textureLod(tex, tex_coord, 0).rgba * color;
+	frag_color = vec4(1.0, 1.0, 1.0, 1.0) - textureLod(tex, tex_coord, 0).rgba * color;
 }
diff --git a/armorsculpt/shaders/mesh_posnor.vert.glsl b/armorsculpt/shaders/mesh_posnor.vert.glsl
index ce13d117..987d2a1b 100644
--- a/armorsculpt/shaders/mesh_posnor.vert.glsl
+++ b/armorsculpt/shaders/mesh_posnor.vert.glsl
@@ -12,8 +12,8 @@ out vec4 prevwvpposition;
 
 void main() {
 	vec4 spos = vec4(pos.xyz, 1.0);
-	wnormal = normalize(N * vec3(nor.xy, pos.w));
-	gl_Position = WVP * spos;
+	wnormal = normalize(mul(vec3(nor.xy, pos.w), N));
+	gl_Position = mul(spos, WVP);
 	wvpposition = gl_Position;
-	prevwvpposition = prevWVP * spos;
+	prevwvpposition = mul(spos, prevWVP);
 }
diff --git a/base/project.js b/base/project.js
index 7c831a83..2e8dbffa 100644
--- a/base/project.js
+++ b/base/project.js
@@ -107,7 +107,7 @@ if (flags.voxels) {
 	project.add_define("arm_voxels");
 
 	if (os_platform() === "win32") {
-		project.add_shaders("shaders/voxel_hlsl/*.glsl", { noprocessing: true });
+		project.add_assets("shaders/voxel_hlsl/*.d3d11", { destination: "data/{name}" });
 	}
 	else {
 		project.add_shaders("shaders/voxel_glsl/*.glsl");
diff --git a/base/shaders/compositor_pass.frag.glsl b/base/shaders/compositor_pass.frag.glsl
index f26f2935..12d6ff72 100644
--- a/base/shaders/compositor_pass.frag.glsl
+++ b/base/shaders/compositor_pass.frag.glsl
@@ -10,7 +10,7 @@ out vec4 frag_color;
 
 // Based on Filmic Tonemapping Operators http://filmicgames.com/archives/75
 vec3 tonemap_filmic(const vec3 color) {
-	vec3 x = max(vec3(0.0), color - 0.004);
+	vec3 x = max(vec3(0.0, 0.0, 0.0), color - 0.004);
 	return (x * (6.2 * x + 0.5)) / (x * (6.2 * x + 1.7) + 0.06);
 }
 
@@ -19,7 +19,8 @@ void main() {
 
 	// Static grain
 	float x = (tex_coord.x + 4.0) * (tex_coord.y + 4.0) * 10.0;
-	frag_color.rgb += vec3(mod((mod(x, 13.0) + 1.0) * (mod(x, 123.0) + 1.0), 0.01) - 0.005) * grain_strength;
+	float g = mod((mod(x, 13.0) + 1.0) * (mod(x, 123.0) + 1.0), 0.01) - 0.005;
+	frag_color.rgb += vec3(g, g, g) * grain_strength;
 
 	frag_color.rgb *= (1.0 - vignette_strength) + vignette_strength * pow(16.0 * tex_coord.x * tex_coord.y * (1.0 - tex_coord.x) * (1.0 - tex_coord.y), 0.2);
 
diff --git a/base/shaders/cursor.vert.glsl b/base/shaders/cursor.vert.glsl
index 8939832b..428a569d 100644
--- a/base/shaders/cursor.vert.glsl
+++ b/base/shaders/cursor.vert.glsl
@@ -8,7 +8,8 @@ uniform float radius;
 uniform vec3 camera_right;
 uniform sampler2D gbufferD;
 #ifdef HLSL
-uniform sampler2D texa; // direct3d12 unit align
+// direct3d12 unit align
+uniform sampler2D texa;
 #endif
 
 in vec4 pos;
@@ -27,7 +28,7 @@ vec3 get_pos(vec2 uv) {
 	float depth = textureLod(gbufferD, uv, 0.0).r;
 	#endif
 	vec4 wpos = vec4(uv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
-	wpos = invVP * wpos;
+	wpos = mul(wpos, invVP);
 	return wpos.xyz / wpos.w;
 }
 
@@ -61,5 +62,5 @@ void main() {
 	else if (gl_VertexID == 1) wpos += normalize( n_tan - n_bin) * 0.7 * radius;
 	else if (gl_VertexID == 2) wpos += normalize( n_tan + n_bin) * 0.7 * radius;
 	else if (gl_VertexID == 3) wpos += normalize(-n_tan + n_bin) * 0.7 * radius;
-	gl_Position = VP * vec4(wpos, 1.0);
+	gl_Position = mul(vec4(wpos, 1.0), VP);
 }
diff --git a/base/shaders/layer_view.vert.glsl b/base/shaders/layer_view.vert.glsl
index ce08e4d8..0edddc84 100644
--- a/base/shaders/layer_view.vert.glsl
+++ b/base/shaders/layer_view.vert.glsl
@@ -9,7 +9,7 @@ out vec2 tex_coord;
 out vec4 color;
 
 void main() {
-	gl_Position = P * vec4(pos, 1.0);
+	gl_Position = mul(vec4(pos, 1.0), P);
 	tex_coord = tex;
 	color = col;
 }
diff --git a/base/shaders/line.vert.glsl b/base/shaders/line.vert.glsl
index d9095dd9..a572ecc5 100644
--- a/base/shaders/line.vert.glsl
+++ b/base/shaders/line.vert.glsl
@@ -8,5 +8,5 @@ out vec3 color;
 
 void main() {
 	color = col;
-	gl_Position = VP * vec4(pos, 1.0);
+	gl_Position = mul(vec4(pos, 1.0), VP);
 }
diff --git a/base/shaders/mesh_poscol.frag.glsl b/base/shaders/mesh_poscol.frag.glsl
index a83b2aab..25f0ee98 100644
--- a/base/shaders/mesh_poscol.frag.glsl
+++ b/base/shaders/mesh_poscol.frag.glsl
@@ -5,5 +5,5 @@ out vec4 frag_color;
 
 void main() {
 	frag_color = vec4(vcolor, 1.0);
-	frag_color.rgb = pow(frag_color.rgb, vec3(1.0 / 2.2));
+	frag_color.rgb = pow(frag_color.rgb, vec3(1.0 / 2.2, 1.0 / 2.2, 1.0 / 2.2));
 }
diff --git a/base/shaders/mesh_poscol.vert.glsl b/base/shaders/mesh_poscol.vert.glsl
index b139ba19..6e13d482 100644
--- a/base/shaders/mesh_poscol.vert.glsl
+++ b/base/shaders/mesh_poscol.vert.glsl
@@ -9,5 +9,5 @@ out vec3 vcolor;
 void main() {
 	vec4 spos = vec4(pos.xyz, 1.0);
 	vcolor = col.rgb;
-	gl_Position = WVP * spos;
+	gl_Position = mul(spos, WVP);
 }
diff --git a/base/shaders/mesh_posnortex.vert.glsl b/base/shaders/mesh_posnortex.vert.glsl
index 5bc89519..4711d9aa 100644
--- a/base/shaders/mesh_posnortex.vert.glsl
+++ b/base/shaders/mesh_posnortex.vert.glsl
@@ -16,8 +16,8 @@ out vec4 prevwvpposition;
 void main() {
 	vec4 spos = vec4(pos.xyz, 1.0);
 	tex_coord = tex * tex_unpack;
-	wnormal = normalize(N * vec3(nor.xy, pos.w));
-	gl_Position = WVP * spos;
+	wnormal = normalize(mul(vec3(nor.xy, pos.w), N));
+	gl_Position = mul(spos, WVP);
 	wvpposition = gl_Position;
-	prevwvpposition = prevWVP * spos;
+	prevwvpposition = mul(spos, prevWVP);
 }
diff --git a/base/shaders/pass_viewray.vert.glsl b/base/shaders/pass_viewray.vert.glsl
index 78cca7b9..5760db04 100644
--- a/base/shaders/pass_viewray.vert.glsl
+++ b/base/shaders/pass_viewray.vert.glsl
@@ -20,7 +20,7 @@ void main() {
 
 	// NDC (at the back of cube)
 	vec4 v = vec4(pos.x, pos.y, 1.0, 1.0);
-	v = vec4(invVP * v);
+	v = vec4(mul(v, invVP));
 	v.xyz /= v.w;
 	view_ray = v.xyz - eye;
 }
diff --git a/base/shaders/pass_viewray2.vert.glsl b/base/shaders/pass_viewray2.vert.glsl
index ceb73075..a747e49a 100644
--- a/base/shaders/pass_viewray2.vert.glsl
+++ b/base/shaders/pass_viewray2.vert.glsl
@@ -19,6 +19,6 @@ void main() {
 
 	// NDC (at the back of cube)
 	vec4 v = vec4(pos.x, pos.y, 1.0, 1.0);
-	v = vec4(invP * v);
+	v = vec4(mul(v, invP));
 	view_ray = vec3(v.xy / v.z, 1.0);
 }
diff --git a/base/shaders/prefilter_envmap.frag.glsl b/base/shaders/prefilter_envmap.frag.glsl
index 4af4a354..2ea04ec4 100644
--- a/base/shaders/prefilter_envmap.frag.glsl
+++ b/base/shaders/prefilter_envmap.frag.glsl
@@ -20,7 +20,7 @@ float rand(vec2 co) {
 
 vec2 equirect(vec3 normal) {
 	float phi = acos(normal.z);
-	float theta = atan(-normal.y, normal.x) + PI;
+	float theta = atan2(normal.x, -normal.y) + PI;
 	return vec2(theta / PI2, phi / PI);
 }
 
@@ -50,5 +50,5 @@ void main() {
 		frag_color.rgb += texture(radiance, equirect(dir)).rgb;
 	}
 	frag_color.rgb /= float(samples);
-	frag_color.rgb = pow(frag_color.rgb, vec3(1.0 / 2.2));
+	frag_color.rgb = pow(frag_color.rgb, vec3(1.0 / 2.2, 1.0 / 2.2, 1.0 / 2.2));
 }
diff --git a/base/shaders/smaa_blend_weight.frag.glsl b/base/shaders/smaa_blend_weight.frag.glsl
index 313cac02..8bb8ebe1 100644
--- a/base/shaders/smaa_blend_weight.frag.glsl
+++ b/base/shaders/smaa_blend_weight.frag.glsl
@@ -31,22 +31,19 @@ out vec4 frag_color;
 // Blending Weight Calculation Pixel Shader (Second Pass)
 vec2 cdw_end;
 
-vec4 textureLod_a(sampler2D tex, vec2 coord, float lod) {
+vec4 textureLod_a(sampler2D edges_tex, vec2 coord, float lod) {
 	#if defined(HLSL) || defined(METAL) || defined(SPIRV)
 	coord.y = 1.0 - coord.y;
 	#endif
-	return textureLod(tex, coord, lod);
+	return textureLod(edges_tex, coord, lod);
 }
 
-#define smaa_sample_level_zero_offset(tex, coord, offset) textureLod_a(tex, coord + offset * screen_size_inv.xy, 0.0)
+#define smaa_sample_level_zero_offset(edges_tex, coord, offset) textureLod_a(edges_tex, coord + offset * screen_size_inv.xy, 0.0)
 
 //-----------------------------------------------------------------------------
 // Diagonal Search Functions
 
 // #if !defined(SMAA_DISABLE_DIAG_DETECTION)
-/**
- * Allows to decode two binary values from a bilinear-filtered access.
- */
 vec2 smaa_decode_diag_bilinear_access(vec2 e) {
 	// Bilinear access for fetching 'e' have a 0.25 offset, and we are
 	// interested in the R and G edges:
@@ -70,9 +67,6 @@ vec4 smaa_decode_diag_bilinear_access(vec4 e) {
 	return round(e);
 }
 
-/**
- * These functions allows to perform diagonal pattern searches.
- */
 vec2 smaa_search_diag1(vec2 texcoord, vec2 dir/*, out vec2 e*/) {
 	vec4 coord = vec4(texcoord, -1.0, 1.0);
 	vec3 t = vec3(screen_size_inv.xy, 1.0);
@@ -100,10 +94,6 @@ vec2 smaa_search_diag2(vec2 texcoord, vec2 dir) {
 	return coord.zw;
 }
 
-/**
- * Similar to smaa_area, this calculates the area corresponding to a certain
- * diagonal distance and crossing edges 'e'.
- */
 vec2 smaa_area_diag(vec2 dist, vec2 e, float offset) {
 	vec2 texcoord = mad(vec2(SMAA_AREATEX_MAX_DISTANCE_DIAG, SMAA_AREATEX_MAX_DISTANCE_DIAG), e, dist);
 
@@ -120,9 +110,6 @@ vec2 smaa_area_diag(vec2 dist, vec2 e, float offset) {
 	return SMAA_AREATEX_SELECT(textureLod(area_tex, texcoord, 0.0));
 }
 
-/**
- * This searches for diagonal patterns and returns the corresponding weights.
- */
 vec2 smaa_calculate_diag_weights(vec2 texcoord, vec2 e, vec4 subsample_indices) {
 	vec2 weights = vec2(0.0, 0.0);
 
@@ -201,12 +188,6 @@ vec2 smaa_calculate_diag_weights(vec2 texcoord, vec2 e, vec4 subsample_indices)
 //-----------------------------------------------------------------------------
 // Horizontal/Vertical Search Functions
 
-/**
- * This allows to determine how much length should we add in the last step
- * of the searches. It takes the bilinearly interpolated edge (see
- * @PSEUDO_GATHER4), and adds 0, 1 or 2, depending on which edges and
- * crossing edges are active.
- */
 float smaa_search_length(vec2 e, float offset) {
 	// The texture is flipped vertically, with left and right cases taking half
 	// of the space horizontally:
@@ -228,17 +209,7 @@ float smaa_search_length(vec2 e, float offset) {
 	return SMAA_SEARCHTEX_SELECT(textureLod(search_tex, coord, 0.0));
 }
 
-/**
- * Horizontal/vertical search functions for the 2nd pass.
- */
 float smaa_search_x_left(vec2 texcoord, float end) {
-	/**
-	 * @PSEUDO_GATHER4
-	 * This texcoord has been offset by (-0.25, -0.125) in the vertex shader to
-	 * sample between edge, thus fetching four edges in a row.
-	 * Sampling with different offsets in each direction allows to disambiguate
-	 * which edges are active from the four fetched ones.
-	 */
 	vec2 e = vec2(0.0, 1.0);
 	while (texcoord.x > end &&
 		   e.g > 0.8281 && // Is there some edge not activated?
@@ -288,10 +259,6 @@ float smaa_search_y_down(vec2 texcoord, float end) {
 	return mad(-screen_size_inv.y, offset, texcoord.y);
 }
 
-/**
- * Ok, we have the distance and both crossing edges. So, what are the areas
- * at each side of current edge?
- */
 vec2 smaa_area(vec2 dist, float e1, float e2, float offset) {
 	// Rounding prevents precision errors of bilinear filtering:
 	vec2 texcoord = mad(vec2(SMAA_AREATEX_MAX_DISTANCE, SMAA_AREATEX_MAX_DISTANCE), round(4.0 * vec2(e1, e2)), dist);
@@ -447,5 +414,5 @@ vec4 smaa_blending_weight_calculation_ps(vec2 texcoord, vec2 pixcoord, vec4 subs
 }
 
 void main() {
-	frag_color = smaa_blending_weight_calculation_ps(tex_coord, pixcoord, vec4(0.0));
+	frag_color = smaa_blending_weight_calculation_ps(tex_coord, pixcoord, vec4(0.0, 0.0, 0.0, 0.0));
 }
diff --git a/base/shaders/smaa_neighborhood_blend.frag.glsl b/base/shaders/smaa_neighborhood_blend.frag.glsl
index ab0d97ff..b3255626 100644
--- a/base/shaders/smaa_neighborhood_blend.frag.glsl
+++ b/base/shaders/smaa_neighborhood_blend.frag.glsl
@@ -16,11 +16,18 @@ out vec4 frag_color;
 //-----------------------------------------------------------------------------
 // Neighborhood Blending Pixel Shader (Third Pass)
 
-vec4 textureLodA(sampler2D tex, vec2 coords, float lod) {
+vec4 textureLodA_color_tex(sampler2D color_tex, vec2 coords, float lod) {
 	#if defined(HLSL) || defined(METAL) || defined(SPIRV)
 	coords.y = 1.0 - coords.y;
 	#endif
-	return textureLod(tex, coords, lod);
+	return textureLod(color_tex, coords, lod);
+}
+
+vec4 textureLodA_sveloc(sampler2D sveloc, vec2 coords, float lod) {
+	#if defined(HLSL) || defined(METAL) || defined(SPIRV)
+	coords.y = 1.0 - coords.y;
+	#endif
+	return textureLod(sveloc, coords, lod);
 }
 
 vec4 smaa_neighborhood_blending_ps(vec2 texcoord, vec4 offset) {
@@ -70,20 +77,20 @@ vec4 smaa_neighborhood_blending_ps(vec2 texcoord, vec4 offset) {
 
 		// We exploit bilinear filtering to mix current pixel with the chosen
 		// neighbor:
-		vec4 color = blending_weight.x * textureLodA(color_tex, blending_coord.xy, 0.0);
-		color += blending_weight.y * textureLodA(color_tex, blending_coord.zw, 0.0);
+		vec4 color = blending_weight.x * textureLodA_color_tex(color_tex, blending_coord.xy, 0.0);
+		color += blending_weight.y * textureLodA_color_tex(color_tex, blending_coord.zw, 0.0);
 
 #ifdef _Veloc
 		// Antialias velocity for proper reprojection in a later stage:
-		vec2 velocity = blending_weight.x * textureLodA(sveloc, blending_coord.xy, 0.0).rg;
-		velocity += blending_weight.y * textureLodA(sveloc, blending_coord.zw, 0.0).rg;
+		vec2 velocity = blending_weight.x * textureLodA_sveloc(sveloc, blending_coord.xy, 0.0).rg;
+		velocity += blending_weight.y * textureLodA_sveloc(sveloc, blending_coord.zw, 0.0).rg;
 
 		// Pack velocity into the alpha channel:
 		color.a = sqrt(5.0 * length(velocity));
 #endif
 		return color;
 	}
-	return vec4(0.0);
+	return vec4(0.0, 0.0, 0.0, 0.0);
 }
 
 void main() {
diff --git a/base/shaders/ssao_blur_pass.frag.glsl b/base/shaders/ssao_blur_pass.frag.glsl
index f2455c57..805be482 100644
--- a/base/shaders/ssao_blur_pass.frag.glsl
+++ b/base/shaders/ssao_blur_pass.frag.glsl
@@ -9,7 +9,7 @@ uniform vec2 dir_inv;
 in vec2 tex_coord;
 out float frag_color;
 
-const float blur_weights[10] = float[] (0.132572, 0.125472, 0.106373, 0.08078, 0.05495, 0.033482, 0.018275, 0.008934, 0.003912, 0.001535);
+const float blur_weights[10] = { 0.132572, 0.125472, 0.106373, 0.08078, 0.05495, 0.033482, 0.018275, 0.008934, 0.003912, 0.001535 };
 const float discard_threshold = 0.95;
 
 void main() {
diff --git a/base/shaders/ssao_pass.frag.glsl b/base/shaders/ssao_pass.frag.glsl
index 2ecb791e..70fe7f36 100644
--- a/base/shaders/ssao_pass.frag.glsl
+++ b/base/shaders/ssao_pass.frag.glsl
@@ -1,14 +1,14 @@
 #version 450
 
-#include "std/math.glsl"
-#include "std/gbuffer.glsl"
-
 uniform sampler2D gbufferD;
-uniform sampler2D gbuffer0; // Normal
+uniform sampler2D gbuffer0;
 uniform mat4 P;
 uniform mat3 V3;
 uniform vec2 camera_proj;
 
+#include "std/math.glsl"
+#include "std/gbuffer.glsl"
+
 in vec3 view_ray;
 in vec2 tex_coord;
 out float frag_color;
@@ -24,7 +24,7 @@ float depth;
 vec3 vpos;
 
 vec2 get_projected_coord(vec3 hit_coord) {
-	vec4 projected_coord = P * vec4(hit_coord, 1.0);
+	vec4 projected_coord = mul(vec4(hit_coord, 1.0), P);
 	projected_coord.xy /= projected_coord.w;
 	projected_coord.xy = projected_coord.xy * 0.5 + 0.5;
 	#if defined(HLSL) || defined(METAL) || defined(SPIRV)
@@ -71,7 +71,7 @@ void main() {
 	vec3 n;
 	n.z = 1.0 - abs(enc.x) - abs(enc.y);
 	n.xy = n.z >= 0.0 ? enc.xy : octahedron_wrap(enc.xy);
-	n = normalize(V3 * n);
+	n = normalize(mul(n, V3));
 
 	vpos = get_pos_view(view_ray, d, camera_proj);
 
diff --git a/base/shaders/ssr_blur_pass.frag.glsl b/base/shaders/ssr_blur_pass.frag.glsl
index 2377d8a6..86587d7f 100644
--- a/base/shaders/ssr_blur_pass.frag.glsl
+++ b/base/shaders/ssr_blur_pass.frag.glsl
@@ -1,11 +1,11 @@
 #version 450
 
-#include "std/gbuffer.glsl"
-
 uniform sampler2D tex;
-uniform sampler2D gbuffer0; // Roughness
+uniform sampler2D gbuffer0;
 uniform vec2 dir_inv;
 
+#include "std/gbuffer.glsl"
+
 in vec2 tex_coord;
 out vec4 frag_color;
 
@@ -21,5 +21,5 @@ void main() {
 	frag_color.rgb += textureLod(tex, tex_coord, 0.0).rgb;
 	frag_color.rgb += textureLod(tex, tex_coord - dir_inv * 1.5, 0.0).rgb;
 	frag_color.rgb += textureLod(tex, tex_coord - dir_inv * 2.5, 0.0).rgb;
-	frag_color.rgb /= vec3(5.0);
+	frag_color.rgb /= vec3(5.0, 5.0, 5.0);
 }
diff --git a/base/shaders/ssr_pass.frag.glsl b/base/shaders/ssr_pass.frag.glsl
index 7d5f2270..47124db8 100644
--- a/base/shaders/ssr_pass.frag.glsl
+++ b/base/shaders/ssr_pass.frag.glsl
@@ -1,16 +1,16 @@
 #version 450
 
-#include "std/math.glsl"
-#include "std/gbuffer.glsl"
-
 uniform sampler2D tex;
 uniform sampler2D gbufferD;
-uniform sampler2D gbuffer0; // Normal, roughness
-uniform sampler2D gbuffer1; // basecol, occ
+uniform sampler2D gbuffer0;
+uniform sampler2D gbuffer1;
 uniform mat4 P;
 uniform mat3 V3;
 uniform vec2 camera_proj;
 
+#include "std/math.glsl"
+#include "std/gbuffer.glsl"
+
 in vec3 view_ray;
 in vec2 tex_coord;
 out vec4 frag_color;
@@ -27,7 +27,7 @@ vec3 hit_coord;
 float depth;
 
 vec2 get_projected_coord(const vec3 hit) {
-	vec4 projected_coord = P * vec4(hit, 1.0);
+	vec4 projected_coord = mul(vec4(hit, 1.0), P);
 	projected_coord.xy /= projected_coord.w;
 	projected_coord.xy = projected_coord.xy * 0.5 + 0.5;
 	#if defined(HLSL) || defined(METAL) || defined(SPIRV)
@@ -52,7 +52,7 @@ vec4 binary_search(vec3 dir) {
 		if (ddepth < 0.0) hit_coord += dir;
 	}
 	// Ugly discard of hits too far away
-	if (abs(ddepth) > ssr_search_dist / 500) return vec4(0.0);
+	if (abs(ddepth) > ssr_search_dist / 500) return vec4(0.0, 0.0, 0.0, 0.0);
 	return vec4(get_projected_coord(hit_coord), 0.0, 1.0);
 }
 
@@ -62,16 +62,22 @@ vec4 ray_cast(vec3 dir) {
 		hit_coord += dir;
 		if (get_delta_depth(hit_coord) > 0.0) return binary_search(dir);
 	}
-	return vec4(0.0);
+	return vec4(0.0, 0.0, 0.0, 0.0);
 }
 
 void main() {
 	vec4 g0 = textureLod(gbuffer0, tex_coord, 0.0);
 	float roughness = g0.b;
-	if (roughness == 1.0) { frag_color.rgb = vec3(0.0); return; }
+	if (roughness == 1.0) {
+		frag_color.rgb = vec3(0.0, 0.0, 0.0);
+		return;
+	}
 
 	float d = textureLod(gbufferD, tex_coord, 0.0).r * 2.0 - 1.0;
-	if (d == 1.0) { frag_color.rgb = vec3(0.0); return; }
+	if (d == 1.0) {
+		frag_color.rgb = vec3(0.0, 0.0, 0.0);
+		return;
+	}
 
 	vec2 enc = g0.rg;
 	vec3 n;
@@ -79,7 +85,7 @@ void main() {
 	n.xy = n.z >= 0.0 ? enc.xy : octahedron_wrap(enc.xy);
 	n = normalize(n);
 
-	vec3 view_normal = V3 * n;
+	vec3 view_normal = mul(n, V3);
 	vec3 view_pos = get_pos_view(view_ray, d, camera_proj);
 	vec3 reflected = normalize(reflect(view_pos, view_normal));
 	hit_coord = view_pos;
diff --git a/base/shaders/std/brdf.glsl b/base/shaders/std/brdf.glsl
index 4140ad33..683765fb 100644
--- a/base/shaders/std/brdf.glsl
+++ b/base/shaders/std/brdf.glsl
@@ -3,11 +3,11 @@
 #define _BRDF_GLSL_
 
 vec3 surface_albedo(const vec3 base_color, const float metalness) {
-	return mix(base_color, vec3(0.0), metalness);
+	return mix(base_color, vec3(0.0, 0.0, 0.0), metalness);
 }
 
 vec3 surface_f0(const vec3 base_color, const float metalness) {
-	return mix(vec3(0.04), base_color, metalness);
+	return mix(vec3(0.04, 0.04, 0.04), base_color, metalness);
 }
 
 float mip_from_roughness(const float roughness, const float num_mipmaps) {
diff --git a/base/shaders/std/conetrace.glsl b/base/shaders/std/conetrace.glsl
index 2e0e8f9e..70141a99 100644
--- a/base/shaders/std/conetrace.glsl
+++ b/base/shaders/std/conetrace.glsl
@@ -38,7 +38,7 @@ float trace_cone_ao(sampler3D voxels, const vec3 origin, vec3 dir, const float a
 	while (sample_col < 1.0 && dist < max_dist) {
 		sample_pos = dir * dist + origin;
 		float mip = max(log2(diam * voxelgi_resolution.x), 0);
-		float mip_sample = textureLod(voxels, sample_pos * 0.5 + vec3(0.5), mip).r;
+		float mip_sample = textureLod(voxels, sample_pos * 0.5 + vec3(0.5, 0.5, 0.5), mip).r;
 		sample_col += (1 - sample_col) * mip_sample;
 		dist += max(diam / 2, VOXEL_SIZE);
 		diam = dist * aperture;
diff --git a/base/shaders/std/deferred_light.glsl b/base/shaders/std/deferred_light.glsl
index 8db51dd4..42a67b1a 100644
--- a/base/shaders/std/deferred_light.glsl
+++ b/base/shaders/std/deferred_light.glsl
@@ -1,14 +1,4 @@
 
-#ifndef _DEFERRED_LIGHT_GLSL_
-#define _DEFERRED_LIGHT_GLSL_
-
-#include "std/gbuffer.glsl"
-#include "std/light.glsl"
-#include "std/shirr.glsl"
-#ifdef _Voxel
-#include "std/conetrace.glsl"
-#endif
-
 uniform sampler2D gbufferD;
 uniform sampler2D gbuffer0;
 uniform sampler2D gbuffer1;
@@ -31,6 +21,13 @@ uniform vec3 eye_look;
 uniform vec3 point_pos;
 uniform vec3 point_col;
 
+#include "gbuffer.glsl"
+#include "light.glsl"
+#include "shirr.glsl"
+#ifdef _Voxel
+#include "conetrace.glsl"
+#endif
+
 in vec2 tex_coord;
 in vec3 view_ray;
 out vec4 frag_color;
@@ -86,7 +83,7 @@ void main() {
 
 	if (matid == 1) { // Emission
 		frag_color.rgb += g1.rgb; // materialid
-		albedo = vec3(0.0);
+		albedo = vec3(0.0, 0.0, 0.0);
 	}
 
 	frag_color.rgb += sample_light(p, n, v, dotnv, point_pos, point_col, albedo, roughness, f0, occ
@@ -96,5 +93,3 @@ void main() {
 	);
 	frag_color.a = 1.0; // Mark as opaque
 }
-
-#endif
diff --git a/base/shaders/std/light.glsl b/base/shaders/std/light.glsl
index 2ffdec83..89956e11 100644
--- a/base/shaders/std/light.glsl
+++ b/base/shaders/std/light.glsl
@@ -2,11 +2,11 @@
 #ifndef _LIGHT_GLSL_
 #define _LIGHT_GLSL_
 
-#include "std/brdf.glsl"
-#include "std/math.glsl"
-#include "std/ltc.glsl"
+#include "brdf.glsl"
+#include "math.glsl"
+#include "ltc.glsl"
 #ifdef _Voxel
-#include "std/conetrace.glsl"
+#include "conetrace.glsl"
 #endif
 
 uniform vec3 light_area0;
@@ -36,7 +36,12 @@ vec3 sample_light(const vec3 p, const vec3 n, const vec3 v, const float dotnv, c
 		vec3(t.w, 0.0, t.x));
 	float ltcspec = ltc_evaluate(n, v, dotnv, p, inv, light_area0, light_area1, light_area2, light_area3);
 	ltcspec *= textureLod(sltc_mag, tuv, 0.0).a;
-	float ltcdiff = ltc_evaluate(n, v, dotnv, p, mat3(1.0), light_area0, light_area1, light_area2, light_area3);
+
+	mat3 m1 = mat3(
+		vec3(1.0, 0.0, 0.0),
+		vec3(0.0, 1.0, 0.0),
+		vec3(0.0, 0.0, 1.0));
+	float ltcdiff = ltc_evaluate(n, v, dotnv, p, m1, light_area0, light_area1, light_area2, light_area3);
 	vec3 direct = albedo * ltcdiff + ltcspec * 0.05;
 
 	direct *= attenuate(distance(p, lp));
diff --git a/base/shaders/std/ltc.glsl b/base/shaders/std/ltc.glsl
index bc66428e..0f527563 100644
--- a/base/shaders/std/ltc.glsl
+++ b/base/shaders/std/ltc.glsl
@@ -22,14 +22,14 @@ float ltc_evaluate(vec3 N, vec3 V, float dotnv, vec3 P, mat3 Minv, vec3 points0,
 	T2 = cross(N, T1);
 
 	// Rotate area light in (T1, T2, R) basis
-	Minv = Minv * transpose(mat3(T1, T2, N));
+	Minv = mul(transpose(mat3(T1, T2, N)), Minv);
 
 	// Polygon (allocate 5 vertices for clipping)
-	vec3 L0 = Minv * (points0 - P);
-	vec3 L1 = Minv * (points1 - P);
-	vec3 L2 = Minv * (points2 - P);
-	vec3 L3 = Minv * (points3 - P);
-	vec3 L4 = vec3(0.0);
+	vec3 L0 = mul((points0 - P), Minv);
+	vec3 L1 = mul((points1 - P), Minv);
+	vec3 L2 = mul((points2 - P), Minv);
+	vec3 L3 = mul((points3 - P), Minv);
+	vec3 L4 = vec3(0.0, 0.0, 0.0);
 
 	int n = 0;
 	// Detect clipping config
diff --git a/base/shaders/std/math.glsl b/base/shaders/std/math.glsl
index 8afbe906..db9e864c 100644
--- a/base/shaders/std/math.glsl
+++ b/base/shaders/std/math.glsl
@@ -9,7 +9,7 @@ vec2 envmap_equirect(const vec3 normal, const float angle) {
 	const float PI = 3.1415926535;
 	const float PI2 = PI * 2.0;
 	float phi = acos(normal.z);
-	float theta = atan(-normal.y, normal.x) + PI + angle;
+	float theta = atan2(normal.x, -normal.y) + PI + angle;
 	return vec2(theta / PI2, phi / PI);
 }
 
diff --git a/base/shaders/voxel_hlsl/voxel_pos.frag.glsl b/base/shaders/voxel_hlsl/voxel_pos.frag.d3d11
similarity index 100%
rename from base/shaders/voxel_hlsl/voxel_pos.frag.glsl
rename to base/shaders/voxel_hlsl/voxel_pos.frag.d3d11
diff --git a/base/shaders/voxel_hlsl/voxel_pos.geom.glsl b/base/shaders/voxel_hlsl/voxel_pos.geom.d3d11
similarity index 100%
rename from base/shaders/voxel_hlsl/voxel_pos.geom.glsl
rename to base/shaders/voxel_hlsl/voxel_pos.geom.d3d11
diff --git a/base/shaders/voxel_hlsl/voxel_pos.vert.glsl b/base/shaders/voxel_hlsl/voxel_pos.vert.d3d11
similarity index 100%
rename from base/shaders/voxel_hlsl/voxel_pos.vert.glsl
rename to base/shaders/voxel_hlsl/voxel_pos.vert.d3d11
diff --git a/base/shaders/world_pass.vert.glsl b/base/shaders/world_pass.vert.glsl
index dcceb0b3..72d2f485 100644
--- a/base/shaders/world_pass.vert.glsl
+++ b/base/shaders/world_pass.vert.glsl
@@ -8,5 +8,5 @@ out vec3 normal;
 
 void main() {
 	normal = nor;
-	gl_Position = SMVP * vec4(pos, 1.0);
+	gl_Position = mul(vec4(pos, 1.0), SMVP);
 }