diff --git a/res/shaders-vk/lines.vert.glsl b/res/shaders-vk/lines.vert.glsl
index 11128bc9c..bae1fc847 100644
--- a/res/shaders-vk/lines.vert.glsl
+++ b/res/shaders-vk/lines.vert.glsl
@@ -5,7 +5,7 @@ layout (location = 1) in vec4 a_color;
 
 layout(location = 0) out vec4 v_color;
 
-layout(binding = 0) uniform Projview {
+layout(set = 0, binding = 0) uniform Projview {
 	mat4 u_projview;
 };
 
diff --git a/res/shaders-vk/main.frag.glsl b/res/shaders-vk/main.frag.glsl
index e5e0d69c8..48a08f1d2 100644
--- a/res/shaders-vk/main.frag.glsl
+++ b/res/shaders-vk/main.frag.glsl
@@ -17,7 +17,9 @@ layout (set = 0, binding = 1) uniform Fog {
 };
 
 void main(){
-    vec3 fogColor = texture(u_cubemap, a_dir).rgb;
+    vec3 dir = a_dir;
+    dir.z = -dir.z;
+    vec3 fogColor = texture(u_cubemap, dir).rgb;
     vec4 tex_color = texture(u_texture0, a_texCoord);
     float depth = (a_distance/256.0);
     float alpha = a_color.a * tex_color.a;
diff --git a/res/shaders-vk/main.vert.glsl b/res/shaders-vk/main.vert.glsl
index a98c2e84a..fd18b545d 100644
--- a/res/shaders-vk/main.vert.glsl
+++ b/res/shaders-vk/main.vert.glsl
@@ -42,7 +42,7 @@ void main(){
     a_color = vec4(pow(light, vec3(u_gamma)),1.0f);
     a_texCoord = v_texCoord;
 
-    vec3 skyLightColor = texture(u_cubemap, vec3(-0.4f, -0.05f, -0.4f)).rgb;
+    vec3 skyLightColor = texture(u_cubemap, vec3(-0.4f, -0.05f, 0.4f)).rgb;
     skyLightColor.g *= 0.9;
     skyLightColor.b *= 0.8;
     skyLightColor = min(vec3(1.0), skyLightColor*SKY_LIGHT_MUL);
diff --git a/res/shaders-vk/ui.vert.glsl b/res/shaders-vk/ui.vert.glsl
index 092677507..92b6d90a6 100644
--- a/res/shaders-vk/ui.vert.glsl
+++ b/res/shaders-vk/ui.vert.glsl
@@ -7,7 +7,7 @@ layout (location = 2) in vec4 v_color;
 layout(location = 0) out vec2 a_textureCoord;
 layout(location = 1) out vec4 a_color;
 
-layout(binding = 0) uniform Projview {
+layout(set = 0, binding = 0) uniform Projview {
 	mat4 u_projview;
 };
 
diff --git a/res/shaders/lines.vert.spv b/res/shaders/lines.vert.spv
index e71b8b721..d725fe255 100644
Binary files a/res/shaders/lines.vert.spv and b/res/shaders/lines.vert.spv differ
diff --git a/res/shaders/main.frag.spv b/res/shaders/main.frag.spv
index 664228c71..835619a93 100644
Binary files a/res/shaders/main.frag.spv and b/res/shaders/main.frag.spv differ
diff --git a/res/shaders/main.vert.spv b/res/shaders/main.vert.spv
index 43b3ec22c..5c7ef7baf 100644
Binary files a/res/shaders/main.vert.spv and b/res/shaders/main.vert.spv differ
diff --git a/res/shaders/ui.vert.spv b/res/shaders/ui.vert.spv
index b663c6601..cca97546e 100644
Binary files a/res/shaders/ui.vert.spv and b/res/shaders/ui.vert.spv differ
diff --git a/src/assets/asset_loaders.cpp b/src/assets/asset_loaders.cpp
index b627e761b..d1b253498 100644
--- a/src/assets/asset_loaders.cpp
+++ b/src/assets/asset_loaders.cpp
@@ -40,8 +40,10 @@ bool assetload::shader(Assets* assets,
                        const string filename,
                        const string name) {
 #ifdef USE_VULKAN
+	path vertexFile = paths->find(filename + ".vert.spv");
+	path fragmentFile = paths->find(filename + ".frag.spv");
 	const ShaderType shaderType = toShaderType(name);
-	IShader* shader = vulkan::loadShader(filename.string() + ".vert.spv", filename.string() + ".frag.spv", shaderType);
+	IShader* shader = vulkan::loadShader(vertexFile, fragmentFile, shaderType);
 #else
 	path vertexFile = paths->find(filename+".glslv");
 	path fragmentFile = paths->find(filename+".glslf");
diff --git a/src/frontend/BlocksPreview.cpp b/src/frontend/BlocksPreview.cpp
index 163dbe58f..6efdea942 100644
--- a/src/frontend/BlocksPreview.cpp
+++ b/src/frontend/BlocksPreview.cpp
@@ -7,6 +7,7 @@
 #include "../graphics/Texture.h"
 #include "../graphics/Atlas.h"
 #include "../graphics/Batch3D.h"
+#include "../graphics-vk/Batch3D.h"
 #include "../window/Camera.h"
 #include "../voxels/Block.h"
 #include "ContentGfxCache.h"
@@ -18,7 +19,7 @@ BlocksPreview::BlocksPreview(IShader* shader,
                              Atlas* atlas, 
                              const ContentGfxCache* cache)
     : shader(shader), atlas(atlas), cache(cache) {
-    batch = new Batch3D(1024);
+    batch = new vulkan::Batch3D(1024);
 }
 
 BlocksPreview::~BlocksPreview() {
@@ -28,10 +29,10 @@ BlocksPreview::~BlocksPreview() {
 void BlocksPreview::begin(const Viewport* viewport) {
     this->viewport = viewport;
     shader->use();
-    shader->uniformMatrix("u_projview", 
-        glm::ortho(0.0f, float(viewport->getWidth()), 
-                   0.0f, float(viewport->getHeight()), 
-                    -1000.0f, 1000.0f) * 
+    shader->uniformMatrix("u_projview",
+        glm::ortho(0.0f, float(viewport->getWidth()),
+                   0.0f, float(viewport->getHeight()),
+                    -1000.0f, 1000.0f) *
         glm::lookAt(vec3(2, 2, 2), vec3(0.0f), vec3(0, 1, 0)));
     atlas->getTexture()->bind();
 }
diff --git a/src/frontend/BlocksPreview.h b/src/frontend/BlocksPreview.h
index 3570e0b6c..08213f2c1 100644
--- a/src/frontend/BlocksPreview.h
+++ b/src/frontend/BlocksPreview.h
@@ -4,6 +4,10 @@
 #include "../typedefs.h"
 #include <glm/glm.hpp>
 
+namespace vulkan {
+    class Batch3D;
+}
+
 class Viewport;
 class IShader;
 class Atlas;
@@ -14,7 +18,7 @@ class ContentGfxCache;
 class BlocksPreview {
     IShader* shader;
     Atlas* atlas;
-    Batch3D* batch;
+    vulkan::Batch3D* batch;
     const ContentGfxCache* const cache;
     const Viewport* viewport;
 public:
diff --git a/src/frontend/hud.cpp b/src/frontend/hud.cpp
index 671d5d63f..1c2550586 100644
--- a/src/frontend/hud.cpp
+++ b/src/frontend/hud.cpp
@@ -65,9 +65,9 @@ HudRenderer::HudRenderer(Engine* engine,
 			  gui(engine->getGUI()),
 			  cache(cache) {
 	auto menu = gui->getMenu();
-	// blocksPreview = new BlocksPreview(assets->getShader("ui3d"),
-	// 								  assets->getAtlas("blocks"),
-	// 								  cache);
+	blocksPreview = new BlocksPreview(assets->getShader("ui3d"),
+									  assets->getAtlas("blocks"),
+									  cache);
 
 	uicamera = new Camera(vec3(), 1);
 	uicamera->perspective = false;
@@ -92,7 +92,11 @@ HudRenderer::HudRenderer(Engine* engine,
 		return L"fps: "+this->fpsString;
 	})));
 	panel->add(shared_ptr<Label>(create_label([this](){
+#ifdef USE_VULKAN
+		return L"meshes: " + std::to_wstring(vulkan::meshesCount);
+#else
 		return L"meshes: " + std::to_wstring(Mesh::meshesCount);
+#endif
 	})));
 	panel->add(shared_ptr<Label>(create_label([=](){
 		auto& settings = engine->getSettings();
@@ -344,19 +348,19 @@ void HudRenderer::draw(const GfxContext& ctx){
 	batch->rect(width - 68, height - 68, 68, 68);
 	batch->setColor(vec4(1.0f));
 	batch->render();
-	batch->end();
+	// batch->end();
 
-	// blocksPreview->begin(&ctx.getViewport());
-	// {
-	// 	Window::clearDepth();
-	// 	GfxContext subctx = ctx.sub();
-	// 	subctx.depthTest(true);
-	// 	subctx.cullFace(true);
-	//
-	// 	Block* cblock = contentIds->getBlockDef(player->choosenBlock);
-	// 	assert(cblock != nullptr);
-	// 	blocksPreview->draw(cblock, width - 56, uicamera->getFov() - 56, 48, vec4(1.0f));
-	// }
+	blocksPreview->begin(&ctx.getViewport());
+	{
+		Window::clearDepth();
+		GfxContext subctx = ctx.sub();
+		subctx.depthTest(true);
+		subctx.cullFace(true);
+
+		Block* cblock = contentIds->getBlockDef(player->choosenBlock);
+		assert(cblock != nullptr);
+		blocksPreview->draw(cblock, width - 56, uicamera->getFov() - 56, 48, vec4(1.0f));
+	}
 	uishader->use();
 #ifndef USE_VULKAN
 	batch->begin();
diff --git a/src/frontend/screens.cpp b/src/frontend/screens.cpp
index 378840a1b..f92ea968d 100644
--- a/src/frontend/screens.cpp
+++ b/src/frontend/screens.cpp
@@ -68,7 +68,7 @@ void MenuScreen::update(float delta) {
 void MenuScreen::draw(float delta) {
     Window::clear();
     Window::setBgColor(vec3(0.2f));
-    vulkan::VulkanContext::get().beginScreenDraw(0.2f, 0.2f, 0.2f);
+    vulkan::VulkanContext::get().beginScreenDraw(0.0f, 0.0f, 0.0f);
 
     uicamera->setFov(Window::height);
 	IShader* uishader = engine->getAssets()->getShader("ui");
diff --git a/src/graphics-common/IShader.h b/src/graphics-common/IShader.h
index 75d6a2062..0b8cb1653 100644
--- a/src/graphics-common/IShader.h
+++ b/src/graphics-common/IShader.h
@@ -10,6 +10,7 @@
 
 #ifdef USE_VULKAN
 #include <vulkan/vulkan_core.h>
+struct ProjectionViewConstant;
 struct DynamicConstants;
 #endif
 
@@ -30,6 +31,7 @@ class IShader {
 #ifdef USE_VULKAN
     virtual void use(VkCommandBuffer commandBuffer, VkExtent2D extent2D) { }
     virtual void pushConstant(const DynamicConstants &constants) { }
+    virtual void pushConatnt(const ProjectionViewConstant &constant) { }
 #endif
 };
 
diff --git a/src/graphics-vk/Batch2D.cpp b/src/graphics-vk/Batch2D.cpp
index 624d83c79..a1be0d7b5 100644
--- a/src/graphics-vk/Batch2D.cpp
+++ b/src/graphics-vk/Batch2D.cpp
@@ -16,7 +16,7 @@ namespace vulkan {
             255, 255, 255, 255
         };
 
-        m_blank = new Image2d(pixels, 1, 1, VK_FORMAT_R8G8B8A8_SRGB);
+        m_blank = new Image2d(pixels, 1, 1, VK_FORMAT_R8G8B8A8_UNORM);
         m_texture = m_blank;
     }
 
@@ -39,9 +39,11 @@ namespace vulkan {
         render();
         if (texture == nullptr) {
             m_texture = m_blank;
+            m_texture->bind();
             return;
         }
         m_texture = texture;
+        m_texture->bind();
     }
 
     void Batch2D::begin() {
@@ -201,7 +203,6 @@ namespace vulkan {
     void Batch2D::render() {
         const VertexOffset offset = {m_currentOffset, m_index - m_currentOffset};
         if (offset.count == 0 || offset.offset >= m_capacity) return;
-        m_texture->bind();
         m_mesh->draw(offset);
 
         m_currentOffset = m_index;
diff --git a/src/graphics-vk/Batch2D.h b/src/graphics-vk/Batch2D.h
index b623c79f1..3574d491a 100644
--- a/src/graphics-vk/Batch2D.h
+++ b/src/graphics-vk/Batch2D.h
@@ -14,7 +14,6 @@ class ITexture;
 namespace vulkan {
 
     class Batch2D {
-        std::vector<VertexOffset> m_offsets{};
         Vertex2D *m_buffer = nullptr;
         Mesh<Vertex2D> *m_mesh = nullptr;
         size_t m_capacity = 0;
diff --git a/src/graphics-vk/Batch3D.cpp b/src/graphics-vk/Batch3D.cpp
new file mode 100644
index 000000000..2b9dbb455
--- /dev/null
+++ b/src/graphics-vk/Batch3D.cpp
@@ -0,0 +1,166 @@
+//
+// Created by chelovek on 12/11/23.
+//
+
+#include "Batch3D.h"
+
+#include "texture/Image2d.h"
+#include "../graphics/UVRegion.h"
+
+namespace vulkan {
+    void Batch3D::vertex(float x, float y, float z, float u, float v, float r, float g, float b, float a) {
+        m_buffer[m_index++] = {{x, y, z}, {u, v}, {r, g, b, a}};
+    }
+
+    void Batch3D::vertex(glm::vec3 coord, float u, float v, float r, float g, float b, float a) {
+        m_buffer[m_index++] = {coord, {u, v}, {r, g, b, a}};
+    }
+
+    void Batch3D::vertex(glm::vec3 point, glm::vec2 uvpoint, float r, float g, float b, float a) {
+        m_buffer[m_index++] = {point, uvpoint, {r, g, b, a}};
+    }
+
+    void Batch3D::vertex(glm::vec3 point, glm::vec2 uvpoint, glm::vec4 color) {
+        m_buffer[m_index++] = {point, uvpoint, color};
+    }
+
+    void Batch3D::face(const glm::vec3& coord, float w, float h,
+                       const glm::vec3& axisX,
+                       const glm::vec3& axisY,
+                       const UVRegion& region,
+                       const glm::vec4& tint) {
+        vertex(coord, region.u1, region.v1,
+           tint.r, tint.g, tint.b, tint.a);
+        vertex(coord + axisX * w, region.u2, region.v1,
+                tint.r, tint.g, tint.b, tint.a);
+        vertex(coord + axisX * w + axisY * h, region.u2, region.v2,
+               tint.r, tint.g, tint.b, tint.a);
+
+        vertex(coord, region.u1, region.v1,
+               tint.r, tint.g, tint.b, tint.a);
+        vertex(coord + axisX * w + axisY * h, region.u2, region.v2,
+               tint.r, tint.g, tint.b, tint.a);
+        vertex(coord + axisY * h, region.u1, region.v2,
+               tint.r, tint.g, tint.b, tint.a);
+    }
+
+    Batch3D::Batch3D(size_t capacity) : m_capacity(capacity) {
+        m_mesh = new Mesh<Vertex3DUI>(nullptr, capacity);
+        m_mesh->mapVertex(&m_buffer);
+
+        constexpr unsigned char pixels[] = {
+            255, 255, 255, 255
+        };
+
+        m_blank = new Image2d(pixels, 1, 1, VK_FORMAT_R8G8B8A8_UNORM);
+        m_texture = m_blank;
+    }
+
+    Batch3D::~Batch3D() {
+        delete m_mesh;
+        delete m_blank;
+    }
+
+    void Batch3D::begin() {
+        m_texture->bind();
+        m_mesh->bind();
+        m_index = 0;
+        m_currentOffset = 0;
+    }
+
+    void Batch3D::texture(ITexture* texture) {
+        if (m_texture == texture)
+            return;
+        flush();
+        if (texture == nullptr) {
+            m_texture = m_blank;
+            m_texture->bind();
+            return;
+        }
+        m_texture = texture;
+        m_texture->bind();
+    }
+
+    void Batch3D::sprite(glm::vec3 pos, glm::vec3 up, glm::vec3 right, float w, float h, const UVRegion& uv,
+        glm::vec4 color) {
+
+        if (m_index >= m_capacity) return;
+
+        const float r = color.r;
+        const float g = color.g;
+        const float b = color.b;
+        const float a = color.a;
+
+        vertex(pos.x - right.x * w - up.x * h,
+                    pos.y - right.y * w - up.y * h,
+                    pos.z - right.z * w - up.z * h,
+                    uv.u1, uv.v1,
+                    r,g,b,a);
+
+        vertex(pos.x + right.x * w + up.x * h,
+                pos.y + right.y * w + up.y * h,
+                pos.z + right.z * w + up.z * h,
+                uv.u2, uv.v2,
+                r,g,b,a);
+
+        vertex(pos.x - right.x * w - up.x * h,
+                pos.y + right.y * w + up.y * h,
+                pos.z - right.z * w - up.z * h,
+                uv.u1, uv.v2,
+                r,g,b,a);
+
+        vertex(pos.x - right.x * w - up.x * h,
+                pos.y - right.y * w - up.y * h,
+                pos.z - right.z * w - up.z * h,
+                uv.u1, uv.v1,
+                r,g,b,a);
+
+        vertex(pos.x + right.x * w + up.x * h,
+                pos.y - right.y * w - up.y * h,
+                pos.z + right.z * w + up.z * h,
+                uv.u2, uv.v1,
+                r,g,b,a);
+
+        vertex(pos.x + right.x * w + up.x * h,
+                pos.y + right.y * w + up.y * h,
+                pos.z + right.z * w + up.z * h,
+                uv.u2, uv.v2,
+                r,g,b,a);
+    }
+
+    inline glm::vec4 do_tint(float value) {
+        return {value, value, value, 1.0f};
+    }
+
+    void Batch3D::xSprite(float w, float h, const UVRegion& uv, const glm::vec4 tint, bool shading) {
+        if (m_index >= m_capacity) return;
+
+        face(glm::vec3(-w * 0.25f, 0.0f, 0.0f - w * 0.25f), w, h, glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), uv, (shading ? do_tint(1.0f)*tint : tint));
+        face(glm::vec3(w * 0.25f, 0.0f, w * 0.5f - w * 0.25f), w, h, glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), uv, (shading ? do_tint(0.9f)*tint : tint));
+    }
+
+    void Batch3D::blockCube(const glm::vec3 size, const UVRegion(& texfaces)[6], const glm::vec4 tint, bool shading) {
+        if (m_index >= m_capacity) return;
+        const glm::vec3 coord = (1.0f - size) * -0.45f;
+        face(coord + glm::vec3(0.0f, 0.0f, 0.0f), size.x, size.y, glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), texfaces[5], (shading ? do_tint(0.8)*tint : tint));
+        face(coord + glm::vec3(size.x, 0.0f, -size.z), size.x, size.y, glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), texfaces[4], (shading ? do_tint(0.8f)*tint : tint));
+        face(coord + glm::vec3(0.0f, size.y, 0.0f), size.x, size.z, glm::vec3(1, 0, 0), glm::vec3(0, 0, -1), texfaces[3], (shading ? do_tint(1.0f)*tint : tint));
+        face(coord + glm::vec3(0.0f, 0.0f, -size.z), size.x, size.z, glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), texfaces[2], (shading ? do_tint(0.7f)*tint : tint));
+        face(coord + glm::vec3(0.0f, 0.0f, -size.z), size.z, size.y, glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), texfaces[0], (shading ? do_tint(0.9f)*tint : tint));
+        face(coord + glm::vec3(size.x, 0.0f, 0.0f), size.z, size.y, glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), texfaces[1], (shading ? do_tint(0.9f)*tint : tint));
+    }
+
+    void Batch3D::flush() {
+        const VertexOffset offset = {m_currentOffset, m_index - m_currentOffset};
+        if (offset.count == 0 || offset.offset >= m_capacity) return;
+        end();
+        m_mesh->bind();
+        m_mesh->draw(offset);
+
+        m_currentOffset = m_index;
+    }
+
+    void Batch3D::end() {
+        m_mesh->reload(nullptr, m_capacity);
+    }
+} // vulkan
\ No newline at end of file
diff --git a/src/graphics-vk/Batch3D.h b/src/graphics-vk/Batch3D.h
new file mode 100644
index 000000000..dcba0ed85
--- /dev/null
+++ b/src/graphics-vk/Batch3D.h
@@ -0,0 +1,57 @@
+//
+// Created by chelovek on 12/11/23.
+//
+
+#ifndef BATCH3D_H
+#define BATCH3D_H
+
+#include "Mesh.h"
+
+class UVRegion;
+class ITexture;
+
+namespace vulkan {
+
+    class Batch3D {
+        Vertex3DUI *m_buffer = nullptr;
+        Mesh<Vertex3DUI> *m_mesh = nullptr;
+        size_t m_capacity = 0;
+        size_t m_index = 0;
+        size_t m_currentOffset = 0;
+
+        ITexture *m_blank = nullptr;
+        ITexture *m_texture = nullptr;
+
+        void vertex(float x, float y, float z,
+                float u, float v,
+                float r, float g, float b, float a);
+        void vertex(glm::vec3 coord,
+                float u, float v,
+                float r, float g, float b, float a);
+        void vertex(glm::vec3 point, glm::vec2 uvpoint,
+                    float r, float g, float b, float a);
+
+        void vertex(glm::vec3 point, glm::vec2 uvpoint, glm::vec4 color);
+
+        void face(const glm::vec3& coord, float w, float h,
+            const glm::vec3& axisX,
+            const glm::vec3& axisY,
+            const UVRegion& region,
+            const glm::vec4& tint);
+    public:
+        Batch3D(size_t capacity);
+        ~Batch3D();
+
+        void begin();
+        void texture(ITexture* texture);
+        void sprite(glm::vec3 pos, glm::vec3 up, glm::vec3 right, float w, float h, const UVRegion& uv, glm::vec4 color);
+        void xSprite(float w, float h, const UVRegion& uv, const glm::vec4 tint, bool shading=true);
+        void blockCube(const glm::vec3 size, const UVRegion(&texfaces)[6], const glm::vec4 tint, bool shading=true);
+        void flush();
+
+        void end();
+    };
+
+} // vulkan
+
+#endif //BATCH3D_H
diff --git a/src/graphics-vk/Mesh.h b/src/graphics-vk/Mesh.h
index 44fc70836..d05b9aa0e 100644
--- a/src/graphics-vk/Mesh.h
+++ b/src/graphics-vk/Mesh.h
@@ -19,9 +19,11 @@ namespace vulkan {
         size_t count;
     };
 
+    inline u32 meshesCount = 0;
+
     template<typename TVertex>
     class Mesh {
-        static_assert(tools::is_same_of_types_v<TVertex, Vertex3D, VertexLine, Vertex2D, VertexBackSkyGen>, "Only vertices");
+        static_assert(tools::is_same_of_types_v<TVertex, Vertex3D, VertexLine, Vertex2D, Vertex3DUI, VertexBackSkyGen>, "Only vertices");
 
         std::unique_ptr<Buffer> m_stagingVertexBuffer = nullptr;
         std::unique_ptr<Buffer> m_stagingIndexBuffer = nullptr;
@@ -32,6 +34,7 @@ namespace vulkan {
         size_t m_vertices = 0;
         size_t m_indices = 0;
     public:
+
         Mesh() = default;
         Mesh(const TVertex *vertexBuffer, size_t vertices, const int* indexBuffer, size_t indices);
         Mesh(const TVertex *vertexBuffer, size_t vertices) :
@@ -54,6 +57,8 @@ namespace vulkan {
 
     template<typename TVertex>
     Mesh<TVertex>::Mesh(const TVertex *vertexBuffer, size_t vertices, const int *indexBuffer, size_t indices) : m_vertices(vertices), m_indices(indices) {
+        ++meshesCount;
+
         m_stagingVertexBuffer = std::make_unique<Buffer>(vertices * sizeof(TVertex), VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
         m_vertexBuffer = std::make_unique<Buffer>(vertices * sizeof(TVertex), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, 0);
 
diff --git a/src/graphics-vk/Tools.h b/src/graphics-vk/Tools.h
index 0da516613..6a5f0b51f 100644
--- a/src/graphics-vk/Tools.h
+++ b/src/graphics-vk/Tools.h
@@ -115,12 +115,9 @@ namespace tools {
 
     template<typename ...Args>
     std::array<VkPushConstantRange, sizeof...(Args)> getPushConstantRanges(Args &&...args) {
-        if constexpr (sizeof...(Args) == 0)
-            return {};
-        else
-            return {
-                { VkPushConstantRange{ args.shaderStage, args.offset, args.size }... }
-            };
+        return {
+            {VkPushConstantRange{args.shaderStage, args.offset, args.size}...}
+        };
     }
 }
 
diff --git a/src/graphics-vk/UniformValues.h b/src/graphics-vk/UniformValues.h
index 00f457003..ae648ada3 100644
--- a/src/graphics-vk/UniformValues.h
+++ b/src/graphics-vk/UniformValues.h
@@ -15,7 +15,6 @@
 #include "uniforms/BackgroundUniform.h"
 #include "uniforms/FogUniform.h"
 #include "uniforms/ProjectionViewUniform.h"
-#include "uniforms/SkyboxUniform.h"
 #include "uniforms/StateUniform.h"
 
 namespace vulkan {
@@ -26,7 +25,7 @@ namespace vulkan {
         glm::mat4>;
 
     template<typename T>
-    inline constexpr bool is_uniform_type_v = tools::is_same_of_types_v<T, float, int, glm::vec2, glm::vec3, glm::vec4, glm::mat4, std::vector<glm::vec3>>;
+    inline constexpr bool is_uniform_type_v = tools::is_same_of_types_v<T, float, int, glm::vec2, glm::vec3, glm::vec4, glm::mat4>;
 
     // this class use for generate vulkan uniforms
     // Vulkan shaders doesn't support OpenGL uniform: uniform mat4 name
diff --git a/src/graphics-vk/VulkanContext.cpp b/src/graphics-vk/VulkanContext.cpp
index daa04cfdf..3146935f2 100644
--- a/src/graphics-vk/VulkanContext.cpp
+++ b/src/graphics-vk/VulkanContext.cpp
@@ -90,7 +90,6 @@ namespace vulkan {
     void VulkanContext::initUploadContext() {
         VkFenceCreateInfo fenceInfo{};
         fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-        // fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
         VkCommandPoolCreateInfo commandPoolCreateInfo{};
         commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
diff --git a/src/graphics-vk/device/Shader.cpp b/src/graphics-vk/device/Shader.cpp
index eda84b17c..1cc99e7ca 100644
--- a/src/graphics-vk/device/Shader.cpp
+++ b/src/graphics-vk/device/Shader.cpp
@@ -12,6 +12,7 @@
 #include "../VulkanContext.h"
 #include "../VulkanDefenitions.h"
 #include "../uniforms/DynamicConstants.h"
+#include "../uniforms/ProjectionViewConstant.h"
 
 inline std::vector<char> readFile(const std::filesystem::path &path) {
 
@@ -115,6 +116,21 @@ namespace vulkan {
         vkCmdPushConstants(commandBuffer, m_pipeline->getLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(DynamicConstants), &constants);
     }
 
+    template<ShaderType ...Types>
+    struct CheckAllowShaders {
+        bool value = false;
+        explicit CheckAllowShaders(ShaderType type) {
+            value = ((type == Types) || ...);
+        }
+    };
+
+    void Shader::pushConatnt(const ProjectionViewConstant& constant) {
+        const auto commandBuffer = VulkanContext::get().getCurrentState().commandbuffer;
+
+        if (commandBuffer == VK_NULL_HANDLE || m_pipeline == nullptr || !CheckAllowShaders<ShaderType::UI, ShaderType::UI3D, ShaderType::LINES>(m_type).value) return;
+        vkCmdPushConstants(commandBuffer, m_pipeline->getLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(ProjectionViewConstant), &constant);
+    }
+
     void Shader::use(VkCommandBuffer commandBuffer, VkExtent2D extent2D) {
         if (commandBuffer == VK_NULL_HANDLE) return;
         m_pipeline->bind(commandBuffer, extent2D);
@@ -143,6 +159,7 @@ namespace vulkan {
         const auto applyUniform = m_values.getApplyUniform();
 
         switch (m_type) {
+            default:
             case ShaderType::NONE:
                 return;
             case ShaderType::MAIN: {
@@ -163,7 +180,7 @@ namespace vulkan {
         }
     }
 
-    Shader* loadShader(std::string vertexFile, std::string fragmentFile, ShaderType type) {
+    Shader* loadShader(const std::filesystem::path &vertexFile, const std::filesystem::path &fragmentFile, ShaderType type) {
         if (type == ShaderType::NONE)
             return nullptr;
 
diff --git a/src/graphics-vk/device/Shader.h b/src/graphics-vk/device/Shader.h
index 8e28e5a27..39d89efd0 100644
--- a/src/graphics-vk/device/Shader.h
+++ b/src/graphics-vk/device/Shader.h
@@ -48,6 +48,7 @@ namespace vulkan {
         void uniform3f(std::string name, glm::vec3 xyz) override;
 
         void pushConstant(const DynamicConstants& constants) override;
+        void pushConatnt(const ProjectionViewConstant& constant) override;
 
         void use(VkCommandBuffer commandBuffer, VkExtent2D extent2D) override;
         
@@ -56,7 +57,7 @@ namespace vulkan {
         void updateUniform();
     };
 
-    Shader *loadShader(std::string vertexFile, std::string fragmentFile, ShaderType type);
+    Shader *loadShader(const std::filesystem::path &vertexFile, const std::filesystem::path &fragmentFile, ShaderType type);
 
 } // vulkan
 
diff --git a/src/graphics-vk/texture/Image2d.cpp b/src/graphics-vk/texture/Image2d.cpp
index 9ef10022b..8c6b17161 100644
--- a/src/graphics-vk/texture/Image2d.cpp
+++ b/src/graphics-vk/texture/Image2d.cpp
@@ -146,6 +146,7 @@ void Image2d::bind() {
     switch (type) {
         case ShaderType::MAIN:
         case ShaderType::UI:
+        case ShaderType::UI3D:
             samplerWrite.dstBinding = 0;
             break;
         case ShaderType::NONE:
diff --git a/src/graphics-vk/uniforms/ProjectionViewConstant.h b/src/graphics-vk/uniforms/ProjectionViewConstant.h
new file mode 100644
index 000000000..22772929c
--- /dev/null
+++ b/src/graphics-vk/uniforms/ProjectionViewConstant.h
@@ -0,0 +1,16 @@
+//
+// Created by chelovek on 12/15/23.
+//
+
+#ifndef PROJECTIONVIEWCONSTANT_H
+#define PROJECTIONVIEWCONSTANT_H
+
+#include <glm/glm.hpp>
+
+struct ProjectionViewConstant {
+    glm::mat4 projView;
+};
+
+
+
+#endif //PROJECTIONVIEWCONSTANT_H
diff --git a/src/graphics/Batch3D.cpp b/src/graphics/Batch3D.cpp
index 1fda4c65d..e0397b32b 100644
--- a/src/graphics/Batch3D.cpp
+++ b/src/graphics/Batch3D.cpp
@@ -102,7 +102,7 @@ void Batch3D::face(const vec3& coord, float w, float h,
 		   tint.r, tint.g, tint.b, tint.a);
 }
 
-void Batch3D::texture(Texture* new_texture){
+void Batch3D::texture(ITexture* new_texture){
 	if (_texture == new_texture)
 		return;
 	flush();
diff --git a/src/graphics/Batch3D.h b/src/graphics/Batch3D.h
index 5de47c84f..ec07edfb9 100644
--- a/src/graphics/Batch3D.h
+++ b/src/graphics/Batch3D.h
@@ -6,8 +6,8 @@
 #include "UVRegion.h"
 #include "../typedefs.h"
 
+class ITexture;
 class Mesh;
-class Texture;
 
 class Batch3D {
 	float* buffer;
@@ -16,8 +16,8 @@ class Batch3D {
 	Mesh* mesh;
 	size_t index;
 
-	Texture* blank;
-	Texture* _texture;
+	ITexture* blank;
+	ITexture* _texture;
 
 	void vertex(float x, float y, float z,
 				float u, float v,
@@ -39,7 +39,7 @@ class Batch3D {
 	~Batch3D();
 
 	void begin();
-	void texture(Texture* texture);
+	void texture(ITexture* texture);
 	void sprite(glm::vec3 pos, glm::vec3 up, glm::vec3 right, float w, float h, const UVRegion& uv, glm::vec4 tint);
 	void xSprite(float w, float h, const UVRegion& uv, const glm::vec4 tint, bool shading=true);
 	void blockCube(const glm::vec3 size, const UVRegion(&texfaces)[6], const glm::vec4 tint, bool shading=true);