diff --git a/.github/workflows/cmake_lnx.yml b/.github/workflows/cmake_lnx.yml
index 913905a..8d007ef 100644
--- a/.github/workflows/cmake_lnx.yml
+++ b/.github/workflows/cmake_lnx.yml
@@ -27,6 +27,21 @@ jobs:
         submodules: true
         fetch-depth: 0
 
+    - name: installing cmake 4
+      run: |
+        sudo apt-get remove --purge -y cmake
+        wget https://github.com/Kitware/CMake/releases/download/v4.0.3/cmake-4.0.3-linux-x86_64.sh
+        chmod +x cmake-4.0.3-linux-x86_64.sh
+        sudo ./cmake-4.0.3-linux-x86_64.sh --skip-license --prefix=/usr/local
+    - name: downloading latest slang
+      run: |
+        url=$(curl -s https://api.github.com/repos/shader-slang/slang/releases/latest | jq -r '.assets[] | select(.name | endswith("linux-x86_64.tar.gz")) | .browser_download_url')
+        mkdir -p ~/slang && curl -L "$url" | tar -xz -C ~/slang
+        ls ~/slang
+        ~/slang/bin/slangc -v
+        sudo cp -v -f ~/slang/bin/* /usr/local/bin
+        sudo cp -v -f ~/slang/lib/* /usr/local/lib
+        sudo ldconfig
     - name: update submodules
       run: |
         git submodule update --init --recursive
@@ -43,22 +58,52 @@ jobs:
         mv $(ls | head -n 1)/x86_64/* .
         rm -r $(ls | head -n 1)
         export VULKAN_SDK=/home/runner/vulk
-        export PATH=$VULKAN_SDK/bin:$PATH
-        export LD_LIBRARY_PATH=$VULKAN_SDK/lib:$LD_LIBRARY_PATH
+        export PATH=~/slang/bin:$VULKAN_SDK/bin:$PATH
+        export LD_LIBRARY_PATH=~/slang/lib:$VULKAN_SDK/lib:$LD_LIBRARY_PATH
         export VK_ICD_FILENAMES=$VULKAN_SDK/etc/vulkan/icd.d
         export VK_LAYER_PATH=$VULKAN_SDK/etc/vulkan/explicit_layer.d
         echo VULKAN_SDK=/home/runner/vulk >> $GITHUB_ENV
-        echo PATH=$VULKAN_SDK/bin:$PATH >> $GITHUB_ENV
-        echo LD_LIBRARY_PATH=$VULKAN_SDK/lib:$LD_LIBRARY_PATH >> $GITHUB_ENV
+        echo PATH=~/slang/bin:$VULKAN_SDK/bin:$PATH >> $GITHUB_ENV
         echo VK_ICD_FILENAMES=$VULKAN_SDK/etc/vulkan/icd.d >> $GITHUB_ENV
         echo VK_LAYER_PATH=$VULKAN_SDK/etc/vulkan/explicit_layer.d >> $GITHUB_ENV
-        echo LD_LIBRARY_PATH=/home/runner/work/rview2/rview2/lib:$LD_LIBRARY_PATH >> $GITHUB_ENV
+        echo LD_LIBRARY_PATH=~/slang/lib:/home/runner/work/rview2/rview2/lib:$VULKAN_SDK/lib:$LD_LIBRARY_PATH >> $GITHUB_ENV
         sudo ldconfig
-    - name: verifying vulkan
+    # - name: downloading latest slang AGAIN
+    #   run: |
+    #     url=$(curl -s https://api.github.com/repos/shader-slang/slang/releases/latest | jq -r '.assets[] | select(.name | endswith("linux-x86_64.tar.gz")) | .browser_download_url')
+    #     mkdir -p ~/slang && curl -L "$url" | tar -xz -C ~/slang
+    #     ls ~/slang
+    #     ~/slang/bin/slangc -v
+    # i give up,..
+    - name: verifying vulkan & slang AGAIN!!
       run: |
+        url=$(curl -s https://api.github.com/repos/shader-slang/slang/releases/latest | jq -r '.assets[] | select(.name | endswith("linux-x86_64.tar.gz")) | .browser_download_url')
+        mkdir -p ~/slang2 && curl -L "$url" | tar -xz -C ~/slang2
+        ls ~/slang2
+        ~/slang2/bin/slangc -v
+        ~/slang/bin/slangc -v
         mkdir -p $VULKAN_SDK/bin
-        cp -n /home/runner/vulk/bin/slangc $VULKAN_SDK/bin/slangc
+        sudo rm -rf $VULKAN_SDK/bin/slangc
+        sudo cp -v -f ~/slang/bin/* $VULKAN_SDK/bin
+        sudo cp -v -f ~/slang/bin/slangc $VULKAN_SDK/bin/slangc
+        sudo cp -v -f ~/slang2/bin/* $VULKAN_SDK/bin
+        sudo cp -v -f ~/slang2/bin/slangc $VULKAN_SDK/bin/slangc
+        echo "\n"
         $VULKAN_SDK/bin/slangc -v
+        echo "\n"
+        slangc -v
+        echo "\n"
+        ~/slang/bin/slangc -v
+        ~/slang2/bin/slangc -v
+        echo "\n"
+        which slangc
+        echo "\n"
+        ls -lah ~/slang/bin/slangc
+        ls -lah ~/slang2/bin/slangc
+        ls -lah $VULKAN_SDK/bin/slangc
+        md5sum ~/slang2/bin/slangc
+        md5sum ~/slang/bin/slangc
+        md5sum $VULKAN_SDK/bin/slangc
     - name: downloading resources
       run: |
         mkdir /home/runner/work/rview2/rview2/resources
diff --git a/.github/workflows/cmake_win.yml b/.github/workflows/cmake_win.yml
index 2963daf..2060c99 100644
--- a/.github/workflows/cmake_win.yml
+++ b/.github/workflows/cmake_win.yml
@@ -42,6 +42,18 @@ jobs:
         # curl -L "https://github.com/openssl/openssl/releases/download/openssl-3.5.0/openssl-3.5.0.tar.gz" | tar -xz     #doesnt work on runner
         pwsh -c 'curl -L "https://github.com/openssl/openssl/releases/download/openssl-3.5.0/openssl-3.5.0.tar.gz" -o ossl.tar.gz'
         tar -xvzf ossl.tar.gz
+        $url = curl -L "https://api.github.com/repos/shader-slang/slang/releases/latest" | ConvertFrom-Json | ForEach-Object { $_.assets } | Where-Object { $_.name -like "*windows-x86_64.tar.gz" } | Select-Object -ExpandProperty browser_download_url
+        mkdir D:/a/slang
+        cd D:/a/slang
+        curl -L $url -o slang.tar.gz
+        ls
+        pwd
+        7z x slang.tar.gz -aoa
+        ls
+        7z x slang.tar -aoa
+        ls
+        # rm slang.tar.gz
+        # rm slang.tar
     - shell: msys2 {0}
       run: |
         cd /d/a/rview2/rview2/openssl-3.5.0
@@ -64,20 +76,19 @@ jobs:
         ./sdk.exe --root D:/a/vulk --accept-licenses --default-answer --confirm-command install
         rm sdk.exe
         $env:VULKAN_SDK="D:/a/vulk"
-        $env:PATH="$env:VULKAN_SDK/bin;$env:PATH"
-        $env:LD_LIBRARY_PATH="$env:VULKAN_SDK/lib;$env:LD_LIBRARY_PATH"
+        $env:SLANG_SDK="D:/a/slang"
+        $env:PATH="$env:SLANG_SDK/bin;$env:VULKAN_SDK/bin;$env:PATH"
+        $env:LD_LIBRARY_PATH="D:/a/work/rview2/rview2/lib;$env:SLANG_SDK/lib;$env:VULKAN_SDK/lib;$env:LD_LIBRARY_PATH"
         $env:VK_ICD_FILENAMES="$env:VULKAN_SDK/etc/vulkan/icd.d"
         $env:VK_LAYER_PATH="$env:VULKAN_SDK/etc/vulkan/explicit_layer.d"
-        $env:LD_LIBRARY_PATH="D:/a/work/rview2/rview2/lib;$env:LD_LIBRARY_PATH"
         echo VULKAN_SDK=$env:VULKAN_SDK  | tee -a $env:GITHUB_ENV
         echo PATH=$env:PATH  | tee -a $env:GITHUB_ENV
         echo LD_LIBRARY_PATH=$env:LD_LIBRARY_PATH  | tee -a $env:GITHUB_ENV
         echo VK_ICD_FILENAMES=$env:VULKAN_SDK/etc/vulkan/icd.d  | tee -a $env:GITHUB_ENV
         echo VK_LAYER_PATH=$env:VULKAN_SDK/etc/vulkan/explicit_layer.d  | tee -a $env:GITHUB_ENV
-        echo LD_LIBRARY_PATH=$env:LD_LIBRARY_PATH  | tee -a $env:GITHUB_ENV
     - name: verifying vulkan
       run: |
-        powershell -c "$env:VULKAN_SDK/bin/glslc --version"
+        pwsh -c "$env:VULKAN_SDK/bin/glslc --version"
         echo $VULKAN_SDK
         ls -r $VULKAN_SDK
     - name: downloading resources
diff --git a/.gitignore b/.gitignore
index 0c02eab..74c6860 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 build
 build_static
+build_corrupted
 cmake_more_cache
 resources
 vsbuild
@@ -17,4 +18,3 @@ dist
 .vscode
 *.swp
 out
-# .gitmodules
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1ab49c9..9625228 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,10 +1,10 @@
-cmake_minimum_required(VERSION 3.31)
+cmake_minimum_required(VERSION 4.0)
 project(rview2 LANGUAGES CXX)
 
 
 include(ExternalProject)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
@@ -173,36 +173,55 @@ endif()
 file(GLOB shaders ${PROJECT_BINARY_DIR}/shaders/*)
 list(LENGTH shaders shader_len)
 
-#wip
-file(GLOB_RECURSE GLSL_SOURCE_FILES
-    # "${PROJECT_SOURCE_DIR}/shaders/*.frag"
-    # "${PROJECT_SOURCE_DIR}/shaders/*.vert"
-    "${PROJECT_SOURCE_DIR}/shaders/*.slang"
-    )
-  foreach(GLSL ${GLSL_SOURCE_FILES})
-    # get_filename_component(GLSL_EXT "${GLSL}" EXT)
-    # if(GLSL_EXT STREQUAL ".frag")
-    #     set(SLANG_STAGE "fragment")
-    # elseif(GLSL_EXT STREQUAL ".vert")
-    #     set(SLANG_STAGE "vertex")
-    # elseif(GLSL_EXT STREQUAL ".comp")
-    #     set(SLANG_STAGE "compute")
-    # endif()
-    file(TO_CMAKE_PATH "${GLSL}" GLSL_NATIVE)
-    cmake_path(GET GLSL_NATIVE FILENAME SPIRV_NAME)
-      set(VXSPIRV "${PROJECT_BINARY_DIR}/shaders/${SPIRV_NAME}.vx.spv")
-      set(PXSPIRV "${PROJECT_BINARY_DIR}/shaders/${SPIRV_NAME}.px.spv")
+# #wip
+# file(GLOB_RECURSE GLSL_SOURCE_FILES
+#     # "${PROJECT_SOURCE_DIR}/shaders/*.frag"
+#     # "${PROJECT_SOURCE_DIR}/shaders/*.vert"
+#     "${PROJECT_SOURCE_DIR}/shaders/*.slang"
+#     )
+#   foreach(GLSL ${GLSL_SOURCE_FILES})
+#     # get_filename_component(GLSL_EXT "${GLSL}" EXT)
+#     # if(GLSL_EXT STREQUAL ".frag")
+#     #     set(SLANG_STAGE "fragment")
+#     # elseif(GLSL_EXT STREQUAL ".vert")
+#     #     set(SLANG_STAGE "vertex")
+#     # elseif(GLSL_EXT STREQUAL ".comp")
+#     #     set(SLANG_STAGE "compute")
+#     # endif()
+#     file(TO_CMAKE_PATH "${GLSL}" GLSL_NATIVE)
+#     cmake_path(GET GLSL_NATIVE FILENAME SPIRV_NAME)
+#       set(VXSPIRV "${PROJECT_BINARY_DIR}/shaders/${SPIRV_NAME}.vx.spv")
+#       set(PXSPIRV "${PROJECT_BINARY_DIR}/shaders/${SPIRV_NAME}.px.spv")
+#       add_custom_command(
+#         OUTPUT ${VXSPIRV}
+#         OUTPUT ${PXSPIRV}
+#         COMMAND ${CMAKE_COMMAND} -E make_directory "${PROJECT_BINARY_DIR}/shaders"
+#         # COMMAND ${SHELL_CMD} -c "$ENV{VULKAN_SDK}/bin/slangc -default-downstream-compiler glsl glslang -lang glsl -entry main $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage ${SLANG_STAGE} -matrix-layout-row-major -target spirv -capability SPIRV_1_6 ${GLSL_NATIVE} -o ${SPIRV}"        DEPENDS ${GLSL_NATIVE}
+#         COMMAND ${SHELL_CMD} -c "$ENV{VULKAN_SDK}/bin/slangc -entry vxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage vertex -target spirv -capability SPIRV_1_6 ${GLSL_NATIVE} -o ${VXSPIRV}"        DEPENDS ${GLSL_NATIVE}
+#         COMMAND ${SHELL_CMD} -c "$ENV{VULKAN_SDK}/bin/slangc -entry pxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage pixel -target spirv -capability SPIRV_1_6 ${GLSL_NATIVE} -o ${PXSPIRV}"        DEPENDS ${GLSL_NATIVE}
+#         )
+#       list(APPEND SPIRV_BINARY_FILES ${VXSPIRV})
+#       list(APPEND SPIRV_BINARY_FILES ${PXSPIRV})
+#   endforeach()
+#     set_source_files_properties(${SPIRV_BINARY_FILES} PROPERTIES GENERATED TRUE)
+#   add_custom_target(shaders ALL DEPENDS ${SPIRV_BINARY_FILES})
+#   add_dependencies(rview2 shaders)
+
+#manually adding shaders for now
       add_custom_command(
-        OUTPUT ${VXSPIRV}
-        OUTPUT ${PXSPIRV}
+        OUTPUT ${PROJECT_BINARY_DIR}/shaders/vx.spv ${PROJECT_BINARY_DIR}/shaders/px.spv ${PROJECT_BINARY_DIR}/shaders/cx.spv ${PROJECT_BINARY_DIR}/shaders/pvx.spv ${PROJECT_BINARY_DIR}/shaders/ppx.spv ${PROJECT_BINARY_DIR}/shaders/pcx.spv
         COMMAND ${CMAKE_COMMAND} -E make_directory "${PROJECT_BINARY_DIR}/shaders"
-        # COMMAND ${SHELL_CMD} -c "$ENV{VULKAN_SDK}/bin/slangc -default-downstream-compiler glsl glslang -lang glsl -entry main $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage ${SLANG_STAGE} -matrix-layout-row-major -target spirv -capability SPIRV_1_6 ${GLSL_NATIVE} -o ${SPIRV}"        DEPENDS ${GLSL_NATIVE}
-        COMMAND ${SHELL_CMD} -c "$ENV{VULKAN_SDK}/bin/slangc -entry vxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage vertex -target spirv -capability SPIRV_1_6 ${GLSL_NATIVE} -o ${VXSPIRV}"        DEPENDS ${GLSL_NATIVE}
-        COMMAND ${SHELL_CMD} -c "$ENV{VULKAN_SDK}/bin/slangc -entry pxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage pixel -target spirv -capability SPIRV_1_6 ${GLSL_NATIVE} -o ${PXSPIRV}"        DEPENDS ${GLSL_NATIVE}
+        COMMAND ${SHELL_CMD} -c "slangc -entry vxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage vertex -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/gen.slang -o ${PROJECT_BINARY_DIR}/shaders/vx.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/gen.slang
+        COMMAND ${SHELL_CMD} -c "slangc -entry pxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage pixel -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/gen.slang -o ${PROJECT_BINARY_DIR}/shaders/px.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/gen.slang
+        # COMMAND ${SHELL_CMD} -c "$ENV{VULKAN_SD/bin/slangc -entry cxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage compute -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/gen.slang -o ${PROJECT_BINARY_DIR}/shaders/cx.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/gen.slang
+        COMMAND ${SHELL_CMD} -c "slangc -entry vxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage vertex -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/static.slang -o ${PROJECT_BINARY_DIR}/shaders/svx.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/static.slang
+        COMMAND ${SHELL_CMD} -c "slangc -entry pxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage pixel -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/static.slang -o ${PROJECT_BINARY_DIR}/shaders/spx.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/static.slang
+        # COMMAND ${SHELL_CMD} -c "$ENV{VULKAN_SD/bin/slangc -entry cxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage compute -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/static.slang -o ${PROJECT_BINARY_DIR}/shaders/scx.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/static.slang
+        COMMAND ${SHELL_CMD} -c "slangc -entry vxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage vertex -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/particle.slang -o ${PROJECT_BINARY_DIR}/shaders/pvx.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/particle.slang
+        COMMAND ${SHELL_CMD} -c "slangc -entry pxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage pixel -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/particle.slang -o ${PROJECT_BINARY_DIR}/shaders/ppx.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/particle.slang
+        COMMAND ${SHELL_CMD} -c "slangc -entry cxmain $<$<CONFIG:Debug>:-g> $<$<CONFIG:Release>:-O3> -stage compute -target spirv -capability SPIRV_1_6 ${PROJECT_SOURCE_DIR}/shaders/particle.slang -o ${PROJECT_BINARY_DIR}/shaders/pcx.spv" DEPENDS ${PROJECT_SOURCE_DIR}/shaders/particle.slang
         )
-      list(APPEND SPIRV_BINARY_FILES ${VXSPIRV})
-      list(APPEND SPIRV_BINARY_FILES ${PXSPIRV})
-  endforeach()
+      list(APPEND SPIRV_BINARY_FILES ${PROJECT_BINARY_DIR}/shaders/vx.spv ${PROJECT_BINARY_DIR}/shaders/px.spv ${PROJECT_BINARY_DIR}/shaders/cx.spv ${PROJECT_BINARY_DIR}/shaders/pvx.spv ${PROJECT_BINARY_DIR}/shaders/ppx.spv ${PROJECT_BINARY_DIR}/shaders/pcx.spv)
     set_source_files_properties(${SPIRV_BINARY_FILES} PROPERTIES GENERATED TRUE)
   add_custom_target(shaders ALL DEPENDS ${SPIRV_BINARY_FILES})
   add_dependencies(rview2 shaders)
@@ -311,7 +330,6 @@ target_link_libraries(rview2
         absl_log_internal_structured_proto
         absl_log_severity
         absl_log_sink
-        absl_low_level_hash
         absl_malloc_internal
         absl_periodic_sampler
         absl_poison
diff --git a/include/buffer/ssbo.hpp b/include/buffer/ssbo.hpp
new file mode 100644
index 0000000..96f6625
--- /dev/null
+++ b/include/buffer/ssbo.hpp
@@ -0,0 +1,94 @@
+#pragma once
+#include <glm/glm.hpp>
+#include <vector>
+#include <vulkan/vulkan.h>
+
+#include "core/rvk.hpp"
+
+namespace ssbo {
+static inline bool init(rvk &objs, ssbodata &ssboData, size_t buffersize) {
+
+	VkBufferCreateInfo bufferInfo{};
+	bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+	bufferInfo.size = buffersize;
+	bufferInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+	VmaAllocationCreateInfo vmaAllocInfo{};
+	vmaAllocInfo.usage = VMA_MEMORY_USAGE_AUTO;
+	vmaAllocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
+
+	if (vmaCreateBuffer(objs.alloc, &bufferInfo, &vmaAllocInfo, &ssboData.buffer, &ssboData.alloc, nullptr) !=
+	        VK_SUCCESS) {
+		return false;
+	}
+
+
+
+
+	VkDescriptorSetAllocateInfo descriptorAllocateInfo{};
+	descriptorAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+	descriptorAllocateInfo.descriptorPool = objs.dpools[rvk::idxinitpool];
+	descriptorAllocateInfo.descriptorSetCount = 1;
+	descriptorAllocateInfo.pSetLayouts = &rvk::ssbolayout;
+
+	if (vkAllocateDescriptorSets(objs.vkdevice.device, &descriptorAllocateInfo, &ssboData.dset) != VK_SUCCESS) {
+		return false;
+	}
+
+	VkDescriptorBufferInfo ssboInfo{};
+	ssboInfo.buffer = ssboData.buffer;
+	ssboInfo.offset = 0;
+	ssboInfo.range = buffersize;
+
+	VkWriteDescriptorSet writeDescriptorSet{};
+	writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+	writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	writeDescriptorSet.dstSet = ssboData.dset;
+	writeDescriptorSet.dstBinding = 0;
+	writeDescriptorSet.descriptorCount = 1;
+	writeDescriptorSet.pBufferInfo = &ssboInfo;
+
+	vkUpdateDescriptorSets(objs.vkdevice.device, 1, &writeDescriptorSet, 0, nullptr);
+
+	ssboData.size = buffersize;
+
+	return true;
+}
+
+static inline bool createlayout(rvk &core,VkDescriptorSetLayout& dlayout){
+	VkDescriptorSetLayoutBinding ssboBind{};
+	ssboBind.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	ssboBind.binding = 0;
+	ssboBind.descriptorCount = 1;
+	ssboBind.pImmutableSamplers = nullptr;
+	ssboBind.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+
+	VkDescriptorSetLayoutCreateInfo ssboCreateInfo{};
+	ssboCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+	ssboCreateInfo.bindingCount = 1;
+	ssboCreateInfo.pBindings = &ssboBind;
+
+	if (vkCreateDescriptorSetLayout(core.vkdevice.device, &ssboCreateInfo, nullptr, &dlayout) != VK_SUCCESS) {
+		return false;
+	}
+	return true;
+}
+// template <typename T>
+// concept vectoradjacent = requires(T x){
+//   {x.size()} -> std::convertible_to<size_t>;
+//   {x.data()};
+// };
+template <typename T>
+static inline void upload(const rvk &objs, const ssbodata &ssbodata, const std::vector<T> &mats) {
+	if (mats.size() <= 0) {
+		return;
+	}
+	void *data;
+	vmaMapMemory(objs.alloc, ssbodata.alloc, &data);
+	std::memcpy(data, mats.data(), ssbodata.size);
+	vmaUnmapMemory(objs.alloc, ssbodata.alloc);
+}
+static inline void cleanup(rvk &objs, ssbodata &ssbodata) {
+	vmaDestroyBuffer(objs.alloc, ssbodata.buffer, ssbodata.alloc);
+}
+};
diff --git a/include/commandbuffer.hpp b/include/commandbuffer.hpp
deleted file mode 100644
index 2502c71..0000000
--- a/include/commandbuffer.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-#include "vkobjs.hpp"
-#include <vulkan/vulkan.h>
-class commandbuffer {
-public:
-	static bool init(vkobjs &rdata, VkCommandPool &vkpool, VkCommandBuffer &incommandbuffer);
-	static void cleanup(vkobjs &rdata, VkCommandPool &vkpool, VkCommandBuffer &incommandbuffer);
-};
\ No newline at end of file
diff --git a/include/commandpool.hpp b/include/commandpool.hpp
deleted file mode 100644
index 0d55988..0000000
--- a/include/commandpool.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-#include "vkobjs.hpp"
-#include <vulkan/vulkan.h>
-class commandpool {
-public:
-	static bool init(vkobjs &rdata, VkCommandPool &vkpool);
-	static void cleanup(vkobjs &rdata, VkCommandPool &vkpool);
-};
\ No newline at end of file
diff --git a/include/vkobjs.hpp b/include/core/rvk.hpp
similarity index 60%
rename from include/vkobjs.hpp
rename to include/core/rvk.hpp
index f3db52b..91e680a 100644
--- a/include/vkobjs.hpp
+++ b/include/core/rvk.hpp
@@ -8,6 +8,10 @@
 #include <vector>
 #include <vk_mem_alloc.h>
 #include <vulkan/vulkan.h>
+#include <span>
+
+
+
 
 enum class skinningmode { linear = 0, dualquat };
 enum class replaydirection { forward = 0, backward };
@@ -20,12 +24,6 @@ struct texdata {
 	VkSampler imgsampler = VK_NULL_HANDLE;
 	VmaAllocation alloc = nullptr;
 };
-struct texdatapls {
-	VkDescriptorPool dpool = VK_NULL_HANDLE;
-	VkDescriptorSetLayout dlayout = VK_NULL_HANDLE;
-	VkDescriptorSet dset = VK_NULL_HANDLE;
-};
-
 struct vbodata {
 
 	size_t size{0};
@@ -45,13 +43,11 @@ struct ebodata {
 	VmaAllocation salloc = nullptr;
 };
 
-struct ubodata {
+struct ubodata {                                                                                                                                                              
 	size_t size{0};
 	VkBuffer buffer = VK_NULL_HANDLE;
 	VmaAllocation alloc = nullptr;
 
-	VkDescriptorPool dpool = VK_NULL_HANDLE;
-	VkDescriptorSetLayout dlayout = VK_NULL_HANDLE;
 	VkDescriptorSet dset = VK_NULL_HANDLE;
 };
 
@@ -60,23 +56,20 @@ struct ssbodata {
 	VkBuffer buffer = VK_NULL_HANDLE;
 	VmaAllocation alloc = nullptr;
 
-	VkDescriptorPool dpool = VK_NULL_HANDLE;
-	VkDescriptorSetLayout dlayout = VK_NULL_HANDLE;
 	VkDescriptorSet dset = VK_NULL_HANDLE;
 };
-
 struct vkpushconstants {
 	int stride;
 	unsigned int texidx;
 	float t{0.0f};
 };
 
-struct vkobjs {
+struct rvk {
 
 	inline static const std::shared_ptr<std::shared_mutex> mtx2{std::make_shared<std::shared_mutex>()};
 
 	SDL_Window *wind = nullptr;
-	
+
 	const SDL_DisplayMode *rdmode;
 	bool fullscreen{false};
 	int width{0};
@@ -118,9 +111,15 @@ struct vkobjs {
 	vkb::Device vkdevice{};
 	vkb::Swapchain schain{};
 
+	
+	
+	inline static std::shared_ptr<VkDescriptorSetLayout> texlayout = std::make_shared<VkDescriptorSetLayout>();
+	inline static VkDescriptorSetLayout ubolayout = VK_NULL_HANDLE;
+	inline static VkDescriptorSetLayout ssbolayout = VK_NULL_HANDLE;
+
 	std::vector<VkImage> schainimgs;
 	std::vector<VkImageView> schainimgviews;
-	std::vector<VkFramebuffer> fbuffers;
+	std::vector<VkFramebuffer> fbuffers = {VK_NULL_HANDLE,VK_NULL_HANDLE,VK_NULL_HANDLE};
 
 	VkQueue graphicsQ = VK_NULL_HANDLE;
 	VkQueue presentQ = VK_NULL_HANDLE;
@@ -138,20 +137,48 @@ struct vkobjs {
 
 	VkRenderPass rdrenderpass = VK_NULL_HANDLE;
 
-	std::vector<VkCommandPool> cpools = {VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE};
-	std::vector<VkCommandBuffer> cbuffers = {VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE};
+	std::array<VkCommandPool,3> cpools_graphics = {VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE};
+	std::array<VkCommandPool,1> cpools_compute = {VK_NULL_HANDLE};
+	std::array<VkCommandBuffer,3> cbuffers_graphics = {VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE};
+	std::array<VkCommandBuffer,1> cbuffers_compute = {VK_NULL_HANDLE};
 
 	VkSemaphore presentsemaphore = VK_NULL_HANDLE;
 	VkSemaphore rendersemaphore = VK_NULL_HANDLE;
 	VkFence renderfence = VK_NULL_HANDLE;
 	VkFence uploadfence = VK_NULL_HANDLE;
-
-	VkDescriptorPool imguidpool = VK_NULL_HANDLE;
+	
+	inline static constexpr size_t idxinitpool{0};
+	inline static constexpr size_t idximguipool{1};
+	inline static constexpr size_t idxruntimepool0{2};
+	inline static constexpr size_t idxruntimepool1{3};
+	inline static constexpr size_t idxruntimepool2{4};
+	inline static constexpr size_t idxruntimepool3{5};
+	std::array<VkDescriptorPool,6> dpools = {VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE,VK_NULL_HANDLE,VK_NULL_HANDLE,VK_NULL_HANDLE};
 };
 
 struct vkgltfobjs {
 	std::vector<std::vector<std::vector<vbodata>>> vbos{};
 	std::vector<std::vector<ebodata>> ebos{};
 	std::vector<texdata> texs{};
-	texdatapls texpls{};
+	VkDescriptorSet dset = VK_NULL_HANDLE;
+};
+namespace rpool {
+static inline bool create(const std::span<VkDescriptorPoolSize>& pools,const VkDevice& dev,VkDescriptorPool* dpool) {
+	VkDescriptorPoolCreateInfo descriptorPool{};
+	descriptorPool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+	descriptorPool.poolSizeCount = pools.size();
+	descriptorPool.pPoolSizes = pools.data();
+	descriptorPool.maxSets = 1024; //not sure
+
+	return vkCreateDescriptorPool(dev, &descriptorPool, nullptr, dpool) == VK_SUCCESS;
+}
+static inline void destroy(const VkDevice& dev,VkDescriptorPool dpool) {
+	vkDestroyDescriptorPool(dev, dpool, nullptr);
+}
 };
+namespace rbuffer {
+static inline bool create(const VkDevice& dev,VmaAllocator alloc,std::vector<VkBufferCreateInfo> binfos,std::vector<VkBuffer> buffs) {
+	// for()
+	return true;
+}
+};
\ No newline at end of file
diff --git a/include/exp/particle.hpp b/include/exp/particle.hpp
new file mode 100644
index 0000000..33c261c
--- /dev/null
+++ b/include/exp/particle.hpp
@@ -0,0 +1,442 @@
+#pragma once
+#include "core/rvk.hpp"
+#include "vkshader.hpp"
+#include <array>
+#include <random>
+
+struct P {
+	glm::vec2 position;
+	glm::vec2 velocity;
+	glm::vec4 color;
+};
+namespace particle {
+
+static VkPipeline gpline;
+static VkPipeline cpline{};
+static VkPipelineLayout cplayout{};
+static VkPipelineLayout gplayout{};
+static VkDescriptorSetLayout cdlayout{};
+static VkDescriptorSet cdset{};
+
+static std::vector<P> Ps(7999);
+
+static std::vector<VkSemaphore> computeFinishedSemaphores(1);
+static std::vector<VkFence> computeInFlightFences(1);
+
+
+
+static std::vector<std::pair<VkBuffer, VmaAllocation>> ssbobuffsnallocs(1);
+
+
+static VkDescriptorPool dpool{VK_NULL_HANDLE};
+
+static inline void createSyncObjects(rvk &objs) {
+
+	// need inflight fences when using more than 1 for both queues
+
+	VkSemaphoreCreateInfo semaphoreInfo{};
+	semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+
+	VkFenceCreateInfo fenceInfo{};
+	fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+
+	if (vkCreateSemaphore(objs.vkdevice.device, &semaphoreInfo, nullptr, &computeFinishedSemaphores.at(0)) !=
+	        VK_SUCCESS ||
+	        vkCreateFence(objs.vkdevice.device, &fenceInfo, nullptr, &computeInFlightFences.at(0)) != VK_SUCCESS) {
+		throw std::runtime_error("failed to create compute synchronization objects for a frame!");
+	}
+}
+
+static inline bool createeverything(rvk &objs) {
+
+	// random
+	std::default_random_engine randomengine((unsigned)time(nullptr));
+	std::uniform_real_distribution<float> randomfloatdistrib(0.0f, 1.0f);
+
+	// particles
+	for (auto &p : Ps) {
+		float r = 0.25 * sqrt(randomfloatdistrib(randomengine));
+		float theta = randomfloatdistrib(randomengine) * 2.0f * 3.14f;
+		float x = r * cos(theta) * 600 / 900;
+		float y = r * sin(theta);
+		p.position = glm::vec2(x, y);
+		p.velocity = glm::normalize(glm::vec2(x, y)) * 0.00025f;
+		p.color = glm::vec4(randomfloatdistrib(randomengine), randomfloatdistrib(randomengine),
+		                    randomfloatdistrib(randomengine), 1.0f);
+		// p.color = glm::vec4(0.6,0.1f,0.5f,1.0f);
+		// p.velocity = glm::vec2(0.002f,0.002);
+		// p.position = glm::vec2(-1.0f);
+	}
+
+	// create buffers
+	size_t stagingbuffersize{sizeof(P) * Ps.size()};
+	VkBuffer stagingbuffer = VK_NULL_HANDLE;
+	VmaAllocation stagingbufferalloc = nullptr;
+
+	VkBufferCreateInfo bufferInfo{};
+	bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+	bufferInfo.size = stagingbuffersize;
+	bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+	VmaAllocationCreateInfo vmaAllocInfo{};
+	vmaAllocInfo.usage = VMA_MEMORY_USAGE_AUTO;				       // auto
+	vmaAllocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT; // auto
+
+	if (vmaCreateBuffer(objs.alloc, &bufferInfo, &vmaAllocInfo, &stagingbuffer, &stagingbufferalloc, nullptr) !=
+	        VK_SUCCESS) {
+		return false;
+	}
+
+	void *data;
+	vmaMapMemory(objs.alloc, stagingbufferalloc, &data);
+	memcpy(data, Ps.data(), stagingbuffersize);
+	vmaUnmapMemory(objs.alloc, stagingbufferalloc);
+
+
+	for (auto &[x, y] : ssbobuffsnallocs) {
+		VkBufferCreateInfo bufferInfo2{};
+		bufferInfo2.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+		bufferInfo2.size = stagingbuffersize;
+		bufferInfo2.usage =
+		    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+		VmaAllocationCreateInfo vmaAllocInfo2{};
+		vmaAllocInfo2.usage = VMA_MEMORY_USAGE_AUTO;				  // auto
+		vmaAllocInfo2.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT; // auto
+
+		if (vmaCreateBuffer(objs.alloc, &bufferInfo2, &vmaAllocInfo2, &x, &y, nullptr) != VK_SUCCESS) {
+			return false;
+		}
+
+		VkBufferCopy2 copyRegion2 = {
+			.sType = VK_STRUCTURE_TYPE_BUFFER_COPY_2,
+			.pNext = NULL,
+			.srcOffset = 0,
+			.dstOffset = 0,
+			.size = stagingbuffersize,
+		};
+		VkCopyBufferInfo2 copyInfo = {
+			.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2,
+			.pNext = NULL,
+			.srcBuffer = stagingbuffer,
+			.dstBuffer = x,
+			.regionCount = 1,
+			.pRegions = &copyRegion2,
+		};
+
+		// uploading buffer
+		VkCommandBufferBeginInfo beginInfo{};
+		beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+		beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+		vkResetCommandBuffer(objs.cbuffers_graphics.at(2), 0);
+		vkBeginCommandBuffer(objs.cbuffers_graphics.at(2), &beginInfo);
+		vkCmdCopyBuffer2(objs.cbuffers_graphics.at(2), &copyInfo);
+		vkEndCommandBuffer(objs.cbuffers_graphics.at(2));
+
+		VkSubmitInfo submitinfo{};
+		submitinfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+		submitinfo.commandBufferCount = 1;
+		submitinfo.pCommandBuffers = &objs.cbuffers_graphics.at(2);
+		if (vkWaitForFences(objs.vkdevice.device, 1, &objs.renderfence, VK_TRUE, UINT64_MAX) != VK_SUCCESS) {
+			return false;
+		}
+		if (vkResetFences(objs.vkdevice.device, 1, &objs.renderfence) != VK_SUCCESS)
+			return false;
+
+		objs.mtx2->lock();
+		if (vkQueueSubmit(objs.graphicsQ, 1, &submitinfo, objs.renderfence) != VK_SUCCESS) {
+			return false;
+		}
+		vkQueueWaitIdle(objs.graphicsQ);
+		objs.mtx2->unlock();
+	}
+
+	vmaDestroyBuffer(objs.alloc, stagingbuffer, stagingbufferalloc);
+
+	// shaders
+	VkShaderModule p = vkshader::loadshader(objs.vkdevice.device, "shaders/ppx.spv");
+	VkShaderModule c = vkshader::loadshader(objs.vkdevice.device, "shaders/pcx.spv");
+	VkShaderModule v = vkshader::loadshader(objs.vkdevice.device, "shaders/pvx.spv");
+
+	// descriptor pool
+	std::vector<VkDescriptorPoolSize> pool0{{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2}};
+	if (!rpool::create(pool0, objs.vkdevice.device, &dpool))
+		return false;
+
+	// descriptor set layout
+	std::array<VkDescriptorSetLayoutBinding, 2> dlayoutbinds{};
+	dlayoutbinds.at(0).binding = 0;
+	dlayoutbinds.at(0).descriptorCount = 1;
+	dlayoutbinds.at(0).descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	dlayoutbinds.at(0).pImmutableSamplers = VK_NULL_HANDLE;
+	dlayoutbinds.at(0).stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+	dlayoutbinds.at(1).binding = 1;
+	dlayoutbinds.at(1).descriptorCount = 1;
+	dlayoutbinds.at(1).descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	dlayoutbinds.at(1).pImmutableSamplers = VK_NULL_HANDLE;
+	dlayoutbinds.at(1).stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+
+	VkDescriptorSetLayoutCreateInfo dlayoutinfo{};
+	dlayoutinfo.bindingCount = 2;
+	dlayoutinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+	dlayoutinfo.pBindings = dlayoutbinds.data();
+	if (vkCreateDescriptorSetLayout(objs.vkdevice.device, &dlayoutinfo, VK_NULL_HANDLE, &cdlayout) != VK_SUCCESS) {
+		return false;
+	}
+
+	// graphics playout
+	VkPipelineLayoutCreateInfo playoutinfo{};
+	playoutinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+	playoutinfo.setLayoutCount = 0;
+	playoutinfo.pSetLayouts = VK_NULL_HANDLE;
+	if (vkCreatePipelineLayout(objs.vkdevice.device, &playoutinfo, VK_NULL_HANDLE, &gplayout) != VK_SUCCESS)
+		return false;
+
+	// graphics pline
+	std::array<VkPipelineShaderStageCreateInfo, 2> gshaderinfos{};
+	gshaderinfos.at(0).sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+	gshaderinfos.at(0).stage = VK_SHADER_STAGE_VERTEX_BIT;
+	gshaderinfos.at(0).module = v;
+	gshaderinfos.at(0).pName = "main";
+	gshaderinfos.at(1).sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+	gshaderinfos.at(1).stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+	gshaderinfos.at(1).module = p;
+	gshaderinfos.at(1).pName = "main";
+
+	VkVertexInputBindingDescription inp{};
+	inp.binding = 0;
+	inp.stride = sizeof(P);
+	inp.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+	std::array<VkVertexInputAttributeDescription, 2> inpvx{};
+	inpvx.at(0).binding = 0;
+	inpvx.at(0).location = 0;
+	inpvx.at(0).format = VK_FORMAT_R32G32_SFLOAT;
+	inpvx.at(0).offset = offsetof(P, position);
+	inpvx.at(1).binding = 0;
+	inpvx.at(1).location = 1;
+	inpvx.at(1).format = VK_FORMAT_R32G32B32A32_SFLOAT;
+	inpvx.at(1).offset = offsetof(P, color);
+	VkPipelineVertexInputStateCreateInfo vinputinfo{};
+	vinputinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+	vinputinfo.vertexBindingDescriptionCount = 1;
+	vinputinfo.vertexAttributeDescriptionCount = inpvx.size();
+	vinputinfo.pVertexBindingDescriptions = &inp;
+	vinputinfo.pVertexAttributeDescriptions = inpvx.data();
+
+	VkPipelineInputAssemblyStateCreateInfo inputass{};
+	inputass.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+	inputass.topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; ///////////////////////////////////////////////////////
+	inputass.primitiveRestartEnable = VK_FALSE;
+
+	VkPipelineViewportStateCreateInfo viewportinfo{};
+	viewportinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+	viewportinfo.viewportCount = 1;
+	viewportinfo.scissorCount = 1;
+
+	VkPipelineRasterizationStateCreateInfo rasterinfo{};
+	rasterinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+	rasterinfo.depthClampEnable = VK_FALSE;
+	rasterinfo.rasterizerDiscardEnable = VK_FALSE;
+	rasterinfo.polygonMode = VK_POLYGON_MODE_FILL;
+	rasterinfo.lineWidth = 1.0f;
+	rasterinfo.cullMode = VK_CULL_MODE_BACK_BIT;
+	rasterinfo.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+	rasterinfo.depthBiasEnable = VK_FALSE;
+
+	VkPipelineMultisampleStateCreateInfo multisinfo{};
+	multisinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+	multisinfo.sampleShadingEnable = VK_FALSE;
+	multisinfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+
+	VkPipelineColorBlendAttachmentState colorattach{};
+	colorattach.colorWriteMask =
+	    VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+	colorattach.blendEnable = VK_TRUE;
+	colorattach.colorBlendOp = VK_BLEND_OP_ADD;
+	colorattach.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+	colorattach.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+	colorattach.alphaBlendOp = VK_BLEND_OP_ADD;
+	colorattach.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+	colorattach.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+	VkPipelineColorBlendStateCreateInfo colorinfo{};
+	colorinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+	colorinfo.logicOpEnable = VK_FALSE;
+	colorinfo.logicOp = VK_LOGIC_OP_COPY;
+	colorinfo.attachmentCount = 1;
+	colorinfo.pAttachments = &colorattach;
+	colorinfo.blendConstants[0] = 0.0f;
+	colorinfo.blendConstants[1] = 0.0f;
+	colorinfo.blendConstants[2] = 0.0f;
+	colorinfo.blendConstants[3] = 0.0f;
+	VkPipelineDepthStencilStateCreateInfo depthStencilInfo{};
+	depthStencilInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+	depthStencilInfo.depthTestEnable = VK_TRUE;
+	depthStencilInfo.depthWriteEnable = VK_TRUE;
+	depthStencilInfo.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
+	depthStencilInfo.depthBoundsTestEnable = VK_FALSE;
+	depthStencilInfo.minDepthBounds = 0.0f;
+	depthStencilInfo.maxDepthBounds = 1.0f;
+	depthStencilInfo.stencilTestEnable = VK_FALSE;
+
+	std::array<VkDynamicState, 2> dynstates{VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
+	VkPipelineDynamicStateCreateInfo dyninfo{};
+	dyninfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+	dyninfo.dynamicStateCount = dynstates.size();
+	dyninfo.pDynamicStates = dynstates.data();
+
+	VkGraphicsPipelineCreateInfo plineinfo{};
+	plineinfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+	plineinfo.stageCount = 2;
+	plineinfo.pStages = gshaderinfos.data();
+	plineinfo.pVertexInputState = &vinputinfo;
+	plineinfo.pInputAssemblyState = &inputass;
+	plineinfo.pViewportState = &viewportinfo;
+	plineinfo.pRasterizationState = &rasterinfo;
+	plineinfo.pMultisampleState = &multisinfo;
+	plineinfo.pColorBlendState = &colorinfo;
+	plineinfo.pDepthStencilState = &depthStencilInfo;
+	plineinfo.pDynamicState = &dyninfo;
+	plineinfo.layout = gplayout;
+	plineinfo.renderPass = objs.rdrenderpass;
+	plineinfo.subpass = 0;
+	plineinfo.basePipelineHandle = VK_NULL_HANDLE;
+	if (vkCreateGraphicsPipelines(objs.vkdevice.device, VK_NULL_HANDLE, 1, &plineinfo, nullptr, &gpline) != VK_SUCCESS) {
+		return false;
+	}
+
+	vkDestroyShaderModule(objs.vkdevice.device, p, VK_NULL_HANDLE);
+	vkDestroyShaderModule(objs.vkdevice.device, v, VK_NULL_HANDLE);
+
+	// descriptor sets
+	std::array<VkDescriptorSetLayout, 1> clayouts({cdlayout});
+	VkDescriptorSetAllocateInfo cdallocinfo{};
+	cdallocinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+	cdallocinfo.descriptorPool = dpool;
+	cdallocinfo.descriptorSetCount = 1;
+	cdallocinfo.pSetLayouts = clayouts.data();
+	if (vkAllocateDescriptorSets(objs.vkdevice.device, &cdallocinfo, &cdset) != VK_SUCCESS) {
+		return false;
+	}
+
+	VkDescriptorBufferInfo cssboinfo{}; // remake when switching to 2 frames
+	cssboinfo.buffer = ssbobuffsnallocs.at(0).first;
+	cssboinfo.offset = 0;
+	cssboinfo.range = sizeof(P) * Ps.size();
+
+	std::array<VkWriteDescriptorSet, 2> cdwrites{};
+	cdwrites.at(0).sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+	cdwrites.at(0).dstSet = cdset;
+	cdwrites.at(0).dstBinding = 0;
+	cdwrites.at(0).dstArrayElement = 0;
+	cdwrites.at(0).descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	cdwrites.at(0).descriptorCount = 1;
+	cdwrites.at(0).pBufferInfo = &cssboinfo;
+	cdwrites.at(1).sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+	cdwrites.at(1).dstSet = cdset;
+	cdwrites.at(1).dstBinding = 1;
+	cdwrites.at(1).dstArrayElement = 0;
+	cdwrites.at(1).descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	cdwrites.at(1).descriptorCount = 1;
+	cdwrites.at(1).pBufferInfo = &cssboinfo;
+
+	vkUpdateDescriptorSets(objs.vkdevice.device, cdwrites.size(), cdwrites.data(), 0, VK_NULL_HANDLE);
+
+	// compute playout
+	VkPipelineLayoutCreateInfo cplayoutinfo{};
+	cplayoutinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+	cplayoutinfo.setLayoutCount = 1;
+	cplayoutinfo.pSetLayouts = &cdlayout;
+	if (vkCreatePipelineLayout(objs.vkdevice.device, &cplayoutinfo, VK_NULL_HANDLE, &cplayout) != VK_SUCCESS)
+		return false;
+
+	// compute pline
+	std::array<VkPipelineShaderStageCreateInfo, 1> cshaderinfos{};
+	cshaderinfos.at(0).sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+	cshaderinfos.at(0).stage = VK_SHADER_STAGE_COMPUTE_BIT;
+	cshaderinfos.at(0).module = c;
+	cshaderinfos.at(0).pName = "main";
+
+	VkComputePipelineCreateInfo cplineinfo{};
+	cplineinfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+	cplineinfo.layout = cplayout;
+	cplineinfo.stage = cshaderinfos.at(0);
+
+	if (vkCreateComputePipelines(objs.vkdevice.device, VK_NULL_HANDLE, 1, &cplineinfo, VK_NULL_HANDLE, &cpline) !=
+	        VK_SUCCESS) {
+		return false;
+	}
+
+	vkDestroyShaderModule(objs.vkdevice.device, c, VK_NULL_HANDLE);
+
+	createSyncObjects(objs);
+	return true;
+}
+
+static inline bool drawcomp(rvk &objs) {
+
+	vkWaitForFences(objs.vkdevice.device,1,&computeInFlightFences.at(0),VK_TRUE,UINT64_MAX);
+
+	vkResetFences(objs.vkdevice.device,1,&computeInFlightFences.at(0));
+
+	if (vkResetCommandBuffer(objs.cbuffers_compute.at(0), 0) != VK_SUCCESS)
+		return false;
+
+	VkCommandBufferBeginInfo cmdbgninfo{};
+	cmdbgninfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+
+	if (vkBeginCommandBuffer(objs.cbuffers_compute.at(0), &cmdbgninfo) != VK_SUCCESS)
+		return false;
+
+	vkCmdBindPipeline(objs.cbuffers_compute.at(0), VK_PIPELINE_BIND_POINT_COMPUTE, cpline);
+
+	vkCmdBindDescriptorSets(objs.cbuffers_compute.at(0),VK_PIPELINE_BIND_POINT_COMPUTE,cplayout,0,1,&cdset,0,VK_NULL_HANDLE);
+	// VkBindDescriptorSetsInfo dsetinfo{};
+	// dsetinfo.sType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO;
+	// dsetinfo.layout = cplayout;
+	// dsetinfo.descriptorSetCount = 1;
+	// dsetinfo.firstSet = 0;
+	// dsetinfo.dynamicOffsetCount = 0;
+	// dsetinfo.pDynamicOffsets = VK_NULL_HANDLE;
+	// dsetinfo.pNext = VK_NULL_HANDLE;
+	// dsetinfo.stageFlags = ;
+	// dsetinfo.pDescriptorSets = &cdset;
+	// vkCmdBindDescriptorSets2(objs.cbuffers_graphics.at(2), &dsetinfo);
+
+	vkCmdDispatch(objs.cbuffers_compute.at(0), Ps.size() / 256, 1, 1);
+
+	if (vkEndCommandBuffer(objs.cbuffers_compute.at(0)) != VK_SUCCESS)
+		return false;
+
+	VkSubmitInfo submitinfo{};
+	submitinfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+	submitinfo.commandBufferCount = 1;
+	submitinfo.pCommandBuffers = &objs.cbuffers_compute.at(0);
+	submitinfo.signalSemaphoreCount = 1;
+	submitinfo.pSignalSemaphores = computeFinishedSemaphores.data();
+
+	objs.mtx2->lock();
+	if (vkQueueSubmit(objs.computeQ, 1, &submitinfo, computeInFlightFences.at(0)) != VK_SUCCESS) {
+		return false;
+	}
+	objs.mtx2->unlock();
+
+	return true;
+}
+
+static inline void destroyeveryting(rvk &objs) {
+	vkDestroyPipeline(objs.vkdevice.device,gpline,VK_NULL_HANDLE);
+	vkDestroyPipelineLayout(objs.vkdevice.device,gplayout,VK_NULL_HANDLE);
+	vkDestroyPipeline(objs.vkdevice.device,cpline,VK_NULL_HANDLE);
+	vkDestroyPipelineLayout(objs.vkdevice.device,cplayout,VK_NULL_HANDLE);
+
+	rpool::destroy(objs.vkdevice.device,dpool);
+	vkDestroyDescriptorSetLayout(objs.vkdevice.device,cdlayout,VK_NULL_HANDLE);
+	vmaDestroyBuffer(objs.alloc,ssbobuffsnallocs.at(0).first,ssbobuffsnallocs.at(0).second);
+
+	vkDestroySemaphore(objs.vkdevice.device,computeFinishedSemaphores.at(0),VK_NULL_HANDLE);
+	vkDestroyFence(objs.vkdevice.device,computeInFlightFences.at(0),VK_NULL_HANDLE);
+
+}
+
+}
\ No newline at end of file
diff --git a/include/framebuffer.hpp b/include/framebuffer.hpp
deleted file mode 100644
index a6c921a..0000000
--- a/include/framebuffer.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-#include "vkobjs.hpp"
-#include <vulkan/vulkan.h>
-
-class framebuffer {
-public:
-	static bool init(vkobjs &rdata);
-	static void cleanup(vkobjs &rdata);
-};
diff --git a/include/genericinstance.hpp b/include/genericinstance.hpp
index 6251db3..da5c827 100644
--- a/include/genericinstance.hpp
+++ b/include/genericinstance.hpp
@@ -10,7 +10,7 @@
 #include "modelsettings.hpp"
 #include "vkclip.hpp"
 #include "vknode.hpp"
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 
 class genericinstance {
 public:
@@ -38,6 +38,18 @@ class genericinstance {
 
 	glm::vec3 *getinstpos();
 
+	glm::mat4 calcstaticmat() {
+	glm::mat4 x = glm::scale(glm::mat4{1.0f}, mmodelsettings.msworldscale);
+	x = glm::toMat4(glm::quat(glm::radians(mmodelsettings.msworldrot))) * x;
+	x = glm::translate(glm::mat4{ 1.0f }, mmodelsettings.msworldpos) * x;
+	return x;
+	// glm::mat4 x{ 1.0 };
+	// ////glm::mat4 t = glm::translate(x, mmodelsettings.msworldpos) * glm::scale(x, mmodelsettings.msworldscale) * glm::rotate(x, glm::radians(mmodelsettings.msworldrot.y), glm::vec3{ 0.0f,1.0f,0.0f });
+	// glm::mat4 t = glm::translate(x, mmodelsettings.msworldpos) * glm::mat4_cast(glm::quat(glm::radians(mmodelsettings.msworldrot))) * glm::scale(x, mmodelsettings.msworldscale);
+	// return t;
+	}
+
+
 private:
 	void playanimation(int animnum, float speeddivider, float blendfactor, replaydirection direction);
 	void playanimation(int srcanimnum, int dstanimnum, float speeddivider, float blendfactor, replaydirection direction);
diff --git a/include/genericmodel.hpp b/include/genericmodel.hpp
index 72eff6a..ac9a5c8 100644
--- a/include/genericmodel.hpp
+++ b/include/genericmodel.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include "vkclip.hpp"
 #include "vknode.hpp"
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <fastgltf/core.hpp>
 #include <fastgltf/tools.hpp>
 #include <fastgltf/types.hpp>
@@ -18,14 +18,15 @@ struct gltfnodedata {
 
 class genericmodel {
 public:
-	bool loadmodel(vkobjs &objs, std::string fname);
-	void draw(vkobjs &objs);
-	void drawinstanced(vkobjs &objs, VkPipelineLayout &vkplayout, VkPipeline &vkpline, VkPipeline &vkplineuint,
+	bool loadmodel(rvk &objs, std::string fname);
+	void draw(rvk &objs);
+	void drawinstanced(rvk &objs, VkPipelineLayout &vkplayout, VkPipeline &vkpline, VkPipeline &vkplineuint,
 	                   int instancecount, int stride);
-	void cleanup(vkobjs &objs);
-	void uploadvboebo(vkobjs &objs, VkCommandBuffer &cbuffer);
+	void drawinstancedstatic(rvk &objs, VkPipelineLayout &vkplayout, VkPipeline &vkpline,
+	                   int instancecount, int stride);
+	void cleanup(rvk &objs);
+	void uploadvboebo(rvk &objs, VkCommandBuffer &cbuffer);
 	std::vector<texdata> gettexdata();
-	texdatapls gettexdatapls();
 	std::string getmodelfname();
 	int getnodecount();
 	gltfnodedata getgltfnodes();
@@ -37,13 +38,14 @@ class genericmodel {
 	std::vector<std::shared_ptr<vkclip>> getanimclips();
 
 	void resetnodedata(std::shared_ptr<vknode> treenode);
+	bool skinned{true};
 
 private:
 	std::vector<bool> meshjointtype{};
 
 	std::vector<unsigned int> jointuintofx{0};
 
-	void createvboebo(vkobjs &objs);
+	void createvboebo(rvk &objs);
 
 	void getjointdata();
 	void getweightdata();
diff --git a/include/modelsettings.hpp b/include/modelsettings.hpp
index 3212bcb..afc1b79 100644
--- a/include/modelsettings.hpp
+++ b/include/modelsettings.hpp
@@ -1,6 +1,6 @@
 
 #pragma once
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <glm/glm.hpp>
 #include <string>
 #include <vector>
diff --git a/include/playout.hpp b/include/playout.hpp
index 18a0420..4736bba 100644
--- a/include/playout.hpp
+++ b/include/playout.hpp
@@ -1,10 +1,10 @@
 #pragma once
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <vulkan/vulkan.h>
 
 class playout {
 public:
-	static bool init(vkobjs &mvkobjs, VkPipelineLayout &vkplayout, std::vector<VkDescriptorSetLayout> layoutz,
+	static bool init(rvk &mvkobjs, VkPipelineLayout &vkplayout, std::span<VkDescriptorSetLayout> layoutz,
 	                 size_t pushc_size);
-	static void cleanup(vkobjs &mvkobjs, VkPipelineLayout &vkplayout);
+	static void cleanup(rvk &mvkobjs, VkPipelineLayout &vkplayout);
 };
\ No newline at end of file
diff --git a/include/playoutgeneric.hpp b/include/playoutgeneric.hpp
index 72c6917..a0e484e 100644
--- a/include/playoutgeneric.hpp
+++ b/include/playoutgeneric.hpp
@@ -1,41 +1,45 @@
 #pragma once
 #include "genericinstance.hpp"
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <memory>
 #include <string>
 #include <vector>
 #include <vulkan/vulkan.h>
-
 class playoutgeneric {
 public:
-	bool loadmodel(vkobjs &objs, std::string fname);
-	bool createinstances(vkobjs &objs, size_t count, bool rand);
-	bool createubo(vkobjs &objs);
-	bool createssbomat(vkobjs &objs);
-	bool createplayout(vkobjs &objs);
-	bool createpline(vkobjs &objs, std::string vfile, std::string ffile);
-	bool setup(vkobjs &objs, std::string fname, size_t count, std::string vfile, std::string ffile);
-	void draw(vkobjs &objs);
+	bool loadmodel(rvk &objs, std::string fname);
+	bool createinstances(rvk &objs, size_t count, bool rand);
+	bool createubo(rvk &objs);
+	bool createssbomat(rvk &objs);
+	bool createssbostatic(rvk &objs);
+	static bool createskinnedplayout(rvk &objs);
+	static bool createstaticplayout(rvk &objs);
+	static bool createpline(rvk &objs, std::string vfile, std::string ffile);
+	static bool createplinestatic(rvk &objs);
+	bool setup(rvk &objs, std::string fname, size_t count, std::string vfile, std::string ffile);
+	void draw(rvk &objs);
 	void updateanims();
 	void updatemats();
-	void cleanuplines(vkobjs &objs);
-	void cleanupbuffers(vkobjs &objs);
-	void cleanupmodels(vkobjs &objs);
-	void uploadvboebo(vkobjs &objs, VkCommandBuffer &cbuffer);
-	void uploadubossbo(vkobjs &objs, std::vector<glm::mat4> &cammats);
+	void cleanuplines(rvk &objs);
+	void cleanupbuffers(rvk &objs);
+	void cleanupmodels(rvk &objs);
+	void uploadvboebo(rvk &objs, VkCommandBuffer &cbuffer);
+	void uploadubossbo(rvk &objs,std::vector<glm::mat4> &cammats);
 
 	std::shared_ptr<genericinstance> getinst(int i);
 
 	bool ready{false};
+	
+	inline static VkPipelineLayout skinnedplayout = VK_NULL_HANDLE;
+	inline static VkPipelineLayout staticplayout = VK_NULL_HANDLE;
+	inline static VkPipeline skinnedpline = VK_NULL_HANDLE;
+	inline static VkPipeline skinnedplineuint = VK_NULL_HANDLE;
+	inline static VkPipeline staticpline = VK_NULL_HANDLE;
 
 private:
-	std::vector<VkDescriptorSetLayout> desclayouts{};
 
-	VkPipelineLayout rdgltfpipelinelayout = VK_NULL_HANDLE;
-	VkPipeline rdgltfgpupipeline = VK_NULL_HANDLE;
-	VkPipeline rdgltfgpupipelineuint = VK_NULL_HANDLE;
 
-	std::vector<ubodata> rdperspviewmatrixubo{};
+	inline static std::vector<ubodata> rdperspviewmatrixubo{};
 	ssbodata rdjointmatrixssbo{};
 
 	bool uploadreq{true};
diff --git a/include/pline.hpp b/include/pline.hpp
index 3628852..01e4653 100644
--- a/include/pline.hpp
+++ b/include/pline.hpp
@@ -1,11 +1,11 @@
 #pragma once
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <string>
 #include <vulkan/vulkan.h>
 
 class pline {
 public:
-	static bool init(vkobjs &objs, VkPipelineLayout &playout, VkPipeline &pipeline, VkPrimitiveTopology topology,
+	static bool init(rvk &objs, VkPipelineLayout &playout, VkPipeline &pipeline, VkPrimitiveTopology topology,
 	                 unsigned int v_in, unsigned int atts, std::vector<std::string> sfiles, bool char_or_short = false);
-	static void cleanup(vkobjs &objs, VkPipeline &pipeline);
+	static void cleanup(rvk &objs, VkPipeline &pipeline);
 };
diff --git a/include/renderpass.hpp b/include/renderpass.hpp
index acc5bb6..f0b40ab 100644
--- a/include/renderpass.hpp
+++ b/include/renderpass.hpp
@@ -1,8 +1,8 @@
 #pragma once
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <vulkan/vulkan.h>
 class renderpass {
 public:
-	static bool init(vkobjs &rdata);
-	static void cleanup(vkobjs &rdata);
+	static bool init(rvk &rdata);
+	static void cleanup(rvk &rdata);
 };
diff --git a/include/ssbo.hpp b/include/ssbo.hpp
deleted file mode 100644
index c056d04..0000000
--- a/include/ssbo.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-#include <glm/glm.hpp>
-#include <vector>
-#include <vulkan/vulkan.h>
-
-#include "vkobjs.hpp"
-
-class ssbo {
-public:
-	static bool init(vkobjs &objs, ssbodata &ssbodata, size_t buffersize);
-	static void upload(vkobjs &objs, ssbodata &ssbodata, std::vector<glm::mat4> mats);
-	static void upload(vkobjs &objs, ssbodata &ssbodata, std::vector<glm::mat2x4> mats);
-	static void upload(vkobjs &objs, ssbodata &ssbodata, const std::vector<double> &mats);
-	static void cleanup(vkobjs &objs, ssbodata &ssbodata);
-};
diff --git a/include/ssbomesh.hpp b/include/ssbomesh.hpp
deleted file mode 100644
index 54cd5e1..0000000
--- a/include/ssbomesh.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-#include <glm/glm.hpp>
-#include <vector>
-#include <vulkan/vulkan.h>
-
-#include "vkobjs.hpp"
-
-class ssbomesh {
-public:
-	static bool init(vkobjs &objs, ssbodata &ssbodata);
-	static void upload(vkobjs &objs, ssbodata &ssbodata, std::vector<glm::mat4> &mats);
-	static void upload(vkobjs &objs, ssbodata &ssbodata, std::vector<glm::mat2x4> mats);
-	static void cleanup(vkobjs &objs, ssbodata &ssbodata);
-};
\ No newline at end of file
diff --git a/include/ubo.hpp b/include/ubo.hpp
index c837630..9ac9d6a 100644
--- a/include/ubo.hpp
+++ b/include/ubo.hpp
@@ -1,12 +1,11 @@
 #pragma once
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <glm/glm.hpp>
 #include <vulkan/vulkan.h>
 class ubo {
 public:
-	static bool init(vkobjs &mvkobjs, std::vector<ubodata> &ubodata);
-	static void upload(vkobjs &mvkobjs, std::vector<ubodata> &ubodata, std::vector<glm::mat4> mats,
-	                   unsigned int texidx);
-	static void upload(vkobjs &mvkobjs, std::vector<ubodata> &ubodata, unsigned int texidx);
-	static void cleanup(vkobjs &mvkobjs, std::vector<ubodata> &ubodata);
+	static bool init(rvk &mvkobjs, std::vector<ubodata> &ubodata);
+	static bool createlayout(rvk &mvkobjs, VkDescriptorSetLayout& dlayout);
+	static void upload(rvk &mvkobjs, std::vector<ubodata> &ubodata, std::vector<glm::mat4> mats);
+	static void cleanup(rvk &mvkobjs, std::vector<ubodata> &ubodata);
 };
diff --git a/include/ui.hpp b/include/ui.hpp
index f1eac35..02d38e2 100644
--- a/include/ui.hpp
+++ b/include/ui.hpp
@@ -2,7 +2,7 @@
 #include <vector>
 
 #include "modelsettings.hpp"
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 
 enum struct ppick { rock, paper, scissor };
 enum struct gstate { tie, ai, player };
@@ -15,13 +15,13 @@ struct selection {
 
 class ui {
 public:
-	bool init(vkobjs &mvkobjs);
-	void createdbgframe(vkobjs &mvkobjs, selection &settingsz);
-	bool createloadingscreen(vkobjs &mvkobjs);
-	bool createpausebuttons(vkobjs &mvkobjs);
+	bool init(rvk &mvkobjs);
+	void createdbgframe(rvk &mvkobjs, selection &settingsz);
+	bool createloadingscreen(rvk &mvkobjs);
+	bool createpausebuttons(rvk &mvkobjs);
 	void addchat(std::string s);
-	void render(vkobjs &mvkobjs, VkCommandBuffer &cbuffer);
-	void cleanup(vkobjs &mvkobjs);
+	void render(rvk &mvkobjs, VkCommandBuffer &cbuffer);
+	void cleanup(rvk &mvkobjs);
 	bool setnetwork{false};
 	void backspace();
 	bool chatfocus{false};
diff --git a/include/vk/commandbuffer.hpp b/include/vk/commandbuffer.hpp
new file mode 100644
index 0000000..a4d3bd9
--- /dev/null
+++ b/include/vk/commandbuffer.hpp
@@ -0,0 +1,24 @@
+#pragma once
+#include "core/rvk.hpp"
+#include <vulkan/vulkan.h>
+#include <span>
+namespace commandbuffer {
+
+static inline bool create(rvk &rdata, VkCommandPool &vkpool,const std::span<VkCommandBuffer> &cbuffs) {
+	VkCommandBufferAllocateInfo bufferallocinfo{
+		.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+		.commandPool = vkpool,
+		.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, //not sure
+		.commandBufferCount = cbuffs.size()
+	};
+	if (vkAllocateCommandBuffers(rdata.vkdevice.device, &bufferallocinfo, cbuffs.data()) != VK_SUCCESS) {
+		return false;
+	}
+	return true;
+}
+
+static inline void destroy(rvk &rdata, VkCommandPool &vkpool,const std::span<VkCommandBuffer> &cbuffs) {
+	vkFreeCommandBuffers(rdata.vkdevice.device, vkpool, cbuffs.size(), cbuffs.data());
+}
+
+};
\ No newline at end of file
diff --git a/include/vk/commandpool.hpp b/include/vk/commandpool.hpp
new file mode 100644
index 0000000..fde9985
--- /dev/null
+++ b/include/vk/commandpool.hpp
@@ -0,0 +1,29 @@
+#pragma once
+#include "core/rvk.hpp"
+#include <vulkan/vulkan.h>
+#include <VkBootstrap.h>
+
+namespace commandpool {
+
+static inline bool createsametype(rvk &rdata,const std::span<VkCommandPool> &vkpools,const vkb::QueueType& qtype) {
+	for(auto& x:vkpools) {
+		VkCommandPoolCreateInfo poolcreateinfo{
+			.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+			.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
+			.queueFamilyIndex = rdata.vkdevice.get_queue_index(qtype).value()
+		};
+
+		if (vkCreateCommandPool(rdata.vkdevice.device, &poolcreateinfo, nullptr, &x) != VK_SUCCESS) {
+			return false;
+		}
+	}
+
+	return true;
+}
+static inline void destroy(rvk &rdata,const std::span<VkCommandPool> &vkpools) {
+	for(auto& x:vkpools) {
+		vkDestroyCommandPool(rdata.vkdevice.device, x, nullptr);
+	}
+}
+
+};
\ No newline at end of file
diff --git a/include/vk/framebuffer.hpp b/include/vk/framebuffer.hpp
new file mode 100644
index 0000000..db6f355
--- /dev/null
+++ b/include/vk/framebuffer.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "core/rvk.hpp"
+#include <vulkan/vulkan.h>
+
+namespace framebuffer {
+static inline bool create(rvk &rdata) {
+	rdata.schainimgs = rdata.schain.get_images().value();
+	rdata.schainimgviews = rdata.schain.get_image_views().value();
+
+	rdata.fbuffers.reserve(rdata.schainimgviews.size());
+	rdata.fbuffers.resize(rdata.schainimgviews.size());
+
+	for (size_t i = 0; i < rdata.schainimgviews.size(); ++i) {
+		VkImageView a[] = {rdata.schainimgviews[i], rdata.rddepthimageview};
+
+		VkFramebufferCreateInfo fbinfo{
+		.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+		.renderPass = rdata.rdrenderpass,
+		.attachmentCount = 2,
+		.pAttachments = a,
+		.width = rdata.schain.extent.width,
+		.height = rdata.schain.extent.height,
+		.layers = 1
+		};
+
+		if (vkCreateFramebuffer(rdata.vkdevice.device, &fbinfo, nullptr, &rdata.fbuffers[i]) != VK_SUCCESS) {
+			return false;
+		}
+	}
+	return true;
+}
+static inline void destroy(const VkDevice &dev,const std::span<VkFramebuffer>& fbs) {
+	for (auto &fb : fbs) {
+		vkDestroyFramebuffer(dev, fb, nullptr);
+	}
+}
+
+};
diff --git a/include/vkcam.hpp b/include/vkcam.hpp
index 5bb57f9..4c26020 100644
--- a/include/vkcam.hpp
+++ b/include/vkcam.hpp
@@ -1,12 +1,12 @@
 #pragma once
 #define GLM_ENABLE_EXPERIMENTAL
 
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <glm/glm.hpp>
 
 class vkcam {
 public:
-	glm::mat4 getview(vkobjs &mvkobjs);
+	glm::mat4 getview(rvk &mvkobjs);
 	glm::vec3 mforward{0.0f};
 	glm::vec3 mright{0.0f};
 	glm::vec3 mup{0.0f};
diff --git a/include/vkebo.hpp b/include/vkebo.hpp
index 8104d45..c114f44 100644
--- a/include/vkebo.hpp
+++ b/include/vkebo.hpp
@@ -1,14 +1,14 @@
 #pragma once
 #include <vulkan/vulkan.h>
 // #include <tinygltf/tiny_gltf.h>
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <fastgltf/core.hpp>
 class vkebo {
 public:
-	static bool init(vkobjs &objs, ebodata &indexbufferdata, size_t buffersize);
-	static bool upload(vkobjs &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferdata, const fastgltf::Buffer &buffer,
+	static bool init(rvk &objs, ebodata &indexbufferdata, size_t buffersize);
+	static bool upload(rvk &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferdata, const fastgltf::Buffer &buffer,
 	                   const fastgltf::BufferView &bufferview, const size_t &count);
-	static bool upload(vkobjs &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferdata,
+	static bool upload(rvk &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferdata,
 	                   std::vector<unsigned short> indicez);
-	static void cleanup(vkobjs &objs, ebodata &indexbufferdata);
+	static void cleanup(rvk &objs, ebodata &indexbufferdata);
 };
diff --git a/include/vkrenderer.hpp b/include/vkrenderer.hpp
index 86a5977..18192e4 100644
--- a/include/vkrenderer.hpp
+++ b/include/vkrenderer.hpp
@@ -21,7 +21,7 @@
 
 #include "playoutgeneric.hpp"
 
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 
 class vkrenderer {
 public:
@@ -40,6 +40,7 @@ class vkrenderer {
 	ui *getuihandle();
 	void moveplayer();
 
+
 	void sdlevent(SDL_Event *e);
 
 
@@ -49,7 +50,7 @@ class vkrenderer {
 
 	bool quicksetup();
 
-	vkobjs &getvkobjs();
+	rvk &getvkobjs();
 
 	bool newconnection{false};
 
@@ -65,7 +66,7 @@ class vkrenderer {
 
 	std::mutex getinstsettingsmtx{};
 
-	vkobjs mvkobjs{};
+	rvk mvkobjs{};
 
 	double dummy{0.0};
 
@@ -114,7 +115,7 @@ class vkrenderer {
 
 	std::vector<unsigned int> playercount{1};
 	std::vector<std::string> playerfname{{"resources/p0.glb"}};
-	const std::vector<std::vector<std::string>> playershaders{{"shaders/gen.slang.vx.spv", "shaders/gen.slang.px.spv"}};
+	const std::vector<std::vector<std::string>> playershaders{{"shaders/vx.spv", "shaders/px.spv"}};
 
 	ui mui{};
 	timer mframetimer{};
@@ -131,6 +132,7 @@ class vkrenderer {
 
 	std::vector<glm::mat4> mpersviewmats{glm::mat4{1.0f},glm::mat4{1.0f}};
 
+	bool createpools();
 	bool deviceinit();
 	bool getqueue();
 	bool createdepthbuffer();
diff --git a/include/vksyncobjects.hpp b/include/vksyncobjects.hpp
index 7ae7384..a21758b 100644
--- a/include/vksyncobjects.hpp
+++ b/include/vksyncobjects.hpp
@@ -1,9 +1,9 @@
 #pragma once
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <VkBootstrap.h>
 #include <vulkan/vulkan.h>
 class vksyncobjects {
 public:
-	static bool init(vkobjs &rdata);
-	static void cleanup(vkobjs &rdata);
+	static bool init(rvk &rdata);
+	static void cleanup(rvk &rdata);
 };
diff --git a/include/vktexture.hpp b/include/vktexture.hpp
index 5636820..5544dc5 100644
--- a/include/vktexture.hpp
+++ b/include/vktexture.hpp
@@ -1,14 +1,14 @@
 #pragma once
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <vulkan/vulkan.h>
 // #include "tinygltf/tiny_gltf.h"
 #include <fastgltf/core.hpp>
 class vktexture {
 public:
-	static bool loadtexturefile(vkobjs &rdata, texdata &texdata, texdatapls &texdatapls, std::string texfile);
-	static bool loadtexture(vkobjs &rdata, std::vector<texdata> &texdata, fastgltf::Asset &mmodel);
-	static bool loadtexlayoutpool(vkobjs &rdata, std::vector<texdata> &texdata, texdatapls &texdatapls,
+	static bool loadtexture(rvk &rdata, std::vector<texdata> &texdata, fastgltf::Asset &mmodel);
+	static bool loadtexset(rvk &rdata, std::vector<texdata> &texdata, VkDescriptorSetLayout &dlayout,VkDescriptorSet &dset,
 	                              fastgltf::Asset &mmodel);
-	static void cleanup(vkobjs &rdata, texdata &texdata);
-	static void cleanuppls(vkobjs &rdata, texdatapls &texdatapls);
+	static bool createlayout(rvk &core);
+	static void cleanup(rvk &rdata, texdata &texdata);
+	// static void cleanuppls(rvk &rdata, texdataset &texdatapls);
 };
diff --git a/include/vkvbo.hpp b/include/vkvbo.hpp
index 4afd27e..de67cd3 100644
--- a/include/vkvbo.hpp
+++ b/include/vkvbo.hpp
@@ -1,18 +1,18 @@
 #pragma once
 #include <vulkan/vulkan.h>
-#include "vkobjs.hpp"
+#include "core/rvk.hpp"
 #include <fastgltf/core.hpp>
 class vkvbo {
 public:
-	static bool init(vkobjs &mvkobjs, vbodata &vbdata, size_t bsize);
-	static bool upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
+	static bool init(rvk &mvkobjs, vbodata &vbdata, size_t bsize);
+	static bool upload(rvk &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
 	                   std::vector<glm::vec3> vertexdata);
-	static bool upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
+	static bool upload(rvk &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
 	                   std::vector<glm::vec2> vertexdata);
-	static bool upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
+	static bool upload(rvk &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
 	                   const fastgltf::Buffer &buffer, const fastgltf::BufferView &bufferview,
 	                   const fastgltf::Accessor &acc);
-	static bool upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
+	static bool upload(rvk &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
 	                   const std::vector<unsigned int> &jointz, const unsigned int count, const unsigned int ofx);
-	static void cleanup(vkobjs &mvkobjs, vbodata &vbdata);
+	static void cleanup(rvk &mvkobjs, vbodata &vbdata);
 };
diff --git a/shaders/gen.slang b/shaders/gen.slang
index 6d18e00..139d93b 100644
--- a/shaders/gen.slang
+++ b/shaders/gen.slang
@@ -6,12 +6,27 @@ struct texidx {
 }
 
 struct VXin {
-	float3 pos:POSITION;
-	float3 aNormal:NORMAL;
-	float2 aTexCoord:TEXCOORD;
-	uint4 aJointNum:JOINTS;
-	float4 aJointWeight:WEIGHTS;
+	float3 pos : POSITION;
+	float3 aNormal : NORMAL;
+	float2 tex0 : TEXCOORD_0;
+	uint4 joi0 : JOINTS_0;
+	float4 wei0 : WEIGHTS_0;
+	// float2 tex1 : TEXCOORD_1;
+	// uint4 joi1 : JOINTS_1;
+	// float4 wei1 : WEIGHTS_1;
+	// float2 tex2 : TEXCOORD_2;
+	// float2 tex3 : TEXCOORD_3;
+	// float2 tex4 : TEXCOORD_4;
+	// float2 tex5 : TEXCOORD_5;
 }
+struct Particle {
+	float2 position;
+	float2 velocity;
+	float4 color;
+};
+
+StructuredBuffer<Particle> pin;
+RWStructuredBuffer<Particle> pout;
 
 struct PXin {
 	float3 normal;
@@ -21,7 +36,11 @@ struct PXin {
 	float32_t t2;
 	float32_t dec;
 }
+struct CXin {
+	uint3 tid : SV_DispatchThreadID;
+	Particle p;
 
+}
 struct PXout {
 	float4 color;
 }
@@ -44,6 +63,14 @@ struct jmats {
 	float4x4 jointmats;
 }
 
+struct anim {
+	float3 trans;
+	float3 scale;
+	float4 rot;
+}
+
+RWStructuredBuffer<anim> Ps;
+
 [vk_push_constant]
 ConstantBuffer<consts> Constants;
 
@@ -51,19 +78,18 @@ ConstantBuffer<consts> Constants;
 ConstantBuffer<cams> cammats;
 
 [[vk_binding(0, 2)]]
-StructuredBuffer<jmats> jmatbuffer;
+RWStructuredBuffer<jmats> jmatbuffer;
 
 [[vk_binding(1, 1)]]
 ConstantBuffer<texidx> texid2;
 
 //stumped
 [shader("vertex")]
-VXout vxmain(VXin vxin) {
-	// float4x4 skinmat = JointMatrices[0].jointMat[vxin.aJointNum.x].scale(vxin.aJointWeight.x.toFloat()).add(JointMatrices[0].jointMat[vxin.aJointNum.y].scale(vxin.aJointWeight.y.toFloat()).add(JointMatrices[0].jointMat[vxin.aJointNum.z].scale(vxin.aJointWeight.z.toFloat())).add(JointMatrices[0].jointMat[vxin.aJointNum.w].scale(vxin.aJointWeight.w.toFloat())));
-	float4x4 skinmat = jmatbuffer[vxin.aJointNum.x].jointmats * vxin.aJointWeight.x +
-					   jmatbuffer[vxin.aJointNum.y].jointmats * vxin.aJointWeight.y +
-					   jmatbuffer[vxin.aJointNum.z].jointmats * vxin.aJointWeight.z +
-					   jmatbuffer[vxin.aJointNum.w].jointmats * vxin.aJointWeight.w ;
+VXout vxmain(VXin vxin, uint id: SV_VulkanInstanceID) {
+	float4x4 skinmat = jmatbuffer[vxin.joi0.x + Constants.aModelStride * id].jointmats * vxin.wei0.x +
+					   jmatbuffer[vxin.joi0.y + Constants.aModelStride * id].jointmats * vxin.wei0.y +
+					   jmatbuffer[vxin.joi0.z + Constants.aModelStride * id].jointmats * vxin.wei0.z +
+					   jmatbuffer[vxin.joi0.w + Constants.aModelStride * id].jointmats * vxin.wei0.w ;
 	VXout out;
 	float4x4 x = mul(cammats.projection, cammats.view);
 	float4x4 y = mul(x, skinmat);
@@ -71,8 +97,8 @@ VXout vxmain(VXin vxin) {
 	float4 z = mul(y, xx);
 	out.sv_position = z;
 	out.pxin0.normal = vxin.aNormal;
-	out.pxin0.texCoord = vxin.aTexCoord;
-	out.pxin0.newcolor = vxin.aJointNum;
+	out.pxin0.texCoord = vxin.tex0;
+	out.pxin0.newcolor = vxin.joi0;
 	out.pxin0.txidx = Constants.txid;
 	out.pxin0.t2 = Constants.t;
 	out.pxin0.dec = 0.0;
@@ -86,4 +112,4 @@ PXout pxmain(PXin pxin) {
 	out.color = tex[pxin.txidx].Sample(float2(pxin.texCoord.x, pxin.texCoord.y - fract(pxin.t2 * pxin.txidx / 4.0)));
 
 	return out;
-}
+}
\ No newline at end of file
diff --git a/shaders/particle.slang b/shaders/particle.slang
new file mode 100644
index 0000000..32bfbbb
--- /dev/null
+++ b/shaders/particle.slang
@@ -0,0 +1,56 @@
+
+struct Particle {
+	float2 position;
+	float2 velocity;
+	float4 color;
+};
+
+struct VXin {
+	float2 pos : POSITION;
+	float4 color;
+}
+struct PXin {
+    float3 normal;
+	float4 color;
+}
+struct CXin {
+	uint3 tid : SV_DispatchThreadID;
+	Particle p;
+
+}
+struct PXout {
+	float4 color;
+}
+
+struct VXout {
+	PXin pxin;
+    float4 sv_position : SV_Position;
+    float psize : SV_PointSize;
+}
+
+
+StructuredBuffer<Particle> pin;
+RWStructuredBuffer<Particle> pout;
+
+[shader("vertex")]
+VXout vxmain(VXin vxin) {
+	VXout out;
+	out.sv_position = float4(vxin.pos, 1.0f, 1.0f);
+	out.pxin.color = vxin.color;
+	out.psize = 14.0f;
+	return out;
+}
+
+[shader("pixel")]
+PXout pxmain(PXin pxin, float2 coord: SV_PointCoord) {
+	PXout out;
+	out.color = float4(pxin.color.xyz, 0.5 - length(coord - float2(0.5)));
+	return out;
+}
+
+[shader("compute")]
+[[numthreads(256, 1, 1)]]
+void cxmain(uint3 tid : SV_DispatchThreadID) {
+    pout[tid.x].position = pin[tid.x].position + pin[tid.x].velocity.xy * 0.1;
+    pout[tid.x].velocity = pin[tid.x].velocity;
+}
\ No newline at end of file
diff --git a/shaders/skin.slang b/shaders/skin.slang
new file mode 100644
index 0000000..91d3ac1
--- /dev/null
+++ b/shaders/skin.slang
@@ -0,0 +1,22 @@
+
+// struct jmats {
+// 	float4x4 jointmats;
+// }
+
+// [[vk_binding(0, 0)]]
+// StructuredBuffer<jmats> jmatbuffer;
+// [[vk_binding(0, 1)]]
+// StructuredBuffer<uint4> jois;
+// [[vk_binding(0, 2)]]
+// StructuredBuffer<float4> weis;
+
+// RWStructuredBuffer<float4> verts;
+
+// [shader("compute")]
+// [[numthreads(256, 1, 1)]]
+// void cxmain(uint3 tid: SV_DispatchThreadID) {
+// 	verts[tid.x] = jmatbuffer[jois[tid.x].x].jointmats * weis[tid.x].x +
+// 				   jmatbuffer[jois[tid.x].y].jointmats * weis[tid.x].y +
+// 				   jmatbuffer[jois[tid.x].z].jointmats * weis[tid.x].z +
+// 				   jmatbuffer[jois[tid.x].w].jointmats * weis[tid.x].w;
+// }
diff --git a/shaders/static.slang b/shaders/static.slang
new file mode 100644
index 0000000..c2eb29f
--- /dev/null
+++ b/shaders/static.slang
@@ -0,0 +1,111 @@
+
+layout(set = 0, binding = 0) uniform Sampler2D tex[];
+
+struct texidx {
+	uint texid;
+}
+
+struct VXin {
+	float3 pos : POSITION;
+	float3 aNormal : NORMAL;
+	float2 tex0 : TEXCOORD_0;
+	// float2 tex1 : TEXCOORD_1;
+	// float2 tex2 : TEXCOORD_2;
+	// float2 tex3 : TEXCOORD_3;
+	// float2 tex4 : TEXCOORD_4;
+	// float2 tex5 : TEXCOORD_5;
+}
+struct Particle {
+	float2 position;
+	float2 velocity;
+	float4 color;
+};
+
+StructuredBuffer<Particle> pin;
+RWStructuredBuffer<Particle> pout;
+
+struct PXin {
+	float3 normal;
+	float2 texCoord;
+	float4 newcolor;
+	uint32_t txidx;
+	float32_t t2;
+	float32_t dec;
+}
+struct CXin {
+	uint3 tid : SV_DispatchThreadID;
+	Particle p;
+
+}
+struct PXout {
+	float4 color;
+}
+
+struct VXout {
+	PXin pxin0;
+	float4 sv_position : SV_Position;
+}
+
+struct consts {
+	int aModelStride;
+	uint txid;
+	float t;
+}
+struct cams {
+	float4x4 view;
+	float4x4 projection;
+}
+struct jmats {
+	float4x4 jointmats;
+}
+
+struct anim {
+	float3 trans;
+	float3 scale;
+	float4 rot;
+}
+
+RWStructuredBuffer<anim> Ps;
+
+[vk_push_constant]
+ConstantBuffer<consts> Constants;
+
+[[vk_binding(0, 1)]]
+ConstantBuffer<cams> cammats;
+
+[[vk_binding(0, 2)]]
+RWStructuredBuffer<jmats> transmat;
+
+[[vk_binding(1, 1)]]
+ConstantBuffer<texidx> texid2;
+
+//stumped
+[shader("vertex")]
+VXout vxmain(VXin vxin, uint id: SV_VulkanInstanceID) {
+	VXout out;
+	// float4x4 x = mul(cammats.projection, cammats.view);
+	// float4 xx = float4(vxin.pos, 1.0f);
+	// float4x4 xxx = mul(x, transmat[id].jointmats);
+	// float4 xxxx = mul(xx, xxx);
+	// out.sv_position = xxxx;
+	float4x4 x = mul(cammats.projection, cammats.view);
+	float4 xx = float4(vxin.pos, 1.0f);
+	float4 xxx = mul(transmat[id].jointmats, xx);
+	float4 xxxx = mul(x, xxx);
+	out.sv_position = xxxx;
+	out.pxin0.normal = vxin.aNormal;
+	out.pxin0.texCoord = vxin.tex0;
+	out.pxin0.txidx = Constants.txid;
+	out.pxin0.t2 = Constants.t;
+	out.pxin0.dec = 0.0;
+	return out;
+}
+
+
+[shader("pixel")]
+PXout pxmain(PXin pxin) {
+	PXout out;
+	out.color = tex[pxin.txidx].Sample(float2(pxin.texCoord.x, pxin.texCoord.y));
+
+	return out;
+}
\ No newline at end of file
diff --git a/src/auxiliary/ui.cpp b/src/auxiliary/ui.cpp
index c081932..c25606e 100644
--- a/src/auxiliary/ui.cpp
+++ b/src/auxiliary/ui.cpp
@@ -10,10 +10,10 @@
 #include <imgui.h>
 #include <misc/cpp/imgui_stdlib.h>
 
-#include "commandbuffer.hpp"
+#include "vk/commandbuffer.hpp"
 #include "ui.hpp"
 
-bool ui::init(vkobjs &renderData) {
+bool ui::init(rvk &renderData) {
 	IMGUI_CHECKVERSION();
 	ImGui::CreateContext();
 	// std::shared_ptr<ImGuiContext> x=std::make_shared<ImGuiContext>(ImGui::CreateContext());
@@ -23,28 +23,28 @@ bool ui::init(vkobjs &renderData) {
 	io.Fonts->AddFontFromFileTTF("resources/comicbd.ttf", 29.0f);
 	io.Fonts->AddFontFromFileTTF("resources/bruce.ttf", 52.0f);
 
-	VkDescriptorPoolSize imguiPoolSizes[] = {{VK_DESCRIPTOR_TYPE_SAMPLER, 1000},
-		{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000},
-		{VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000},
-		{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000},
-		{VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000},
-		{VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000},
-		{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000},
-		{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000},
-		{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000},
-		{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000},
-		{VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000}
-	};
+	std::array<VkDescriptorPoolSize,11> imguiPoolSizes{{{VK_DESCRIPTOR_TYPE_SAMPLER, 24},
+		{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 24},
+		{VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 24},
+		{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 24},
+		{VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 24},
+		{VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 24},
+		{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 24},
+		{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 24},
+		{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 24},
+		{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 24},
+		{VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 24}
+	}};
 
 	VkDescriptorPoolCreateInfo imguiPoolInfo{};
 	imguiPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
 	imguiPoolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
-	imguiPoolInfo.maxSets = 1000;
-	imguiPoolInfo.poolSizeCount = std::size(imguiPoolSizes);
-	imguiPoolInfo.pPoolSizes = imguiPoolSizes;
-
+	imguiPoolInfo.maxSets = 24;
+	imguiPoolInfo.poolSizeCount = imguiPoolSizes.size();
+	imguiPoolInfo.pPoolSizes = imguiPoolSizes.data();
+	
 	if (vkCreateDescriptorPool(renderData.vkdevice.device, &imguiPoolInfo, nullptr,
-	                           &renderData.imguidpool)) {
+	                           &renderData.dpools[rvk::idximguipool])) {
 		return false;
 	}
 	ImGui_ImplSDL3_InitForVulkan(renderData.wind);
@@ -54,7 +54,7 @@ bool ui::init(vkobjs &renderData) {
 	imguiIinitInfo.PhysicalDevice = renderData.physdev.physical_device;
 	imguiIinitInfo.Device = renderData.vkdevice.device;
 	imguiIinitInfo.Queue = renderData.graphicsQ;
-	imguiIinitInfo.DescriptorPool = renderData.imguidpool;
+	imguiIinitInfo.DescriptorPool = renderData.dpools[rvk::idximguipool];
 	imguiIinitInfo.MinImageCount = 2;
 	imguiIinitInfo.ImageCount = renderData.schainimgs.size();
 	imguiIinitInfo.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
@@ -64,68 +64,6 @@ bool ui::init(vkobjs &renderData) {
 
 	ImGui_ImplVulkan_Init(&imguiIinitInfo);
 
-	VkCommandBuffer imguiCommandBuffer;
-
-	if (!commandbuffer::init(renderData, renderData.cpools[1], imguiCommandBuffer)) {
-		return false;
-	}
-
-	if (vkResetCommandBuffer(imguiCommandBuffer, 0) != VK_SUCCESS) {
-		return false;
-	}
-
-	VkCommandBufferBeginInfo cmdBeginInfo{};
-	cmdBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-	cmdBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-
-	if (vkBeginCommandBuffer(imguiCommandBuffer, &cmdBeginInfo) != VK_SUCCESS) {
-		return false;
-	}
-
-	renderData.mtx2->lock();
-	ImGui_ImplVulkan_CreateFontsTexture();
-	renderData.mtx2->unlock();
-
-	if (vkEndCommandBuffer(imguiCommandBuffer) != VK_SUCCESS) {
-		return false;
-	}
-
-	VkSubmitInfo submitInfo{};
-	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-	submitInfo.pWaitDstStageMask = nullptr;
-	submitInfo.waitSemaphoreCount = 0;
-	submitInfo.pWaitSemaphores = nullptr;
-	submitInfo.signalSemaphoreCount = 0;
-	submitInfo.pSignalSemaphores = nullptr;
-	submitInfo.commandBufferCount = 1;
-	submitInfo.pCommandBuffers = &imguiCommandBuffer;
-
-	VkFence imguiBufferFence;
-
-	VkFenceCreateInfo fenceInfo{};
-	fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
-
-	if (vkCreateFence(renderData.vkdevice.device, &fenceInfo, nullptr, &imguiBufferFence) != VK_SUCCESS) {
-		return false;
-	}
-
-	if (vkResetFences(renderData.vkdevice.device, 1, &imguiBufferFence) != VK_SUCCESS) {
-		return false;
-	}
-
-	renderData.mtx2->lock();
-	if (vkQueueSubmit(renderData.graphicsQ, 1, &submitInfo, imguiBufferFence) != VK_SUCCESS) {
-		return false;
-	}
-	renderData.mtx2->unlock();
-
-	if (vkWaitForFences(renderData.vkdevice.device, 1, &imguiBufferFence, VK_TRUE, UINT64_MAX) != VK_SUCCESS) {
-		return false;
-	}
-
-	vkDestroyFence(renderData.vkdevice.device, imguiBufferFence, nullptr);
-	commandbuffer::cleanup(renderData, renderData.cpools[1], imguiCommandBuffer);
 
 	ImGui::StyleColorsDark();
 
@@ -152,7 +90,7 @@ bool ui::init(vkobjs &renderData) {
 	return true;
 }
 
-void ui::createdbgframe(vkobjs &renderData, selection &settings) {
+void ui::createdbgframe(rvk &renderData, selection &settings) {
 	ImGui_ImplVulkan_NewFrame();
 	ImGui_ImplSDL3_NewFrame();
 	ImGui::NewFrame();
@@ -762,7 +700,7 @@ void ui::createdbgframe(vkobjs &renderData, selection &settings) {
 	}
 }
 
-bool ui::createloadingscreen(vkobjs &mvkobjs) {
+bool ui::createloadingscreen(rvk &mvkobjs) {
 
 	ImGui_ImplVulkan_NewFrame();
 	ImGui_ImplSDL3_NewFrame();
@@ -792,7 +730,7 @@ bool ui::createloadingscreen(vkobjs &mvkobjs) {
 	return true;
 }
 
-bool ui::createpausebuttons(vkobjs &mvkobjs) {
+bool ui::createpausebuttons(rvk &mvkobjs) {
 
 	ImGui_ImplVulkan_NewFrame();
 	ImGui_ImplSDL3_NewFrame();
@@ -869,7 +807,7 @@ void ui::addchat(std::string s) {
 	chattxts.push_back(s);
 }
 
-void ui::render(vkobjs &renderData, VkCommandBuffer &cbuffer) {
+void ui::render(rvk &renderData, VkCommandBuffer &cbuffer) {
 	ImGui::Render();
 
 	// renderData.mtx2.lock();
@@ -877,9 +815,8 @@ void ui::render(vkobjs &renderData, VkCommandBuffer &cbuffer) {
 	// renderData.mtx2.unlock();
 }
 
-void ui::cleanup(vkobjs &mvkobjs) {
+void ui::cleanup(rvk &mvkobjs) {
 	ImGui_ImplVulkan_Shutdown();
-	vkDestroyDescriptorPool(mvkobjs.vkdevice.device, mvkobjs.imguidpool, nullptr);
 	ImGui_ImplSDL3_Shutdown();
 	ImGui::DestroyContext();
 }
diff --git a/src/buffer/ssbo.cpp b/src/buffer/ssbo.cpp
deleted file mode 100644
index 14f8281..0000000
--- a/src/buffer/ssbo.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#include "ssbo.hpp"
-
-#include <VkBootstrap.h>
-
-bool ssbo::init(vkobjs &objs, ssbodata &SSBOData, size_t bufferSize) {
-	VkBufferCreateInfo bufferInfo{};
-	bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-	bufferInfo.size = bufferSize;
-	bufferInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-
-	VmaAllocationCreateInfo vmaAllocInfo{};
-	vmaAllocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-
-	if (vmaCreateBuffer(objs.alloc, &bufferInfo, &vmaAllocInfo, &SSBOData.buffer, &SSBOData.alloc,
-	                    nullptr) != VK_SUCCESS) {
-		return false;
-	}
-
-	VkDescriptorSetLayoutBinding ssboBind{};
-	ssboBind.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-	ssboBind.binding = 0;
-	ssboBind.descriptorCount = 1;
-	ssboBind.pImmutableSamplers = nullptr;
-	ssboBind.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
-
-	VkDescriptorSetLayoutCreateInfo ssboCreateInfo{};
-	ssboCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-	ssboCreateInfo.bindingCount = 1;
-	ssboCreateInfo.pBindings = &ssboBind;
-
-	if (vkCreateDescriptorSetLayout(objs.vkdevice.device, &ssboCreateInfo, nullptr,
-	                                &SSBOData.dlayout) != VK_SUCCESS) {
-		return false;
-	}
-
-	VkDescriptorPoolSize poolSize{};
-	poolSize.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-	poolSize.descriptorCount = bufferSize;
-
-	VkDescriptorPoolCreateInfo descriptorPool{};
-	descriptorPool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-	descriptorPool.poolSizeCount = 1;
-	descriptorPool.pPoolSizes = &poolSize;
-	descriptorPool.maxSets = 1;
-
-	if (vkCreateDescriptorPool(objs.vkdevice.device, &descriptorPool, nullptr, &SSBOData.dpool) !=
-	        VK_SUCCESS) {
-		return false;
-	}
-
-	VkDescriptorSetAllocateInfo descriptorAllocateInfo{};
-	descriptorAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-	descriptorAllocateInfo.descriptorPool = SSBOData.dpool;
-	descriptorAllocateInfo.descriptorSetCount = 1;
-	descriptorAllocateInfo.pSetLayouts = &SSBOData.dlayout;
-
-	if (vkAllocateDescriptorSets(objs.vkdevice.device, &descriptorAllocateInfo, &SSBOData.dset) !=
-	        VK_SUCCESS) {
-		return false;
-	}
-
-	VkDescriptorBufferInfo ssboInfo{};
-	ssboInfo.buffer = SSBOData.buffer;
-	ssboInfo.offset = 0;
-	ssboInfo.range = bufferSize;
-
-	VkWriteDescriptorSet writeDescriptorSet{};
-	writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-	writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-	writeDescriptorSet.dstSet = SSBOData.dset;
-	writeDescriptorSet.dstBinding = 0;
-	writeDescriptorSet.descriptorCount = 1;
-	writeDescriptorSet.pBufferInfo = &ssboInfo;
-
-	vkUpdateDescriptorSets(objs.vkdevice.device, 1, &writeDescriptorSet, 0, nullptr);
-
-	SSBOData.size = bufferSize;
-	return true;
-}
-
-void ssbo::upload(vkobjs &objs, ssbodata &ssbodata, std::vector<glm::mat4> mats) {
-	if (mats.size() == 0) {
-		return;
-	}
-
-	void *data;
-	vmaMapMemory(objs.alloc, ssbodata.alloc, &data);
-	std::memcpy(data, mats.data(), ssbodata.size);
-	vmaUnmapMemory(objs.alloc, ssbodata.alloc);
-}
-
-void ssbo::upload(vkobjs &objs, ssbodata &ssbodata, std::vector<glm::mat2x4> mats) {
-	if (mats.size() == 0) {
-		return;
-	}
-
-	void *data;
-	vmaMapMemory(objs.alloc, ssbodata.alloc, &data);
-	std::memcpy(data, mats.data(), ssbodata.size);
-	vmaUnmapMemory(objs.alloc, ssbodata.alloc);
-}
-void ssbo::upload(vkobjs &objs, ssbodata &ssbodata, const std::vector<double> &mats) {
-	if (mats.size() == 0) {
-		return;
-	}
-
-	void *data;
-	vmaMapMemory(objs.alloc, ssbodata.alloc, &data);
-	std::memcpy(data, mats.data(), ssbodata.size);
-	vmaUnmapMemory(objs.alloc, ssbodata.alloc);
-}
-
-void ssbo::cleanup(vkobjs &objs, ssbodata &ssbodata) {
-	vkDestroyDescriptorPool(objs.vkdevice.device, ssbodata.dpool, nullptr);
-	vkDestroyDescriptorSetLayout(objs.vkdevice.device, ssbodata.dlayout, nullptr);
-	vmaDestroyBuffer(objs.alloc, ssbodata.buffer, ssbodata.alloc);
-}
diff --git a/src/buffer/ssbomesh.cpp b/src/buffer/ssbomesh.cpp
deleted file mode 100644
index 1768ae5..0000000
--- a/src/buffer/ssbomesh.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "ssbomesh.hpp"
-
-#include <VkBootstrap.h>
-
-bool ssbomesh::init(vkobjs &objs, ssbodata &SSBOData) {
-	VkBufferCreateInfo bufferInfo{};
-	bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-	bufferInfo.size = 2; //////////////////////////////////////////////////////fix
-	bufferInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-
-	VmaAllocationCreateInfo vmaAllocInfo{};
-	vmaAllocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-
-	if (vmaCreateBuffer(objs.alloc, &bufferInfo, &vmaAllocInfo, &SSBOData.buffer, &SSBOData.alloc,
-	                    nullptr) != VK_SUCCESS) {
-		return false;
-	}
-
-	VkDescriptorSetLayoutBinding ssboBind{};
-	ssboBind.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-	ssboBind.binding = 0;
-	ssboBind.descriptorCount = 1;
-	ssboBind.pImmutableSamplers = nullptr;
-	ssboBind.stageFlags = VK_SHADER_STAGE_MESH_BIT_EXT;
-
-	VkDescriptorSetLayoutCreateInfo ssboCreateInfo{};
-	ssboCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-	ssboCreateInfo.bindingCount = 1;
-	ssboCreateInfo.pBindings = &ssboBind;
-
-	if (vkCreateDescriptorSetLayout(objs.vkdevice.device, &ssboCreateInfo, nullptr,
-	                                &SSBOData.dlayout) != VK_SUCCESS) {
-		return false;
-	}
-
-	VkDescriptorPoolSize poolSize{};
-	poolSize.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-	poolSize.descriptorCount = 1;
-
-	VkDescriptorPoolCreateInfo descriptorPool{};
-	descriptorPool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-	descriptorPool.poolSizeCount = 1;
-	descriptorPool.pPoolSizes = &poolSize;
-	descriptorPool.maxSets = 1;
-
-	if (vkCreateDescriptorPool(objs.vkdevice.device, &descriptorPool, nullptr, &SSBOData.dpool) !=
-	        VK_SUCCESS) {
-		return false;
-	}
-
-	VkDescriptorSetAllocateInfo descriptorAllocateInfo{};
-	descriptorAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-	descriptorAllocateInfo.descriptorPool = SSBOData.dpool;
-	descriptorAllocateInfo.descriptorSetCount = 1;
-	descriptorAllocateInfo.pSetLayouts = &SSBOData.dlayout;
-
-	if (vkAllocateDescriptorSets(objs.vkdevice.device, &descriptorAllocateInfo, &SSBOData.dset) !=
-	        VK_SUCCESS) {
-		return false;
-	}
-
-	VkDescriptorBufferInfo ssboInfo{};
-	ssboInfo.buffer = SSBOData.buffer;
-	ssboInfo.offset = 0;
-	ssboInfo.range = 2; //////////////////////////////////////////////////////////////fix
-
-	VkWriteDescriptorSet writeDescriptorSet{};
-	writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-	writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-	writeDescriptorSet.dstSet = SSBOData.dset;
-	writeDescriptorSet.dstBinding = 0;
-	writeDescriptorSet.descriptorCount = 1;
-	writeDescriptorSet.pBufferInfo = &ssboInfo;
-
-	vkUpdateDescriptorSets(objs.vkdevice.device, 1, &writeDescriptorSet, 0, nullptr);
-
-	SSBOData.size = 2; /////////////////////////////////////////////////////fix
-	return true;
-}
-
-void ssbomesh::upload(vkobjs &objs, ssbodata &ssbodata, std::vector<glm::mat4> &mats) {
-	if (mats.size() == 0) {
-		return;
-	}
-
-	void *data;
-	vmaMapMemory(objs.alloc, ssbodata.alloc, &data);
-	std::memcpy(data, mats.data(), ssbodata.size);
-	vmaUnmapMemory(objs.alloc, ssbodata.alloc);
-}
-
-void ssbomesh::upload(vkobjs &objs, ssbodata &ssbodata, std::vector<glm::mat2x4> mats) {
-	if (mats.size() == 0) {
-		return;
-	}
-
-	void *data;
-	vmaMapMemory(objs.alloc, ssbodata.alloc, &data);
-	std::memcpy(data, mats.data(), ssbodata.size);
-	vmaUnmapMemory(objs.alloc, ssbodata.alloc);
-}
-
-void ssbomesh::cleanup(vkobjs &objs, ssbodata &ssbodata) {
-	vkDestroyDescriptorPool(objs.vkdevice.device, ssbodata.dpool, nullptr);
-	vkDestroyDescriptorSetLayout(objs.vkdevice.device, ssbodata.dlayout, nullptr);
-	vmaDestroyBuffer(objs.alloc, ssbodata.buffer, ssbodata.alloc);
-}
diff --git a/src/buffer/ubo.cpp b/src/buffer/ubo.cpp
index 531a2e6..723230b 100644
--- a/src/buffer/ubo.cpp
+++ b/src/buffer/ubo.cpp
@@ -1,7 +1,7 @@
 #include "ubo.hpp"
 #include <VkBootstrap.h>
 
-bool ubo::init(vkobjs &mvkobjs, std::vector<ubodata> &ubodata) {
+bool ubo::init(rvk &mvkobjs, std::vector<ubodata> &ubodata) {
 	ubodata.reserve(2);
 	ubodata.resize(2);
 
@@ -22,47 +22,12 @@ bool ubo::init(vkobjs &mvkobjs, std::vector<ubodata> &ubodata) {
 			return false;
 	}
 
-	std::vector<VkDescriptorSetLayoutBinding> ubobind(2);
-	ubobind[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-	ubobind[0].binding = 0;
-	ubobind[0].descriptorCount = 1;
-	ubobind[0].pImmutableSamplers = nullptr;
-	ubobind[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
-
-	ubobind[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-	ubobind[1].binding = 1;
-	ubobind[1].descriptorCount = 1;
-	ubobind[1].pImmutableSamplers = nullptr;
-	ubobind[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-
-	VkDescriptorSetLayoutCreateInfo uboinfo{};
-	uboinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-	uboinfo.bindingCount = 2;
-	uboinfo.pBindings = &ubobind.at(0);
-
-	if (vkCreateDescriptorSetLayout(mvkobjs.vkdevice.device, &uboinfo, nullptr, &ubodata[0].dlayout) !=
-	        VK_SUCCESS)
-		return false;
-
-	VkDescriptorPoolSize poolsize{};
-	poolsize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-	poolsize.descriptorCount = 1 * (ubodata.size() * sizeof(glm::mat4) + sizeof(unsigned int));
-
-	VkDescriptorPoolCreateInfo dpoolinfo{};
-	dpoolinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-	dpoolinfo.poolSizeCount = 1;
-	dpoolinfo.pPoolSizes = &poolsize;
-	dpoolinfo.maxSets = 1;
-
-	if (vkCreateDescriptorPool(mvkobjs.vkdevice.device, &dpoolinfo, nullptr, &ubodata[0].dpool) !=
-	        VK_SUCCESS)
-		return false;
 
 	VkDescriptorSetAllocateInfo dallocinfo{};
 	dallocinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-	dallocinfo.descriptorPool = ubodata[0].dpool;
+	dallocinfo.descriptorPool = mvkobjs.dpools[rvk::idxinitpool];
 	dallocinfo.descriptorSetCount = 1;
-	dallocinfo.pSetLayouts = &ubodata[0].dlayout;
+	dallocinfo.pSetLayouts = &rvk::ubolayout;
 
 	if (vkAllocateDescriptorSets(mvkobjs.vkdevice.device, &dallocinfo, &ubodata[0].dset) != VK_SUCCESS)
 		return false;
@@ -94,24 +59,41 @@ bool ubo::init(vkobjs &mvkobjs, std::vector<ubodata> &ubodata) {
 
 	return true;
 }
-void ubo::upload(vkobjs &mvkobjs, std::vector<ubodata> &ubodata, std::vector<glm::mat4> mats, unsigned int texidx) {
+bool ubo::createlayout(rvk &mvkobjs,VkDescriptorSetLayout& dlayout){
+	std::vector<VkDescriptorSetLayoutBinding> ubobind(2);
+	ubobind[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+	ubobind[0].binding = 0;
+	ubobind[0].descriptorCount = 1;
+	ubobind[0].pImmutableSamplers = nullptr;
+	ubobind[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+
+	ubobind[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+	ubobind[1].binding = 1;
+	ubobind[1].descriptorCount = 1;
+	ubobind[1].pImmutableSamplers = nullptr;
+	ubobind[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+
+
+	VkDescriptorSetLayoutCreateInfo uboinfo{};
+	uboinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+	uboinfo.bindingCount = 2;
+	uboinfo.pBindings = ubobind.data();
+
+	if (vkCreateDescriptorSetLayout(mvkobjs.vkdevice.device, &uboinfo, nullptr, &dlayout) !=
+	        VK_SUCCESS)
+		return false;
+	return true;
+		
+}
+void ubo::upload(rvk &mvkobjs, std::vector<ubodata> &ubodata, std::vector<glm::mat4> mats) {
 	void *data;
 	vmaMapMemory(mvkobjs.alloc, ubodata[0].alloc, &data);
 	std::memcpy(data, mats.data(), ubodata[0].size);
 	vmaUnmapMemory(mvkobjs.alloc, ubodata[0].alloc);
 }
 
-void ubo::upload(vkobjs &mvkobjs, std::vector<ubodata> &ubodata, unsigned int texidx) {
-	void *data;
-	vmaMapMemory(mvkobjs.alloc, ubodata[1].alloc, &data);
-	std::memcpy(data, &texidx, ubodata[1].size);
-	vmaUnmapMemory(mvkobjs.alloc, ubodata[1].alloc);
-}
-
-void ubo::cleanup(vkobjs &mvkobjs, std::vector<ubodata> &ubodata) {
+void ubo::cleanup(rvk &mvkobjs, std::vector<ubodata> &ubodata) {
 	for (size_t i{0}; i < ubodata.size(); i++) {
-		vkDestroyDescriptorPool(mvkobjs.vkdevice.device, ubodata[i].dpool, nullptr);
-		vkDestroyDescriptorSetLayout(mvkobjs.vkdevice.device, ubodata[i].dlayout, nullptr);
 		vmaDestroyBuffer(mvkobjs.alloc, ubodata[i].buffer, ubodata[i].alloc);
 	}
 }
diff --git a/src/buffer/vkebo.cpp b/src/buffer/vkebo.cpp
index ee5cb96..b914510 100644
--- a/src/buffer/vkebo.cpp
+++ b/src/buffer/vkebo.cpp
@@ -1,7 +1,7 @@
 #include "vkebo.hpp"
 #include <cstring>
 
-bool vkebo::init(vkobjs &objs, ebodata &indexbufferdata, size_t buffersize) {
+bool vkebo::init(rvk &objs, ebodata &indexbufferdata, size_t buffersize) {
 	VkBufferCreateInfo binfo{};
 	binfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
 	binfo.size = buffersize;
@@ -32,7 +32,7 @@ bool vkebo::init(vkobjs &objs, ebodata &indexbufferdata, size_t buffersize) {
 	return true;
 }
 
-bool vkebo::upload(vkobjs &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferdata,
+bool vkebo::upload(rvk &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferdata,
                    std::vector<unsigned short> indicez) {
 
 	void *d;
@@ -62,7 +62,7 @@ bool vkebo::upload(vkobjs &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferd
 	return true;
 }
 
-bool vkebo::upload(vkobjs &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferdata, const fastgltf::Buffer &buffer,
+bool vkebo::upload(rvk &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferdata, const fastgltf::Buffer &buffer,
                    const fastgltf::BufferView &bufferview, const size_t &count) {
 
 	std::visit(fastgltf::visitor{[](auto &arg) {},
@@ -97,7 +97,7 @@ bool vkebo::upload(vkobjs &objs, VkCommandBuffer &cbuffer, ebodata &indexbufferd
 	return true;
 }
 
-void vkebo::cleanup(vkobjs &objs, ebodata &indexbufferdata) {
+void vkebo::cleanup(rvk &objs, ebodata &indexbufferdata) {
 	vmaDestroyBuffer(objs.alloc, indexbufferdata.sbuffer, indexbufferdata.salloc);
 	vmaDestroyBuffer(objs.alloc, indexbufferdata.buffer, indexbufferdata.alloc);
 }
diff --git a/src/buffer/vkvbo.cpp b/src/buffer/vkvbo.cpp
index 658be74..1e6d0c0 100644
--- a/src/buffer/vkvbo.cpp
+++ b/src/buffer/vkvbo.cpp
@@ -1,6 +1,6 @@
 #include "vkvbo.hpp"
 
-bool vkvbo::init(vkobjs &mvkobjs, vbodata &vbdata, size_t bsize) {
+bool vkvbo::init(rvk &mvkobjs, vbodata &vbdata, size_t bsize) {
 	VkBufferCreateInfo binfo{};
 	binfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
 	binfo.size = bsize;
@@ -30,7 +30,7 @@ bool vkvbo::init(vkobjs &mvkobjs, vbodata &vbdata, size_t bsize) {
 	return true;
 }
 
-bool vkvbo::upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
+bool vkvbo::upload(rvk &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
                    std::vector<glm::vec3> vertexData) {
 
 	/* copy data to staging buffer*/
@@ -61,7 +61,7 @@ bool vkvbo::upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
 	return true;
 }
 
-bool vkvbo::upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
+bool vkvbo::upload(rvk &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
                    std::vector<glm::vec2> vertexData) {
 
 	void *data;
@@ -91,7 +91,7 @@ bool vkvbo::upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
 	return true;
 }
 
-bool vkvbo::upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
+bool vkvbo::upload(rvk &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
                    const fastgltf::Buffer &buffer, const fastgltf::BufferView &bufferview,
                    const fastgltf::Accessor &acc) {
 
@@ -127,7 +127,7 @@ bool vkvbo::upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
 	return true;
 }
 
-bool vkvbo::upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
+bool vkvbo::upload(rvk &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
                    const std::vector<unsigned int> &jointz, const unsigned int count, const unsigned int ofx) {
 
 	void *d;
@@ -158,7 +158,7 @@ bool vkvbo::upload(vkobjs &mvkobjs, VkCommandBuffer &cbuffer, vbodata &vbdata,
 	return true;
 }
 
-void vkvbo::cleanup(vkobjs &mvkobjs, vbodata &vbdata) {
+void vkvbo::cleanup(rvk &mvkobjs, vbodata &vbdata) {
 	vmaDestroyBuffer(mvkobjs.alloc, vbdata.sbuffer, vbdata.salloc);
 	vmaDestroyBuffer(mvkobjs.alloc, vbdata.buffer, vbdata.alloc);
 }
diff --git a/src/core/vkrenderer.cpp b/src/core/vkrenderer.cpp
index c9d3290..7dce78b 100644
--- a/src/core/vkrenderer.cpp
+++ b/src/core/vkrenderer.cpp
@@ -4,6 +4,7 @@
 // #define _DEBUG
 
 #include "vkrenderer.hpp"
+#include "exp/particle.hpp"
 
 #include <backends/imgui_impl_glfw.h>
 #include <imgui.h>
@@ -17,9 +18,9 @@
 #include <glm/gtx/spline.hpp>
 #include <iostream>
 
-#include "commandbuffer.hpp"
-#include "commandpool.hpp"
-#include "framebuffer.hpp"
+#include "vk/commandbuffer.hpp"
+#include "vk/commandpool.hpp"
+#include "vk/framebuffer.hpp"
 #include "renderpass.hpp"
 #include "vksyncobjects.hpp"
 // #ifdef _DEBUG
@@ -28,6 +29,9 @@
 #include <SDL3/SDL_vulkan.h>
 // #include <unistd.h>
 
+#include "exp/particle.hpp"
+
+
 float map2(glm::vec3 x) {
 	return std::max(x.y, 0.0f);
 }
@@ -51,7 +55,7 @@ bool vkrenderer::init() {
 			createswapchain() && createdepthbuffer() &&
 			createcommandpool() && createcommandbuffer() &&
 			createrenderpass() && createframebuffer() &&
-			createsyncobjects();
+			createsyncobjects() && createpools();
 		},
 	}))
 	return false;
@@ -91,12 +95,14 @@ bool vkrenderer::initscene() {
 	playercount.clear();
 	playercount.shrink_to_fit();
 
+	if(!particle::createeverything(mvkobjs))return false;
+
 	return true;
 }
 ui *vkrenderer::getuihandle() {
 	return &mui;
 }
-vkobjs &vkrenderer::getvkobjs() {
+rvk &vkrenderer::getvkobjs() {
 	return mvkobjs;
 }
 bool vkrenderer::quicksetup() {
@@ -107,9 +113,9 @@ bool vkrenderer::quicksetup() {
 bool vkrenderer::deviceinit() {
 	vkb::InstanceBuilder instbuild{};
 
-	auto instret = instbuild.use_default_debug_messenger().request_validation_layers().require_api_version(1, 4).build();
+	auto instret = instbuild.use_default_debug_messenger().request_validation_layers().require_api_version(1, 3).build();
 
-	if(!instret){
+	if(!instret) {
 		std::cout << instret.full_error().type << std::endl;
 		std::cout << instret.full_error().vk_result << std::endl;
 		return false;
@@ -119,9 +125,13 @@ bool vkrenderer::deviceinit() {
 
 	bool res{false};
 	res = SDL_Vulkan_CreateSurface(mvkobjs.wind, mvkobjs.inst, nullptr, &msurface);
+	if(!res) {
+		std::cout << "SDL failed to create surface" << std::endl;
+		return false;
+	}
 
 	vkb::PhysicalDeviceSelector physicaldevsel{mvkobjs.inst};
-	auto firstphysicaldevselret = physicaldevsel.set_surface(msurface).set_minimum_version(1, 4).select();
+	auto firstphysicaldevselret = physicaldevsel.set_surface(msurface).set_minimum_version(1, 3).select();
 
 	VkPhysicalDeviceVulkan14Features physfeatures14;
 	VkPhysicalDeviceVulkan13Features physfeatures13;
@@ -142,7 +152,7 @@ bool vkrenderer::deviceinit() {
 	physfeatures14.pNext = VK_NULL_HANDLE;
 
 	vkGetPhysicalDeviceFeatures2(firstphysicaldevselret.value(), &physfeatures);
-	auto secondphysicaldevselret = physicaldevsel.set_minimum_version(1, 4)
+	auto secondphysicaldevselret = physicaldevsel.set_minimum_version(1, 3)
 	                               .set_surface(msurface)
 	                               .set_required_features(physfeatures.features)
 	                               .set_required_features_11(physfeatures11)
@@ -189,6 +199,10 @@ bool vkrenderer::getqueue() {
 
 	return true;
 }
+bool vkrenderer::createpools(){
+	std::array<VkDescriptorPoolSize,3> poolz{{{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,24},{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,2},{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,1}}};
+	return rpool::create(poolz,mvkobjs.vkdevice.device, &mvkobjs.dpools[rvk::idxinitpool]);
+}
 bool vkrenderer::createdepthbuffer() {
 	VkExtent3D depthimageextent = {mvkobjs.schain.extent.width, mvkobjs.schain.extent.height, 1};
 
@@ -253,7 +267,7 @@ bool vkrenderer::recreateswapchain() {
 	SDL_GetWindowSize(mvkobjs.wind, &mvkobjs.width, &mvkobjs.height);
 
 	vkDeviceWaitIdle(mvkobjs.vkdevice.device);
-	framebuffer::cleanup(mvkobjs);
+	framebuffer::destroy(mvkobjs.vkdevice.device,mvkobjs.fbuffers);
 	vkDestroyImageView(mvkobjs.vkdevice.device, mvkobjs.rddepthimageview, nullptr);
 	vmaDestroyImage(mvkobjs.alloc, mvkobjs.rddepthimage, mvkobjs.rddepthimagealloc);
 
@@ -277,23 +291,21 @@ bool vkrenderer::createrenderpass() {
 	return true;
 }
 bool vkrenderer::createframebuffer() {
-	if (!framebuffer::init(mvkobjs))
+	if (!framebuffer::create(mvkobjs))
 		return false;
 	return true;
 }
 bool vkrenderer::createcommandpool() {
-	if (!commandpool::init(mvkobjs, mvkobjs.cpools[0]))
-		return false;
-	if (!commandpool::init(mvkobjs, mvkobjs.cpools[1]))
+	if (!commandpool::createsametype(mvkobjs, mvkobjs.cpools_graphics,vkb::QueueType::graphics))
 		return false;
-	if (!commandpool::init(mvkobjs, mvkobjs.cpools[2]))
+	if (!commandpool::createsametype(mvkobjs, mvkobjs.cpools_compute,vkb::QueueType::compute))
 		return false;
 	return true;
 }
 bool vkrenderer::createcommandbuffer() {
-	if (!commandbuffer::init(mvkobjs, mvkobjs.cpools[0], mvkobjs.cbuffers[0]))
+	if (!commandbuffer::create(mvkobjs, mvkobjs.cpools_graphics.at(0), mvkobjs.cbuffers_graphics))
 		return false;
-	if (!commandbuffer::init(mvkobjs, mvkobjs.cpools[1], mvkobjs.cbuffers[1]))
+	if (!commandbuffer::create(mvkobjs, mvkobjs.cpools_compute.at(0), mvkobjs.cbuffers_compute))
 		return false;
 	return true;
 }
@@ -310,18 +322,23 @@ bool vkrenderer::initui() {
 void vkrenderer::cleanup() {
 	vkDeviceWaitIdle(mvkobjs.vkdevice.device);
 
-	commandbuffer::cleanup(mvkobjs, mvkobjs.cpools[1], mvkobjs.cbuffers[1]);
-	commandpool::cleanup(mvkobjs, mvkobjs.cpools[1]);
+	particle::destroyeveryting(mvkobjs);
+
 
-	for (const auto &i : mplayer)
-		i->cleanupmodels(mvkobjs);
 	mui.cleanup(mvkobjs);
 
 	vksyncobjects::cleanup(mvkobjs);
-	commandbuffer::cleanup(mvkobjs, mvkobjs.cpools[0], mvkobjs.cbuffers[0]);
-	commandpool::cleanup(mvkobjs, mvkobjs.cpools[0]);
-	commandpool::cleanup(mvkobjs, mvkobjs.cpools[2]);
-	framebuffer::cleanup(mvkobjs);
+	commandbuffer::destroy(mvkobjs, mvkobjs.cpools_graphics.at(0), mvkobjs.cbuffers_graphics);
+	commandbuffer::destroy(mvkobjs, mvkobjs.cpools_compute.at(0), mvkobjs.cbuffers_compute);
+	commandpool::destroy(mvkobjs, mvkobjs.cpools_graphics);
+	commandpool::destroy(mvkobjs, mvkobjs.cpools_compute);
+	for(auto& x:mvkobjs.dpools)
+	rpool::destroy(mvkobjs.vkdevice.device,x);
+	framebuffer::destroy(mvkobjs.vkdevice.device,mvkobjs.fbuffers);
+
+	vkDestroyDescriptorSetLayout(mvkobjs.vkdevice.device,rvk::ubolayout,nullptr);
+	vkDestroyDescriptorSetLayout(mvkobjs.vkdevice.device,*rvk::texlayout,nullptr);
+	vkDestroyDescriptorSetLayout(mvkobjs.vkdevice.device,rvk::ssbolayout,nullptr);
 
 	for (const auto &i : mplayer)
 		i->cleanuplines(mvkobjs);
@@ -329,6 +346,9 @@ void vkrenderer::cleanup() {
 	renderpass::cleanup(mvkobjs);
 	for (const auto &i : mplayer)
 		i->cleanupbuffers(mvkobjs);
+		
+	for (const auto &i : mplayer)
+		i->cleanupmodels(mvkobjs);
 
 	vkDestroyImageView(mvkobjs.vkdevice.device, mvkobjs.rddepthimageview, nullptr);
 	vmaDestroyImage(mvkobjs.alloc, mvkobjs.rddepthimage, mvkobjs.rddepthimagealloc);
@@ -368,23 +388,23 @@ bool vkrenderer::uploadfordraw() {
 	VkResult res = vkAcquireNextImageKHR(mvkobjs.vkdevice.device, mvkobjs.schain.swapchain, UINT64_MAX,
 	                                     mvkobjs.presentsemaphore, VK_NULL_HANDLE, &imgidx);
 
-	if (vkResetCommandBuffer(mvkobjs.cbuffers[0], 0) != VK_SUCCESS)
+	if (vkResetCommandBuffer(mvkobjs.cbuffers_graphics.at(0), 0) != VK_SUCCESS)
 		return false;
 
 	VkCommandBufferBeginInfo cmdbgninfo{};
 	cmdbgninfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 	cmdbgninfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
-	if (vkBeginCommandBuffer(mvkobjs.cbuffers[0], &cmdbgninfo) != VK_SUCCESS)
+	if (vkBeginCommandBuffer(mvkobjs.cbuffers_graphics.at(0), &cmdbgninfo) != VK_SUCCESS)
 		return false;
 
 	manimupdatetimer.start();
 
 	for (const auto &i : mplayer)
-		i->uploadvboebo(mvkobjs, mvkobjs.cbuffers[0]);
+		i->uploadvboebo(mvkobjs, mvkobjs.cbuffers_graphics.at(0));
 
 	mvkobjs.uploadubossbotime = manimupdatetimer.stop();
-	if (vkEndCommandBuffer(mvkobjs.cbuffers[0]) != VK_SUCCESS)
+	if (vkEndCommandBuffer(mvkobjs.cbuffers_graphics.at(0)) != VK_SUCCESS)
 		return false;
 
 	VkSubmitInfo submitinfo{};
@@ -400,7 +420,7 @@ bool vkrenderer::uploadfordraw() {
 	submitinfo.pSignalSemaphores = &mvkobjs.rendersemaphore;
 
 	submitinfo.commandBufferCount = 1;
-	submitinfo.pCommandBuffers = &mvkobjs.cbuffers.at(0);
+	submitinfo.pCommandBuffers = &mvkobjs.cbuffers_graphics.at(0);
 
 	VkSemaphoreWaitInfo swinfo{};
 	swinfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
@@ -453,22 +473,22 @@ bool vkrenderer::uploadfordraw(std::shared_ptr<playoutgeneric> &x) {
 	VkResult res = vkAcquireNextImageKHR(mvkobjs.vkdevice.device, mvkobjs.schain.swapchain, UINT64_MAX,
 	                                     mvkobjs.presentsemaphore, VK_NULL_HANDLE, &imgidx);
 
-	if (vkResetCommandBuffer(mvkobjs.cbuffers[0], 0) != VK_SUCCESS)
+	if (vkResetCommandBuffer(mvkobjs.cbuffers_graphics.at(0), 0) != VK_SUCCESS)
 		return false;
 
 	VkCommandBufferBeginInfo cmdbgninfo{};
 	cmdbgninfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 	cmdbgninfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
-	if (vkBeginCommandBuffer(mvkobjs.cbuffers[0], &cmdbgninfo) != VK_SUCCESS)
+	if (vkBeginCommandBuffer(mvkobjs.cbuffers_graphics.at(0), &cmdbgninfo) != VK_SUCCESS)
 		return false;
 
 	manimupdatetimer.start();
 
-	x->uploadvboebo(mvkobjs, mvkobjs.cbuffers[0]);
+	x->uploadvboebo(mvkobjs, mvkobjs.cbuffers_graphics.at(0));
 
 	mvkobjs.uploadubossbotime = manimupdatetimer.stop();
-	if (vkEndCommandBuffer(mvkobjs.cbuffers[0]) != VK_SUCCESS)
+	if (vkEndCommandBuffer(mvkobjs.cbuffers_graphics.at(0)) != VK_SUCCESS)
 		return false;
 
 	VkSubmitInfo submitinfo{};
@@ -484,12 +504,7 @@ bool vkrenderer::uploadfordraw(std::shared_ptr<playoutgeneric> &x) {
 	submitinfo.pSignalSemaphores = &mvkobjs.rendersemaphore;
 
 	submitinfo.commandBufferCount = 1;
-	submitinfo.pCommandBuffers = &mvkobjs.cbuffers.at(0);
-
-	// VkSemaphoreWaitInfo swinfo{};
-	// swinfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
-	// swinfo.pSemaphores = &mvkobjs.rdpresentsemaphore;
-	// swinfo.semaphoreCount = 1;
+	submitinfo.pCommandBuffers = &mvkobjs.cbuffers_graphics.at(0);
 
 	mvkobjs.mtx2->lock();
 	if (vkQueueSubmit(mvkobjs.graphicsQ, 1, &submitinfo, mvkobjs.renderfence) != VK_SUCCESS) {
@@ -508,7 +523,7 @@ bool vkrenderer::uploadfordraw(std::shared_ptr<playoutgeneric> &x) {
 	presentinfo.pImageIndices = &imgidx;
 
 	mvkobjs.mtx2->lock();
-	size_t res2 = vkQueuePresentKHR(mvkobjs.presentQ, &presentinfo);
+	VkResult res2 = vkQueuePresentKHR(mvkobjs.presentQ, &presentinfo);
 
 	mvkobjs.mtx2->unlock();
 
@@ -763,6 +778,13 @@ void vkrenderer::updateanims() {
 }
 
 bool vkrenderer::draw() {
+
+
+
+	particle::drawcomp(mvkobjs);
+
+
+
 	double tick = static_cast<double>(SDL_GetTicks()) / 1000.0;
 	mvkobjs.tickdiff = tick - mlasttick;
 	mvkobjs.frametime = mframetimer.stop();
@@ -823,13 +845,15 @@ bool vkrenderer::draw() {
 		}
 	}
 
-	VkClearValue colorclearvalue;
-	colorclearvalue.color = {{0.0f, 0.0f, 0.0f, 0.0f}};
-
-	VkClearValue depthvalue;
-	depthvalue.depthStencil.depth = 1.0f;
-
-	VkClearValue clearvals[] = {colorclearvalue, depthvalue};
+	std::array<VkClearValue, 2> colorclearvalue{
+		VkClearValue{.color={0.0f, 0.0f, 0.0f, 1.0f}},//no idea why i have to put VkClearValue here but not in the secon one, doesnt work without it
+		{.depthStencil={1.0f,0}}
+	};
+	
+	// VkRenderingInfo rinfo{};
+	// rinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
+	// rinfo.renderArea.extent = mvkobjs.schain.extent;
+	// rinfo.renderArea.offset = {0, 0};
 
 	VkRenderPassBeginInfo rpinfo{};
 	rpinfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
@@ -841,7 +865,7 @@ bool vkrenderer::draw() {
 	rpinfo.framebuffer = mvkobjs.fbuffers[imgidx];
 
 	rpinfo.clearValueCount = 2;
-	rpinfo.pClearValues = clearvals;
+	rpinfo.pClearValues = colorclearvalue.data();
 
 	VkViewport viewport{};
 	viewport.x = 0.0f;
@@ -855,7 +879,7 @@ bool vkrenderer::draw() {
 	scissor.offset = {0, 0};
 	scissor.extent = mvkobjs.schain.extent;
 
-	if (vkResetCommandBuffer(mvkobjs.cbuffers[0], 0) != VK_SUCCESS)
+	if (vkResetCommandBuffer(mvkobjs.cbuffers_graphics.at(0), 0) != VK_SUCCESS)
 		return false;
 
 	sdlevent(mvkobjs.e);
@@ -864,13 +888,22 @@ bool vkrenderer::draw() {
 	cmdbgninfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 	cmdbgninfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
-	if (vkBeginCommandBuffer(mvkobjs.cbuffers[0], &cmdbgninfo) != VK_SUCCESS)
+	if (vkBeginCommandBuffer(mvkobjs.cbuffers_graphics.at(0), &cmdbgninfo) != VK_SUCCESS)
 		return false;
 
-	vkCmdBeginRenderPass(mvkobjs.cbuffers[0], &rpinfo, VK_SUBPASS_CONTENTS_INLINE);
+	vkCmdBeginRenderPass(mvkobjs.cbuffers_graphics.at(0), &rpinfo, VK_SUBPASS_CONTENTS_INLINE);
+	// try switching to rendering instead of renderpass
+	// vkCmdBeginRendering()
+
+	vkCmdSetViewport(mvkobjs.cbuffers_graphics.at(0), 0, 1, &viewport);
+	vkCmdSetScissor(mvkobjs.cbuffers_graphics.at(0), 0, 1, &scissor);
+
+	VkDeviceSize coffsets{0};
+	vkCmdBindPipeline(mvkobjs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, particle::gpline);
+	vkCmdBindVertexBuffers(mvkobjs.cbuffers_graphics.at(0),0,1,&particle::ssbobuffsnallocs.at(0).first,&coffsets);
+	vkCmdDraw(mvkobjs.cbuffers_graphics.at(0),8192,1,0,0);
+
 
-	vkCmdSetViewport(mvkobjs.cbuffers[0], 0, 1, &viewport);
-	vkCmdSetScissor(mvkobjs.cbuffers[0], 0, 1, &scissor);
 	for (const auto &i : mplayer)
 		i->draw(mvkobjs);
 
@@ -879,9 +912,14 @@ bool vkrenderer::draw() {
 
 	mui.createdbgframe(mvkobjs, selectiondata);
 
-	mui.render(mvkobjs, mvkobjs.cbuffers[0]);
 
-	vkCmdEndRenderPass(mvkobjs.cbuffers[0]);
+
+
+
+
+	mui.render(mvkobjs, mvkobjs.cbuffers_graphics.at(0));
+
+	vkCmdEndRenderPass(mvkobjs.cbuffers_graphics.at(0));
 
 	// animmtx.lock();
 	// updatemtx.lock();
@@ -893,7 +931,7 @@ bool vkrenderer::draw() {
 
 	mvkobjs.uploadubossbotime = muploadubossbotimer.stop();
 
-	if (vkEndCommandBuffer(mvkobjs.cbuffers[0]) != VK_SUCCESS)
+	if (vkEndCommandBuffer(mvkobjs.cbuffers_graphics.at(0)) != VK_SUCCESS)
 		return false;
 
 	movecam();
@@ -903,15 +941,15 @@ bool vkrenderer::draw() {
 
 	VkPipelineStageFlags waitstage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 	submitinfo.pWaitDstStageMask = &waitstage;
-
-	submitinfo.waitSemaphoreCount = 1;
-	submitinfo.pWaitSemaphores = &mvkobjs.presentsemaphore;
+	std::array<VkSemaphore,2> waitsemas{mvkobjs.presentsemaphore,particle::computeFinishedSemaphores.at(0)};
+	submitinfo.waitSemaphoreCount = 2;
+	submitinfo.pWaitSemaphores = waitsemas.data();
 
 	submitinfo.signalSemaphoreCount = 1;
 	submitinfo.pSignalSemaphores = &mvkobjs.rendersemaphore;
 
 	submitinfo.commandBufferCount = 1;
-	submitinfo.pCommandBuffers = &mvkobjs.cbuffers.at(0);
+	submitinfo.pCommandBuffers = &mvkobjs.cbuffers_graphics.at(0);
 
 	mvkobjs.mtx2->lock();
 	if (vkQueueSubmit(mvkobjs.graphicsQ, 1, &submitinfo, mvkobjs.renderfence) != VK_SUCCESS) {
@@ -996,27 +1034,27 @@ bool vkrenderer::drawloading() {
 	scissor.offset = {0, 0};
 	scissor.extent = mvkobjs.schain.extent;
 
-	if (vkResetCommandBuffer(mvkobjs.cbuffers[1], 0) != VK_SUCCESS)
+	if (vkResetCommandBuffer(mvkobjs.cbuffers_compute.at(0), 0) != VK_SUCCESS)
 		return false;
 
 	VkCommandBufferBeginInfo cmdbgninfo{};
 	cmdbgninfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 	cmdbgninfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
-	if (vkBeginCommandBuffer(mvkobjs.cbuffers[1], &cmdbgninfo) != VK_SUCCESS)
+	if (vkBeginCommandBuffer(mvkobjs.cbuffers_compute.at(0), &cmdbgninfo) != VK_SUCCESS)
 		return false;
 
-	vkCmdBeginRenderPass(mvkobjs.cbuffers[1], &rpinfo, VK_SUBPASS_CONTENTS_INLINE);
+	vkCmdBeginRenderPass(mvkobjs.cbuffers_compute.at(0), &rpinfo, VK_SUBPASS_CONTENTS_INLINE);
 
-	vkCmdSetViewport(mvkobjs.cbuffers[1], 0, 1, &viewport);
-	vkCmdSetScissor(mvkobjs.cbuffers[1], 0, 1, &scissor);
+	vkCmdSetViewport(mvkobjs.cbuffers_compute.at(0), 0, 1, &viewport);
+	vkCmdSetScissor(mvkobjs.cbuffers_compute.at(0), 0, 1, &scissor);
 
 	rdscene = mui.createloadingscreen(mvkobjs);
-	mui.render(mvkobjs, mvkobjs.cbuffers[1]);
+	mui.render(mvkobjs, mvkobjs.cbuffers_compute.at(0));
 
-	vkCmdEndRenderPass(mvkobjs.cbuffers[1]);
+	vkCmdEndRenderPass(mvkobjs.cbuffers_compute.at(0));
 
-	if (vkEndCommandBuffer(mvkobjs.cbuffers[1]) != VK_SUCCESS)
+	if (vkEndCommandBuffer(mvkobjs.cbuffers_compute.at(0)) != VK_SUCCESS)
 		return false;
 
 	VkSubmitInfo submitinfo{};
@@ -1032,7 +1070,7 @@ bool vkrenderer::drawloading() {
 	submitinfo.pSignalSemaphores = &mvkobjs.rendersemaphore;
 
 	submitinfo.commandBufferCount = 1;
-	submitinfo.pCommandBuffers = &mvkobjs.cbuffers[1];
+	submitinfo.pCommandBuffers = &mvkobjs.cbuffers_compute.at(0);
 
 	mvkobjs.mtx2->lock();
 	if (vkQueueSubmit(mvkobjs.graphicsQ, 1, &submitinfo, mvkobjs.renderfence) != VK_SUCCESS) {
@@ -1113,24 +1151,24 @@ bool vkrenderer::drawblank() {
 	scissor.offset = {0, 0};
 	scissor.extent = mvkobjs.schain.extent;
 
-	if (vkResetCommandBuffer(mvkobjs.cbuffers[0], 0) != VK_SUCCESS)
+	if (vkResetCommandBuffer(mvkobjs.cbuffers_graphics.at(0), 0) != VK_SUCCESS)
 		return false;
 
 	VkCommandBufferBeginInfo cmdbgninfo{};
 	cmdbgninfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 	cmdbgninfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
-	if (vkBeginCommandBuffer(mvkobjs.cbuffers[0], &cmdbgninfo) != VK_SUCCESS)
+	if (vkBeginCommandBuffer(mvkobjs.cbuffers_graphics.at(0), &cmdbgninfo) != VK_SUCCESS)
 		return false;
 
-	vkCmdBeginRenderPass(mvkobjs.cbuffers[0], &rpinfo, VK_SUBPASS_CONTENTS_INLINE);
+	vkCmdBeginRenderPass(mvkobjs.cbuffers_graphics.at(0), &rpinfo, VK_SUBPASS_CONTENTS_INLINE);
 
-	vkCmdSetViewport(mvkobjs.cbuffers[0], 0, 1, &viewport);
-	vkCmdSetScissor(mvkobjs.cbuffers[0], 0, 1, &scissor);
+	vkCmdSetViewport(mvkobjs.cbuffers_graphics.at(0), 0, 1, &viewport);
+	vkCmdSetScissor(mvkobjs.cbuffers_graphics.at(0), 0, 1, &scissor);
 
-	vkCmdEndRenderPass(mvkobjs.cbuffers[0]);
+	vkCmdEndRenderPass(mvkobjs.cbuffers_graphics.at(0));
 
-	if (vkEndCommandBuffer(mvkobjs.cbuffers[0]) != VK_SUCCESS)
+	if (vkEndCommandBuffer(mvkobjs.cbuffers_graphics.at(0)) != VK_SUCCESS)
 		return false;
 
 	VkSubmitInfo submitinfo{};
@@ -1146,7 +1184,7 @@ bool vkrenderer::drawblank() {
 	submitinfo.pSignalSemaphores = &mvkobjs.rendersemaphore;
 
 	submitinfo.commandBufferCount = 1;
-	submitinfo.pCommandBuffers = &mvkobjs.cbuffers[0];
+	submitinfo.pCommandBuffers = &mvkobjs.cbuffers_graphics.at(0);
 
 	mvkobjs.mtx2->lock();
 	if (vkQueueSubmit(mvkobjs.graphicsQ, 1, &submitinfo, mvkobjs.renderfence) != VK_SUCCESS) {
diff --git a/src/glue/playout.cpp b/src/glue/playout.cpp
index e019823..73ddde2 100644
--- a/src/glue/playout.cpp
+++ b/src/glue/playout.cpp
@@ -2,7 +2,7 @@
 
 #include "VkBootstrap.h"
 
-bool playout::init(vkobjs &mvkobjs, VkPipelineLayout &vkplayout, std::vector<VkDescriptorSetLayout> layoutz,
+bool playout::init(rvk &mvkobjs, VkPipelineLayout &vkplayout, std::span<VkDescriptorSetLayout> layoutz,
                    size_t pushc_size) {
 
 
@@ -22,6 +22,6 @@ bool playout::init(vkobjs &mvkobjs, VkPipelineLayout &vkplayout, std::vector<VkD
 	return true;
 }
 
-void playout::cleanup(vkobjs &mvkobjs, VkPipelineLayout &vkplayout) {
+void playout::cleanup(rvk &mvkobjs, VkPipelineLayout &vkplayout) {
 	vkDestroyPipelineLayout(mvkobjs.vkdevice.device, vkplayout, nullptr);
 }
diff --git a/src/glue/pline.cpp b/src/glue/pline.cpp
index e516a01..2d6af95 100644
--- a/src/glue/pline.cpp
+++ b/src/glue/pline.cpp
@@ -6,7 +6,7 @@
 #include <VkBootstrap.h>
 #include <glm/glm.hpp>
 
-bool pline::init(vkobjs &objs, VkPipelineLayout &playout, VkPipeline &pipeline, VkPrimitiveTopology topology,
+bool pline::init(rvk &objs, VkPipelineLayout &playout, VkPipeline &pipeline, VkPrimitiveTopology topology,
                  unsigned int v_in, unsigned int atts, std::vector<std::string> sfiles, bool char_or_short) {
 	if (sfiles.size() < 2)
 		return false;
@@ -119,7 +119,7 @@ bool pline::init(vkobjs &objs, VkPipelineLayout &playout, VkPipeline &pipeline,
 	colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
 	colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 	colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
-	colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+	colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 	colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
 	colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
 
@@ -183,6 +183,6 @@ bool pline::init(vkobjs &objs, VkPipelineLayout &playout, VkPipeline &pipeline,
 	return true;
 }
 
-void pline::cleanup(vkobjs &objs, VkPipeline &pipeline) {
+void pline::cleanup(rvk &objs, VkPipeline &pipeline) {
 	vkDestroyPipeline(objs.vkdevice.device, pipeline, nullptr);
 }
diff --git a/src/glue/vktexture.cpp b/src/glue/vktexture.cpp
index 71b8241..e54e46b 100644
--- a/src/glue/vktexture.cpp
+++ b/src/glue/vktexture.cpp
@@ -1,286 +1,13 @@
 #define STB_IMAGE_IMPLEMENTATION
 #include "vktexture.hpp"
-#include "commandbuffer.hpp"
+#include "vk/commandbuffer.hpp"
 #include "logger.hpp"
 #include <VkBootstrap.h>
 #include <cstring>
 #include <stb_image.h>
+#include <iostream>
 
-bool vktexture::loadtexturefile(vkobjs &rdata, texdata &texdata, texdatapls &texdatapls, std::string filename) {
-
-	int w;
-	int h;
-	int c;
-
-	unsigned char *data = stbi_load(filename.c_str(), &w, &h, &c, STBI_rgb_alpha);
-	if (!data) {
-		stbi_image_free(data);
-		return false;
-	}
-
-	VkDeviceSize imgsize = w * h * 4;
-
-	VkImageCreateInfo imginfo{};
-	imginfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
-	imginfo.imageType = VK_IMAGE_TYPE_2D;
-	imginfo.extent.width = static_cast<uint32_t>(w);
-	imginfo.extent.height = static_cast<uint32_t>(h);
-	imginfo.extent.depth = 1;
-	imginfo.mipLevels = 1;
-	imginfo.arrayLayers = 1;
-	imginfo.format = VK_FORMAT_R8G8B8A8_SRGB;
-	imginfo.tiling = VK_IMAGE_TILING_LINEAR;
-	imginfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-	imginfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
-	imginfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-	imginfo.samples = VK_SAMPLE_COUNT_1_BIT;
-
-	VmaAllocationCreateInfo iainfo{};
-	iainfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
-	if (vmaCreateImage(rdata.alloc, &imginfo, &iainfo, &texdata.img, &texdata.alloc, nullptr) !=
-	        VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vmaCreateImage");
-		return false;
-	}
-
-	VkBufferCreateInfo stagingbufferinfo{};
-	stagingbufferinfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-	stagingbufferinfo.size = imgsize;
-	stagingbufferinfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
-
-	VkBuffer stagingbuffer;
-	VmaAllocation stagingbufferalloc;
-
-	VmaAllocationCreateInfo stagingallocinfo{};
-	stagingallocinfo.usage = VMA_MEMORY_USAGE_CPU_ONLY;
-
-	if (vmaCreateBuffer(rdata.alloc, &stagingbufferinfo, &stagingallocinfo, &stagingbuffer, &stagingbufferalloc,
-	                    nullptr) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vmaCreateBuffer");
-		return false;
-	}
-
-	void *tmp;
-	vmaMapMemory(rdata.alloc, stagingbufferalloc, &tmp);
-	std::memcpy(tmp, data, (imgsize));
-	vmaUnmapMemory(rdata.alloc, stagingbufferalloc);
-
-	stbi_image_free(data);
-
-	VkImageSubresourceRange stagingbufferrange{};
-	stagingbufferrange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-	stagingbufferrange.baseMipLevel = 0;
-	stagingbufferrange.levelCount = 1;
-	stagingbufferrange.baseArrayLayer = 0;
-	stagingbufferrange.layerCount = 1;
-
-	VkImageMemoryBarrier stagingbuffertransferbarrier{};
-	stagingbuffertransferbarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-	stagingbuffertransferbarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-	stagingbuffertransferbarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-	stagingbuffertransferbarrier.image = texdata.img;
-	stagingbuffertransferbarrier.subresourceRange = stagingbufferrange;
-	stagingbuffertransferbarrier.srcAccessMask = 0;
-	stagingbuffertransferbarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-
-	VkExtent3D texextent{};
-	texextent.width = static_cast<uint32_t>(w);
-	texextent.height = static_cast<uint32_t>(h);
-	texextent.depth = 1;
-
-	VkBufferImageCopy stagingbuffercopy{};
-	stagingbuffercopy.bufferOffset = 0;
-	stagingbuffercopy.bufferRowLength = 0;
-	stagingbuffercopy.bufferImageHeight = 0;
-	stagingbuffercopy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-	stagingbuffercopy.imageSubresource.mipLevel = 0;
-	stagingbuffercopy.imageSubresource.baseArrayLayer = 0;
-	stagingbuffercopy.imageSubresource.layerCount = 1;
-	stagingbuffercopy.imageExtent = texextent;
-
-	VkImageMemoryBarrier stagingbuffershaderbarrier{};
-	stagingbuffershaderbarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-	stagingbuffershaderbarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-	stagingbuffershaderbarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-	stagingbuffershaderbarrier.image = texdata.img;
-	stagingbuffershaderbarrier.subresourceRange = stagingbufferrange;
-	stagingbuffershaderbarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-	stagingbuffershaderbarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-
-	VkCommandBuffer stagingcommandbuffer;
-	if (!commandbuffer::init(rdata, rdata.cpools[2], stagingcommandbuffer)) {
-		logger::log(0, "crashed in texture at commandbuffer::init");
-		return false;
-	}
-
-	if (vkResetCommandBuffer(stagingcommandbuffer, 0) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkResetCommandBuffer");
-		return false;
-	}
-
-	VkCommandBufferBeginInfo cmdbegininfo{};
-	cmdbegininfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-	cmdbegininfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-
-	if (vkBeginCommandBuffer(stagingcommandbuffer, &cmdbegininfo) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkBeginCommandBuffer");
-		return false;
-	}
-
-	vkCmdPipelineBarrier(stagingcommandbuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0,
-	                     nullptr, 0, nullptr, 1, &stagingbuffertransferbarrier);
-	vkCmdCopyBufferToImage(stagingcommandbuffer, stagingbuffer, texdata.img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
-	                       &stagingbuffercopy);
-	vkCmdPipelineBarrier(stagingcommandbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
-	                     0, nullptr, 0, nullptr, 1, &stagingbuffershaderbarrier);
-
-	if (vkEndCommandBuffer(stagingcommandbuffer) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkEndCommandBuffer");
-		return false;
-	}
-
-	VkSubmitInfo submitinfo{};
-	submitinfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-	submitinfo.pWaitDstStageMask = nullptr;
-	submitinfo.waitSemaphoreCount = 0;
-	submitinfo.pWaitSemaphores = nullptr;
-	submitinfo.signalSemaphoreCount = 0;
-	submitinfo.pSignalSemaphores = nullptr;
-	submitinfo.commandBufferCount = 1;
-	submitinfo.pCommandBuffers = &stagingcommandbuffer;
-
-	VkFence stagingbufferfence;
-
-	VkFenceCreateInfo fenceinfo{};
-	fenceinfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-	fenceinfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
-
-	if (vkCreateFence(rdata.vkdevice.device, &fenceinfo, nullptr, &stagingbufferfence) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkCreateFence");
-		return false;
-	}
-	if (vkResetFences(rdata.vkdevice.device, 1, &stagingbufferfence) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkResetFences");
-		return false;
-	}
-	rdata.mtx2->lock();
-	if (vkQueueSubmit(rdata.graphicsQ, 1, &submitinfo, stagingbufferfence) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkQueueSubmit");
-		return false;
-	}
-	rdata.mtx2->unlock();
-	if (vkWaitForFences(rdata.vkdevice.device, 1, &stagingbufferfence, VK_TRUE, INT64_MAX) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkWaitForFences");
-		return false;
-	}
-
-	vkDestroyFence(rdata.vkdevice.device, stagingbufferfence, nullptr);
-	commandbuffer::cleanup(rdata, rdata.cpools[2], stagingcommandbuffer);
-	vmaDestroyBuffer(rdata.alloc, stagingbuffer, stagingbufferalloc);
-
-	VkImageViewCreateInfo texviewinfo{};
-	texviewinfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
-	texviewinfo.image = texdata.img;
-	texviewinfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
-	texviewinfo.format = VK_FORMAT_R8G8B8A8_SRGB;
-	texviewinfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-	texviewinfo.subresourceRange.baseMipLevel = 0;
-	texviewinfo.subresourceRange.levelCount = 1;
-	texviewinfo.subresourceRange.baseArrayLayer = 0;
-	texviewinfo.subresourceRange.layerCount = 1;
-
-	if (vkCreateImageView(rdata.vkdevice.device, &texviewinfo, nullptr, &texdata.imgview) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkCreateImageView");
-		return false;
-	}
-
-	VkSamplerCreateInfo texsamplerinfo{};
-	texsamplerinfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
-	texsamplerinfo.magFilter = VK_FILTER_LINEAR;
-	texsamplerinfo.minFilter = VK_FILTER_LINEAR;
-	texsamplerinfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
-	texsamplerinfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
-	texsamplerinfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
-	texsamplerinfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
-	texsamplerinfo.unnormalizedCoordinates = VK_FALSE;
-	texsamplerinfo.compareEnable = VK_FALSE;
-	texsamplerinfo.compareOp = VK_COMPARE_OP_ALWAYS;
-	texsamplerinfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
-	texsamplerinfo.mipLodBias = 0.0f;
-	texsamplerinfo.minLod = 0.0f;
-	texsamplerinfo.maxLod = 0.0f;
-	texsamplerinfo.anisotropyEnable = VK_FALSE;
-	texsamplerinfo.maxAnisotropy = 1.0f;
-
-	if (vkCreateSampler(rdata.vkdevice.device, &texsamplerinfo, nullptr, &texdata.imgsampler) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkCreateSampler");
-		return false;
-	}
-
-	VkDescriptorSetLayoutBinding texturebind{};
-	texturebind.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-	texturebind.binding = 0;
-	texturebind.descriptorCount = 1;
-	texturebind.pImmutableSamplers = nullptr;
-	texturebind.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-
-	VkDescriptorSetLayoutCreateInfo texcreateinfo{};
-	texcreateinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-	texcreateinfo.bindingCount = 1;
-	texcreateinfo.pBindings = &texturebind;
-
-	if (vkCreateDescriptorSetLayout(rdata.vkdevice.device, &texcreateinfo, nullptr, &texdatapls.dlayout) !=
-	        VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkCreateDescriptorSetLayout");
-		return false;
-	}
-
-	VkDescriptorPoolSize poolsize{};
-	poolsize.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-	poolsize.descriptorCount = imgsize;
-
-	VkDescriptorPoolCreateInfo descriptorpool{};
-	descriptorpool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-	descriptorpool.poolSizeCount = 1;
-	descriptorpool.pPoolSizes = &poolsize;
-	descriptorpool.maxSets = 16;
-
-	if (vkCreateDescriptorPool(rdata.vkdevice.device, &descriptorpool, nullptr, &texdatapls.dpool) !=
-	        VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkCreateDescriptorPool");
-		return false;
-	}
-
-	VkDescriptorSetAllocateInfo descallocinfo{};
-	descallocinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-	descallocinfo.descriptorPool = texdatapls.dpool;
-	descallocinfo.descriptorSetCount = 1;
-	descallocinfo.pSetLayouts = &texdatapls.dlayout;
-
-	if (vkAllocateDescriptorSets(rdata.vkdevice.device, &descallocinfo, &texdatapls.dset) != VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkAllocateDescriptorSets");
-		return false;
-	}
-
-	VkDescriptorImageInfo descriptorimginfo{};
-	descriptorimginfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-	descriptorimginfo.imageView = texdata.imgview;
-	descriptorimginfo.sampler = texdata.imgsampler;
-
-	VkWriteDescriptorSet writedescset{};
-	writedescset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-	writedescset.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-	writedescset.dstSet = texdatapls.dset;
-	writedescset.dstBinding = 0;
-	writedescset.descriptorCount = 1;
-	writedescset.pImageInfo = &descriptorimginfo;
-
-	vkUpdateDescriptorSets(rdata.vkdevice.device, 1, &writedescset, 0, nullptr);
-
-	return true;
-}
-
-bool vktexture::loadtexture(vkobjs &rdata, std::vector<texdata> &texdata, fastgltf::Asset &mmodel) {
+bool vktexture::loadtexture(rvk &rdata, std::vector<texdata> &texdata, fastgltf::Asset &mmodel) {
 
 	texdata.reserve(mmodel.images.size());
 	texdata.resize(mmodel.images.size());
@@ -397,13 +124,13 @@ bool vktexture::loadtexture(vkobjs &rdata, std::vector<texdata> &texdata, fastgl
 		stagingbuffershaderbarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
 		stagingbuffershaderbarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
 
-		VkCommandBuffer stagingcommandbuffer;
-		if (!commandbuffer::init(rdata, rdata.cpools[2], stagingcommandbuffer)) {
+		std::array<VkCommandBuffer,1> stagingcommandbuffer;
+		if (!commandbuffer::create(rdata, rdata.cpools_graphics.at(1), stagingcommandbuffer)) {
 			logger::log(0, "crashed in texture at commandbuffer::init");
 			return false;
 		}
 
-		if (vkResetCommandBuffer(stagingcommandbuffer, 0) != VK_SUCCESS) {
+		if (vkResetCommandBuffer(stagingcommandbuffer.at(0), 0) != VK_SUCCESS) {
 			logger::log(0, "crashed in texture at vkResetCommandBuffer");
 			return false;
 		}
@@ -412,19 +139,19 @@ bool vktexture::loadtexture(vkobjs &rdata, std::vector<texdata> &texdata, fastgl
 		cmdbegininfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 		cmdbegininfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
-		if (vkBeginCommandBuffer(stagingcommandbuffer, &cmdbegininfo) != VK_SUCCESS) {
+		if (vkBeginCommandBuffer(stagingcommandbuffer.at(0), &cmdbegininfo) != VK_SUCCESS) {
 			logger::log(0, "crashed in texture at vkBeginCommandBuffer");
 			return false;
 		}
 
-		vkCmdPipelineBarrier(stagingcommandbuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0,
+		vkCmdPipelineBarrier(stagingcommandbuffer.at(0), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0,
 		                     nullptr, 0, nullptr, 1, &stagingbuffertransferbarrier);
-		vkCmdCopyBufferToImage(stagingcommandbuffer, stagingbuffer, texdata[i].img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+		vkCmdCopyBufferToImage(stagingcommandbuffer.at(0), stagingbuffer, texdata[i].img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 		                       1, &stagingbuffercopy);
-		vkCmdPipelineBarrier(stagingcommandbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
+		vkCmdPipelineBarrier(stagingcommandbuffer.at(0), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
 		                     0, nullptr, 0, nullptr, 1, &stagingbuffershaderbarrier);
 
-		if (vkEndCommandBuffer(stagingcommandbuffer) != VK_SUCCESS) {
+		if (vkEndCommandBuffer(stagingcommandbuffer.at(0)) != VK_SUCCESS) {
 			logger::log(0, "crashed in texture at vkEndCommandBuffer");
 			return false;
 		}
@@ -437,7 +164,7 @@ bool vktexture::loadtexture(vkobjs &rdata, std::vector<texdata> &texdata, fastgl
 		submitinfo.signalSemaphoreCount = 0;
 		submitinfo.pSignalSemaphores = nullptr;
 		submitinfo.commandBufferCount = 1;
-		submitinfo.pCommandBuffers = &stagingcommandbuffer;
+		submitinfo.pCommandBuffers = stagingcommandbuffer.data();
 
 		VkFence stagingbufferfence;
 
@@ -468,7 +195,7 @@ bool vktexture::loadtexture(vkobjs &rdata, std::vector<texdata> &texdata, fastgl
 		}
 
 		vkDestroyFence(rdata.vkdevice.device, stagingbufferfence, nullptr);
-		commandbuffer::cleanup(rdata, rdata.cpools[2], stagingcommandbuffer);
+		commandbuffer::destroy(rdata, rdata.cpools_graphics.at(1), stagingcommandbuffer);
 		vmaDestroyBuffer(rdata.alloc, stagingbuffer, stagingbufferalloc);
 
 		VkImageViewCreateInfo texviewinfo{};
@@ -513,20 +240,13 @@ bool vktexture::loadtexture(vkobjs &rdata, std::vector<texdata> &texdata, fastgl
 
 	return true;
 }
-bool vktexture::loadtexlayoutpool(vkobjs &rdata, std::vector<texdata> &texdata, texdatapls &texdatapls,
+bool vktexture::loadtexset(rvk &rdata, std::vector<texdata> &texdata, VkDescriptorSetLayout &dlayout,VkDescriptorSet &dset,
                                   fastgltf::Asset &mmodel) {
 
-	VkDescriptorSetLayoutBinding texturebind;
 	std::vector<VkDescriptorImageInfo> descriptorimginfo;
 	descriptorimginfo.reserve(mmodel.images.size());
 	descriptorimginfo.resize(mmodel.images.size());
 
-	texturebind.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-	texturebind.binding = 0;
-	texturebind.descriptorCount = mmodel.images.size();
-	texturebind.pImmutableSamplers = nullptr;
-	texturebind.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-
 	for (size_t i{0}; i < mmodel.images.size(); i++) {
 
 		descriptorimginfo[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
@@ -534,40 +254,14 @@ bool vktexture::loadtexlayoutpool(vkobjs &rdata, std::vector<texdata> &texdata,
 		descriptorimginfo[i].sampler = texdata[i].imgsampler;
 	}
 
-	VkDescriptorSetLayoutCreateInfo texcreateinfo{};
-	texcreateinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-	texcreateinfo.bindingCount = 1; // mmodel->images.size();
-	texcreateinfo.pBindings = &texturebind;
-
-	if (vkCreateDescriptorSetLayout(rdata.vkdevice.device, &texcreateinfo, nullptr, &texdatapls.dlayout) !=
-	        VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkCreateDescriptorSetLayout");
-		return false;
-	}
-
-	VkDescriptorPoolSize poolsize{};
-	poolsize.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-	poolsize.descriptorCount = mmodel.images.size() * 1024 * 1024 * 4;
-
-	VkDescriptorPoolCreateInfo descriptorpool{};
-	descriptorpool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-	descriptorpool.poolSizeCount = 1;
-	descriptorpool.pPoolSizes = &poolsize;
-	descriptorpool.maxSets = 16;
-
-	if (vkCreateDescriptorPool(rdata.vkdevice.device, &descriptorpool, nullptr, &texdatapls.dpool) !=
-	        VK_SUCCESS) {
-		logger::log(0, "crashed in texture at vkCreateDescriptorPool");
-		return false;
-	}
 
 	VkDescriptorSetAllocateInfo descallocinfo{};
 	descallocinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-	descallocinfo.descriptorPool = texdatapls.dpool;
+	descallocinfo.descriptorPool = rdata.dpools[rvk::idxinitpool];
 	descallocinfo.descriptorSetCount = 1;
-	descallocinfo.pSetLayouts = &texdatapls.dlayout;
+	descallocinfo.pSetLayouts = &dlayout;
 
-	if (vkAllocateDescriptorSets(rdata.vkdevice.device, &descallocinfo, &texdatapls.dset) != VK_SUCCESS) {
+	if (vkAllocateDescriptorSets(rdata.vkdevice.device, &descallocinfo, &dset) != VK_SUCCESS) {
 		logger::log(0, "crashed in texture at vkAllocateDescriptorSets");
 		return false;
 	}
@@ -575,7 +269,7 @@ bool vktexture::loadtexlayoutpool(vkobjs &rdata, std::vector<texdata> &texdata,
 	VkWriteDescriptorSet writedescset{};
 	writedescset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 	writedescset.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-	writedescset.dstSet = texdatapls.dset;
+	writedescset.dstSet = dset;
 	writedescset.dstArrayElement = 0;
 	writedescset.dstBinding = 0;
 	// writedescset.pBufferInfo = 0;
@@ -586,13 +280,30 @@ bool vktexture::loadtexlayoutpool(vkobjs &rdata, std::vector<texdata> &texdata,
 	return true;
 }
 
-void vktexture::cleanup(vkobjs &rdata, texdata &texdata) {
+void vktexture::cleanup(rvk &rdata, texdata &texdata) {
 	vkDestroySampler(rdata.vkdevice.device, texdata.imgsampler, nullptr);
 	vkDestroyImageView(rdata.vkdevice.device, texdata.imgview, nullptr);
 	vmaDestroyImage(rdata.alloc, texdata.img, texdata.alloc);
 }
+bool vktexture::createlayout(rvk &core){
+	
+	VkDescriptorSetLayoutBinding texturebind;
+	texturebind.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+	texturebind.binding = 0;
+	texturebind.descriptorCount = 24;//max ~24 images per gltf file
+	texturebind.pImmutableSamplers = nullptr;
+	texturebind.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+
+	VkDescriptorSetLayoutCreateInfo texcreateinfo{};
+	texcreateinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+	texcreateinfo.bindingCount = 1;
+	texcreateinfo.pBindings = &texturebind;
+
+	if (vkCreateDescriptorSetLayout(core.vkdevice.device, &texcreateinfo, nullptr, rvk::texlayout.get()) !=
+	        VK_SUCCESS) {
+		std::cout << "texture set layout crashed" << std::endl;
+		return false;
+	}
+	return true;
 
-void vktexture::cleanuppls(vkobjs &rdata, texdatapls &texdatapls) {
-	vkDestroyDescriptorPool(rdata.vkdevice.device, texdatapls.dpool, nullptr);
-	vkDestroyDescriptorSetLayout(rdata.vkdevice.device, texdatapls.dlayout, nullptr);
 }
diff --git a/src/model/genericmodel.cpp b/src/model/genericmodel.cpp
index 099c4e6..4937318 100644
--- a/src/model/genericmodel.cpp
+++ b/src/model/genericmodel.cpp
@@ -15,7 +15,7 @@
 #include "vkebo.hpp"
 #include "vkvbo.hpp"
 
-bool genericmodel::loadmodel(vkobjs &objs, std::string fname) {
+bool genericmodel::loadmodel(rvk &objs, std::string fname) {
 
 	fastgltf::Parser fastparser{};
 	auto buff = fastgltf::MappedGltfFile::FromPath(fname);
@@ -24,9 +24,15 @@ bool genericmodel::loadmodel(vkobjs &objs, std::string fname) {
 
 	mgltfobjs.texs.reserve(mmodel2.images.size());
 	mgltfobjs.texs.resize(mmodel2.images.size());
+	static const bool _ = [&]{
+	if (!vktexture::createlayout(objs))
+		return false;
+		return true;
+	}();
+	
 	if (!vktexture::loadtexture(objs, mgltfobjs.texs, mmodel2))
 		return false;
-	if (!vktexture::loadtexlayoutpool(objs, mgltfobjs.texs, mgltfobjs.texpls, mmodel2))
+	if (!vktexture::loadtexset(objs, mgltfobjs.texs, *rvk::texlayout, mgltfobjs.dset, mmodel2))
 		return false;
 
 	createvboebo(objs);
@@ -38,6 +44,8 @@ bool genericmodel::loadmodel(vkobjs &objs, std::string fname) {
 		mjnodecount = mmodel2.nodes.size();
 
 		getanims();
+	}else{
+		skinned=false;
 	}
 	return true;
 }
@@ -164,7 +172,7 @@ std::vector<unsigned int> genericmodel::getnodetojoint() {
 	return mnodetojoint;
 }
 
-void genericmodel::createvboebo(vkobjs &objs) { //& joint vector
+void genericmodel::createvboebo(rvk &objs) { //& joint vector
 
 	jointuintofx.reserve(mmodel2.meshes.size());
 	jointuintofx.resize(mmodel2.meshes.size());
@@ -265,7 +273,7 @@ void genericmodel::createvboebo(vkobjs &objs) { //& joint vector
 	}
 }
 
-void genericmodel::uploadvboebo(vkobjs &objs, VkCommandBuffer &cbuffer) {
+void genericmodel::uploadvboebo(rvk &objs, VkCommandBuffer &cbuffer) {
 	for (size_t i{0}; i < mmodel2.meshes.size(); i++) {
 		for (auto it = mmodel2.meshes[i].primitives.begin(); it < mmodel2.meshes[i].primitives.end(); it++) {
 
@@ -318,20 +326,20 @@ size_t genericmodel::gettricount(size_t i, size_t j) {
 	return c;
 }
 
-void genericmodel::drawinstanced(vkobjs &objs, VkPipelineLayout &vkplayout, VkPipeline &vkpline,
+void genericmodel::drawinstanced(rvk &objs, VkPipelineLayout &vkplayout, VkPipeline &vkpline,
                                  VkPipeline &vkplineuint, int instancecount, int stride) {
 	VkDeviceSize offset = 0;
 	std::vector<std::vector<vkpushconstants>> pushes(mgltfobjs.vbos.size());
 
-	vkCmdBindDescriptorSets(objs.cbuffers[0], VK_PIPELINE_BIND_POINT_GRAPHICS, vkplayout, 0, 1,
-	                        &mgltfobjs.texpls.dset, 0, nullptr);
+	vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, vkplayout, 0, 1,
+	                        &mgltfobjs.dset, 0, nullptr);
 
 	for (size_t i{0}; i < mgltfobjs.vbos.size(); i++) {
 		pushes[i].reserve(mgltfobjs.vbos.at(i).size());
 		pushes[i].resize(mgltfobjs.vbos.at(i).size());
 
-		meshjointtype[i] ? vkCmdBindPipeline(objs.cbuffers[0], VK_PIPELINE_BIND_POINT_GRAPHICS, vkplineuint)
-		: vkCmdBindPipeline(objs.cbuffers[0], VK_PIPELINE_BIND_POINT_GRAPHICS, vkpline);
+		meshjointtype[i] ? vkCmdBindPipeline(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, vkplineuint)
+		: vkCmdBindPipeline(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, vkpline);
 
 		for (size_t j{0}; j < mgltfobjs.vbos.at(i).size(); j++) {
 			pushes[i][j].stride = stride;
@@ -348,21 +356,21 @@ void genericmodel::drawinstanced(vkobjs &objs, VkPipelineLayout &vkplayout, VkPi
 			}
 			pushes[i][j].t = static_cast<float>(SDL_GetTicks()) / 1000.0f;
 
-			vkCmdPushConstants(objs.cbuffers[0], vkplayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(vkpushconstants),
+			vkCmdPushConstants(objs.cbuffers_graphics.at(0), vkplayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(vkpushconstants),
 			                   &pushes.at(i).at(j));
 			// rework bindings
 			for (size_t k{0}; k < mgltfobjs.vbos.at(i).at(j).size(); k++) {
 				if (mgltfobjs.vbos.at(i).at(j).at(k).buffer != VK_NULL_HANDLE)
-					vkCmdBindVertexBuffers(objs.cbuffers[0], k, 1, &mgltfobjs.vbos.at(i).at(j).at(k).buffer,
+					vkCmdBindVertexBuffers(objs.cbuffers_graphics.at(0), k, 1, &mgltfobjs.vbos.at(i).at(j).at(k).buffer,
 					                       &offset);
 			}
-			vkCmdBindIndexBuffer(objs.cbuffers[0], mgltfobjs.ebos.at(i).at(j).buffer, 0, VK_INDEX_TYPE_UINT16);
-			vkCmdDrawIndexed(objs.cbuffers[0], static_cast<uint32_t>(gettricount(i, j) * 3), instancecount, 0, 0, 0);
+			vkCmdBindIndexBuffer(objs.cbuffers_graphics.at(0), mgltfobjs.ebos.at(i).at(j).buffer, 0, VK_INDEX_TYPE_UINT16);
+			vkCmdDrawIndexed(objs.cbuffers_graphics.at(0), static_cast<uint32_t>(gettricount(i, j) * 3), instancecount, 0, 0, 0);
 		}
 	}
 }
 
-void genericmodel::cleanup(vkobjs &objs) {
+void genericmodel::cleanup(rvk &objs) {
 
 	for (size_t i{0}; i < mgltfobjs.vbos.size(); i++) {
 		for (size_t j{0}; j < mgltfobjs.vbos.at(i).size(); j++) {
@@ -379,15 +387,52 @@ void genericmodel::cleanup(vkobjs &objs) {
 	for (size_t i{0}; i < mgltfobjs.texs.size(); i++) {
 		vktexture::cleanup(objs, mgltfobjs.texs[i]);
 	}
-	vktexture::cleanuppls(objs, mgltfobjs.texpls);
+}
+
+
+void genericmodel::drawinstancedstatic(rvk &objs, VkPipelineLayout &vkplayout, VkPipeline &vkpline,
+                                  int instancecount, int stride) {
+	VkDeviceSize offset = 0;
+	std::vector<std::vector<vkpushconstants>> pushes(mgltfobjs.vbos.size());
+
+	vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, vkplayout, 0, 1,
+	                        &mgltfobjs.dset, 0, nullptr);
+
+	for (size_t i{0}; i < mgltfobjs.vbos.size(); i++) {
+		pushes[i].reserve(mgltfobjs.vbos.at(i).size());
+		pushes[i].resize(mgltfobjs.vbos.at(i).size());
+		
+		vkCmdBindPipeline(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, vkpline);
+
+		for (size_t j{0}; j < mgltfobjs.vbos.at(i).size(); j++) {
+			pushes[i][j].stride = stride;
+			if (mmodel2.meshes.at(i).primitives.at(j).materialIndex.has_value() &&
+			        mmodel2.materials.at(mmodel2.meshes.at(i).primitives.at(j).materialIndex.value())
+			        .pbrData.baseColorTexture.has_value()) {
+				pushes[i][j].texidx = static_cast<unsigned int>(
+				                          mmodel2
+				                          .textures[mmodel2.materials[mmodel2.meshes.at(i).primitives.at(j).materialIndex.value_or(0)]
+				                                    .pbrData.baseColorTexture->textureIndex]
+				                          .imageIndex.value_or(0));
+			} else {
+				pushes[i][j].texidx = 0;
+			}
+			pushes[i][j].t = static_cast<float>(SDL_GetTicks()) / 1000.0f;
 
-	// mmodel.reset();
+			vkCmdPushConstants(objs.cbuffers_graphics.at(0), vkplayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(vkpushconstants),
+			                   &pushes.at(i).at(j));
+			// rework bindings
+			for (size_t k{0}; k < mgltfobjs.vbos.at(i).at(j).size(); k++) {
+				if (mgltfobjs.vbos.at(i).at(j).at(k).buffer != VK_NULL_HANDLE)
+					vkCmdBindVertexBuffers(objs.cbuffers_graphics.at(0), k, 1, &mgltfobjs.vbos.at(i).at(j).at(k).buffer,
+					                       &offset);
+			}
+			vkCmdBindIndexBuffer(objs.cbuffers_graphics.at(0), mgltfobjs.ebos.at(i).at(j).buffer, 0, VK_INDEX_TYPE_UINT16);
+			vkCmdDrawIndexed(objs.cbuffers_graphics.at(0), static_cast<uint32_t>(gettricount(i, j) * 3), instancecount, 0, 0, 0);
+		}
+	}
 }
 
 std::vector<texdata> genericmodel::gettexdata() {
 	return mgltfobjs.texs;
 }
-
-texdatapls genericmodel::gettexdatapls() {
-	return mgltfobjs.texpls;
-}
diff --git a/src/playout/playoutgeneric.cpp b/src/playout/playoutgeneric.cpp
index 199d5cc..f5e57ba 100644
--- a/src/playout/playoutgeneric.cpp
+++ b/src/playout/playoutgeneric.cpp
@@ -1,38 +1,52 @@
 #include "playoutgeneric.hpp"
+#include "buffer/ssbo.hpp"
 #include "modelsettings.hpp"
 #include "playout.hpp"
 #include "pline.hpp"
-#include "ssbo.hpp"
 #include "ubo.hpp"
+#include <iostream>
 
-bool playoutgeneric::setup(vkobjs &objs, std::string fname, size_t count, std::string vfile, std::string ffile) {
-	if (!createubo(objs))
-		return false;
+bool playoutgeneric::setup(rvk &objs, std::string fname, size_t count, std::string vfile, std::string ffile) {
 	if (!loadmodel(objs, fname))
 		return false;
 	if (!createinstances(objs, count, false))
 		return false;
-	if (!createssbomat(objs))
-		return false;
-
-	if (!createplayout(objs))
-		return false;
-	if (!createpline(objs, vfile, ffile))
-		return false;
+	static const bool _ = [&] {
+		if(!ssbo::createlayout(objs,rvk::ssbolayout))
+			return false;
+		if (!createubo(objs))
+			return false;
+		if (!createskinnedplayout(objs))
+			return false;
+		if (!createstaticplayout(objs))
+			return false;
+		if (!createplinestatic(objs))
+			return false;
+		if (!createpline(objs, vfile, ffile))
+			return false;
+		return true;
+	}();
+
+	if (mgltf->skinned) {
+		if (!createssbomat(objs))
+			return false;
+	} else {
+		if(!createssbostatic(objs))
+			return false;
+	}
 
 	ready = true;
-
-	return true;
+	return _;
 }
 
-bool playoutgeneric::loadmodel(vkobjs &objs, std::string fname) {
+bool playoutgeneric::loadmodel(rvk &objs, std::string fname) {
 	mgltf = std::make_shared<genericmodel>();
 	if (!mgltf->loadmodel(objs, fname))
 		return false;
 	return true;
 }
 
-bool playoutgeneric::createinstances(vkobjs &objs, size_t count, bool rand) {
+bool playoutgeneric::createinstances(rvk &objs, size_t count, bool rand) {
 	size_t numTriangles{};
 	for (size_t i{0}; i < count; ++i) {
 		minstances.emplace_back(std::make_shared<genericinstance>(mgltf, glm::vec3{0.0f, 0.0f, 0.0f}, rand));
@@ -45,61 +59,83 @@ bool playoutgeneric::createinstances(vkobjs &objs, size_t count, bool rand) {
 		return false;
 	return true;
 }
-bool playoutgeneric::createubo(vkobjs &objs) {
+bool playoutgeneric::createubo(rvk &objs) {
+	ubo::createlayout(objs,rvk::ubolayout);
 	if (!ubo::init(objs, rdperspviewmatrixubo))
 		return false;
-	desclayouts.push_back(rdperspviewmatrixubo[0].dlayout);
 	return true;
 }
 
-bool playoutgeneric::createssbomat(vkobjs &objs) {
+bool playoutgeneric::createssbomat(rvk &objs) {
 	size_t size = numinstancess * SDL_clamp(minstances[0]->getjointmatrixsize(), 1, minstances[0]->getjointmatrixsize()) *
 	              sizeof(glm::mat4);
 	if (!ssbo::init(objs, rdjointmatrixssbo, size))
 		return false;
-	desclayouts.push_back(rdjointmatrixssbo.dlayout);
 	return true;
 }
-bool playoutgeneric::createplayout(vkobjs &objs) {
-	texdatapls texdatapls0 = mgltf->gettexdatapls();
-	desclayouts.insert(desclayouts.begin(), texdatapls0.dlayout);
-	if (!playout::init(objs, rdgltfpipelinelayout, desclayouts, sizeof(vkpushconstants)))
+bool playoutgeneric::createssbostatic(rvk &objs) {
+	size_t size = numinstancess * sizeof(glm::mat4);
+	if (!ssbo::init(objs, rdjointmatrixssbo, size))
+		return false;
+	return true;
+}
+bool playoutgeneric::createskinnedplayout(rvk &objs) {
+	std::array<VkDescriptorSetLayout,3> dlayouts{*rvk::texlayout,rvk::ubolayout,rvk::ssbolayout};
+	if (!playout::init(objs, skinnedplayout, dlayouts, sizeof(vkpushconstants)))
+		return false;
+	return true;
+}
+bool playoutgeneric::createstaticplayout(rvk &objs) {
+	std::array<VkDescriptorSetLayout,3> dlayouts{*rvk::texlayout,rvk::ubolayout,rvk::ssbolayout};
+	if (!playout::init(objs, staticplayout, dlayouts, sizeof(vkpushconstants)))
 		return false;
 	return true;
 }
 
-bool playoutgeneric::createpline(vkobjs &objs, std::string vfile, std::string ffile) {
-	if (!pline::init(objs, rdgltfpipelinelayout, rdgltfgpupipeline, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 5, 31,
+bool playoutgeneric::createpline(rvk &objs, std::string vfile, std::string ffile) {
+	if (!pline::init(objs, skinnedplayout, skinnedpline, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 5, 31,
 	                 std::vector<std::string> {vfile, ffile}))
 		return false;
-	if (!pline::init(objs, rdgltfpipelinelayout, rdgltfgpupipelineuint, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 5, 31,
+	if (!pline::init(objs, skinnedplayout, skinnedplineuint, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 5, 31,
 	                 std::vector<std::string> {vfile, ffile}, true))
 		return false;
 	return true;
 }
+bool playoutgeneric::createplinestatic(rvk &objs) {
+	if (!pline::init(objs, staticplayout, staticpline, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 3, 7,
+	                 std::vector<std::string> {"shaders/svx.spv", "shaders/spx.spv"}))
+		return false;
+	return true;
+}
 
 void playoutgeneric::updateanims() {
-	for (auto &i : minstances) {
-		i->updateanimation();
-		i->solveik();
-	}
+	if(mgltf->skinned)
+		for (auto &i : minstances) {
+			i->updateanimation();
+			i->solveik();
+		}
 }
 
-void playoutgeneric::uploadvboebo(vkobjs &objs, VkCommandBuffer &cbuffer) {
+void playoutgeneric::uploadvboebo(rvk &objs, VkCommandBuffer &cbuffer) {
 	if (uploadreq) {
 		mgltf->uploadvboebo(objs, cbuffer);
 		uploadreq = false;
 	}
 }
 
-void playoutgeneric::uploadubossbo(vkobjs &objs, std::vector<glm::mat4> &cammats) {
-	vkCmdBindDescriptorSets(objs.cbuffers[0], VK_PIPELINE_BIND_POINT_GRAPHICS, rdgltfpipelinelayout, 1, 1,
+void playoutgeneric::uploadubossbo(rvk &objs, std::vector<glm::mat4> &cammats) {
+	vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, mgltf->skinned ? skinnedplayout : staticplayout, 1, 1,
 	                        &rdperspviewmatrixubo[0].dset, 0, nullptr);
-	vkCmdBindDescriptorSets(objs.cbuffers[0], VK_PIPELINE_BIND_POINT_GRAPHICS, rdgltfpipelinelayout, 2, 1,
-	                        &rdjointmatrixssbo.dset, 0, nullptr);
-
-	ubo::upload(objs, rdperspviewmatrixubo, cammats, 0);
-	ssbo::upload(objs, rdjointmatrixssbo, jointmats);
+	ubo::upload(objs, rdperspviewmatrixubo, cammats);
+	if(mgltf->skinned) {
+		vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, skinnedplayout, 2, 1,
+		                        &rdjointmatrixssbo.dset, 0, nullptr);
+		ssbo::upload(objs, rdjointmatrixssbo, jointmats);
+	} else {
+		vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, staticplayout, 2, 1,
+		                        &rdjointmatrixssbo.dset, 0, nullptr);
+		ssbo::upload(objs, rdjointmatrixssbo, jointmats);
+	}
 }
 
 std::shared_ptr<genericinstance> playoutgeneric::getinst(int i) {
@@ -108,55 +144,87 @@ std::shared_ptr<genericinstance> playoutgeneric::getinst(int i) {
 
 void playoutgeneric::updatemats() {
 
+	//might have to put if skinned here
+
 	totaltricount = 0;
 	jointmats.clear();
 	jointdqs.clear();
 
 	numdqs = 0;
 	nummats = 0;
-
-	for (const auto &i : minstances) {
-		modelsettings &settings = i->getinstancesettings();
-		if (!settings.msdrawmodel)
-			continue;
-		if (settings.mvertexskinningmode == skinningmode::dualquat) {
-			std::vector<glm::mat2x4> quats = i->getjointdualquats();
-			jointdqs.insert(jointdqs.end(), quats.begin(), quats.end());
-			numdqs++;
-		} else {
-			std::vector<glm::mat4> mats = i->getjointmats();
-			jointmats.insert(jointmats.end(), mats.begin(), mats.end());
+	if(mgltf->skinned) {
+
+		for (const auto &i : minstances) {
+			modelsettings &settings = i->getinstancesettings();
+			if (!settings.msdrawmodel)
+				continue;
+			if (settings.mvertexskinningmode == skinningmode::dualquat) {
+				std::vector<glm::mat2x4> quats = i->getjointdualquats();
+				jointdqs.insert(jointdqs.end(), quats.begin(), quats.end());
+				numdqs++;
+			} else {
+				std::vector<glm::mat4> mats = i->getjointmats();
+				jointmats.insert(jointmats.end(), mats.begin(), mats.end());
+				nummats++;
+			}
+			totaltricount += mgltf->gettricount(0, 0);
+		}
+	} else {
+		//todo dual quats
+		for (const auto &i : minstances) {
+			modelsettings &settings = i->getinstancesettings();
+			if (!settings.msdrawmodel)
+				continue;
+			jointmats.push_back(i->calcstaticmat());
 			nummats++;
+			totaltricount += mgltf->gettricount(0, 0);
 		}
-		totaltricount += mgltf->gettricount(0, 0);
 	}
 }
 
-void playoutgeneric::cleanuplines(vkobjs &objs) {
-	pline::cleanup(objs, rdgltfgpupipeline);
-	pline::cleanup(objs, rdgltfgpupipelineuint);
-	playout::cleanup(objs, rdgltfpipelinelayout);
+void playoutgeneric::cleanuplines(rvk &objs) {
+	static const bool _ = [&] {
+		pline::cleanup(objs, skinnedpline);
+		pline::cleanup(objs, skinnedplineuint);
+		pline::cleanup(objs,staticpline);
+		playout::cleanup(objs, skinnedplayout);
+		playout::cleanup(objs, staticplayout);
+		return true;
+	}();
 }
 
-void playoutgeneric::cleanupbuffers(vkobjs &objs) {
-	ubo::cleanup(objs, rdperspviewmatrixubo);
-	ssbo::cleanup(objs, rdjointmatrixssbo);
+void playoutgeneric::cleanupbuffers(rvk &objs) {
+	static const bool _ = [&] {
+		ubo::cleanup(objs, rdperspviewmatrixubo);
+		return true;
+	}();
+		ssbo::cleanup(objs, rdjointmatrixssbo);
 }
 
-void playoutgeneric::cleanupmodels(vkobjs &objs) {
+void playoutgeneric::cleanupmodels(rvk &objs) {
 	mgltf->cleanup(objs);
 	mgltf.reset();
 }
 
-void playoutgeneric::draw(vkobjs &objs) {
+void playoutgeneric::draw(rvk &objs) {
 	if (minstances[0]->getinstancesettings().msdrawmodel) {
-		stride = minstances.at(0)->getjointmatrixsize();
 
-		vkCmdBindDescriptorSets(objs.cbuffers[0], VK_PIPELINE_BIND_POINT_GRAPHICS, rdgltfpipelinelayout, 1, 1,
-		                        &rdperspviewmatrixubo[0].dset, 0, nullptr);
-		vkCmdBindDescriptorSets(objs.cbuffers[0], VK_PIPELINE_BIND_POINT_GRAPHICS, rdgltfpipelinelayout, 2, 1,
-		                        &rdjointmatrixssbo.dset, 0, nullptr);
+		if(mgltf->skinned) {
+			stride = minstances.at(0)->getjointmatrixsize();
 
-		mgltf->drawinstanced(objs, rdgltfpipelinelayout, rdgltfgpupipeline, rdgltfgpupipelineuint, numinstancess, stride);
+			vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, skinnedplayout, 1, 1,
+			                        &rdperspviewmatrixubo[0].dset, 0, nullptr);
+			vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, skinnedplayout, 2, 1,
+			                        &rdjointmatrixssbo.dset, 0, nullptr);
+
+			mgltf->drawinstanced(objs, skinnedplayout, skinnedpline, skinnedplineuint, numinstancess, stride);
+		} else {
+			vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, staticplayout, 1, 1,
+			                        &rdperspviewmatrixubo[0].dset, 0, nullptr);
+			vkCmdBindDescriptorSets(objs.cbuffers_graphics.at(0), VK_PIPELINE_BIND_POINT_GRAPHICS, staticplayout, 2, 1,
+			                        &rdjointmatrixssbo.dset, 0, nullptr);
+
+			mgltf->drawinstancedstatic(objs, skinnedplayout, staticpline, numinstancess, stride);
+		}
 	}
 }
diff --git a/src/subcore/vkcam.cpp b/src/subcore/vkcam.cpp
index 0505601..8fc44b5 100644
--- a/src/subcore/vkcam.cpp
+++ b/src/subcore/vkcam.cpp
@@ -5,7 +5,7 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/string_cast.hpp>
 
-glm::mat4 vkcam::getview(vkobjs &mvkobjs) {
+glm::mat4 vkcam::getview(rvk &mvkobjs) {
 	mforward = glm::normalize(
 	               glm::vec3{glm::sin(glm::radians(mvkobjs.azimuth)) * glm::cos(glm::radians(mvkobjs.elevation)),
 	                         glm::sin(glm::radians(mvkobjs.elevation)),
@@ -16,8 +16,8 @@ glm::mat4 vkcam::getview(vkobjs &mvkobjs) {
 	mup = glm::normalize(glm::cross(mright, mforward));
 
 	mvkobjs.camwpos += mvkobjs.camfor * static_cast<float>(mvkobjs.tickdiff) * mforward +
-	                     mvkobjs.camright * static_cast<float>(mvkobjs.tickdiff) * mright +
-	                     mvkobjs.camup * static_cast<float>(mvkobjs.tickdiff) * mup;
+	                   mvkobjs.camright * static_cast<float>(mvkobjs.tickdiff) * mright +
+	                   mvkobjs.camup * static_cast<float>(mvkobjs.tickdiff) * mup;
 
 	return glm::lookAt(mvkobjs.camwpos, mvkobjs.camwpos + mforward, mup);
 }
diff --git a/src/vk/commandbuffer.cpp b/src/vk/commandbuffer.cpp
deleted file mode 100644
index 6b5c57d..0000000
--- a/src/vk/commandbuffer.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "commandbuffer.hpp"
-#include <VkBootstrap.h>
-
-bool commandbuffer::init(vkobjs &rdata, VkCommandPool &vkpool, VkCommandBuffer &incommandbuffer) {
-	VkCommandBufferAllocateInfo bufferallocinfo{};
-	bufferallocinfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-	bufferallocinfo.commandPool = vkpool;
-	bufferallocinfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-	bufferallocinfo.commandBufferCount = 1;
-	if (vkAllocateCommandBuffers(rdata.vkdevice.device, &bufferallocinfo, &incommandbuffer) != VK_SUCCESS) {
-		return false;
-	}
-
-	return true;
-}
-
-void commandbuffer::cleanup(vkobjs &rdata, VkCommandPool &vkpool, VkCommandBuffer &incommandbuffer) {
-	vkFreeCommandBuffers(rdata.vkdevice.device, vkpool, 1, &incommandbuffer);
-}
diff --git a/src/vk/commandpool.cpp b/src/vk/commandpool.cpp
deleted file mode 100644
index dc7053d..0000000
--- a/src/vk/commandpool.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "commandpool.hpp"
-#include <VkBootstrap.h>
-
-bool commandpool::init(vkobjs &rdata, VkCommandPool &vkpool) {
-	VkCommandPoolCreateInfo poolcreateinfo{};
-	poolcreateinfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
-	poolcreateinfo.queueFamilyIndex = rdata.vkdevice.get_queue_index(vkb::QueueType::graphics).value();
-	poolcreateinfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-
-	if (vkCreateCommandPool(rdata.vkdevice.device, &poolcreateinfo, nullptr, &vkpool) != VK_SUCCESS) {
-		return false;
-	}
-
-	return true;
-}
-
-void commandpool::cleanup(vkobjs &rdata, VkCommandPool &vkpool) {
-	vkDestroyCommandPool(rdata.vkdevice.device, vkpool, nullptr);
-}
diff --git a/src/vk/framebuffer.cpp b/src/vk/framebuffer.cpp
deleted file mode 100644
index 3302255..0000000
--- a/src/vk/framebuffer.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "framebuffer.hpp"
-#include <vector>
-
-bool framebuffer::init(vkobjs &rdata) {
-	rdata.schainimgs = rdata.schain.get_images().value();
-	rdata.schainimgviews = rdata.schain.get_image_views().value();
-
-	rdata.fbuffers.reserve(rdata.schainimgviews.size());
-	rdata.fbuffers.resize(rdata.schainimgviews.size());
-
-	for (unsigned int i = 0; i < rdata.schainimgviews.size(); ++i) {
-		VkImageView a[] = {rdata.schainimgviews.at(i), rdata.rddepthimageview};
-
-		VkFramebufferCreateInfo fbinfo{};
-		fbinfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-		fbinfo.renderPass = rdata.rdrenderpass;
-		fbinfo.attachmentCount = 2;
-		fbinfo.pAttachments = a;
-		fbinfo.width = rdata.schain.extent.width;
-		fbinfo.height = rdata.schain.extent.height;
-		fbinfo.layers = 1;
-
-		if (vkCreateFramebuffer(rdata.vkdevice.device, &fbinfo, nullptr, &rdata.fbuffers[i]) != VK_SUCCESS) {
-			return false;
-		}
-	}
-	return true;
-}
-void framebuffer::cleanup(vkobjs &rdata) {
-	for (auto &fb : rdata.fbuffers) {
-		vkDestroyFramebuffer(rdata.vkdevice.device, fb, nullptr);
-	}
-}
diff --git a/src/vk/renderpass.cpp b/src/vk/renderpass.cpp
index 6ced97b..a6f2ed2 100644
--- a/src/vk/renderpass.cpp
+++ b/src/vk/renderpass.cpp
@@ -1,7 +1,7 @@
 #include "renderpass.hpp"
 #include <VkBootstrap.h>
 
-bool renderpass::init(vkobjs &rdata) {
+bool renderpass::init(rvk &rdata) {
 	VkAttachmentDescription colora{};
 	colora.format = rdata.schain.image_format;
 	colora.samples = VK_SAMPLE_COUNT_1_BIT;
@@ -37,23 +37,15 @@ bool renderpass::init(vkobjs &rdata) {
 	subpassdesc.pColorAttachments = &coloraref;
 	subpassdesc.pDepthStencilAttachment = &deptharef;
 
-	VkSubpassDependency subpassdep{};
-	subpassdep.srcSubpass = VK_SUBPASS_EXTERNAL;
-	subpassdep.dstSubpass = 0;
-	subpassdep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	subpassdep.srcAccessMask = 0;
-	subpassdep.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	subpassdep.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+	VkSubpassDependency dependency{};
+	dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
+	dependency.dstSubpass = 0;
+	dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+	dependency.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+	dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+	dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 
-	VkSubpassDependency depthdep{};
-	depthdep.srcSubpass = VK_SUBPASS_EXTERNAL;
-	depthdep.dstSubpass = 0;
-	depthdep.srcStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-	depthdep.srcAccessMask = 0;
-	depthdep.dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-	depthdep.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-
-	VkSubpassDependency deps[] = {subpassdep, depthdep};
+	VkSubpassDependency deps[] = {dependency};
 	VkAttachmentDescription descs[] = {colora, deptha};
 
 	VkRenderPassCreateInfo renderpassinfo{};
@@ -62,7 +54,7 @@ bool renderpass::init(vkobjs &rdata) {
 	renderpassinfo.pAttachments = descs;
 	renderpassinfo.subpassCount = 1;
 	renderpassinfo.pSubpasses = &subpassdesc;
-	renderpassinfo.dependencyCount = 2;
+	renderpassinfo.dependencyCount = 1;
 	renderpassinfo.pDependencies = deps;
 
 	if (vkCreateRenderPass(rdata.vkdevice.device, &renderpassinfo, nullptr, &rdata.rdrenderpass) != VK_SUCCESS) {
@@ -71,6 +63,6 @@ bool renderpass::init(vkobjs &rdata) {
 
 	return true;
 }
-void renderpass::cleanup(vkobjs &rdata) {
+void renderpass::cleanup(rvk &rdata) {
 	vkDestroyRenderPass(rdata.vkdevice.device, rdata.rdrenderpass, nullptr);
 }
diff --git a/src/vk/vksyncobjects.cpp b/src/vk/vksyncobjects.cpp
index f247d4b..a8e8cad 100644
--- a/src/vk/vksyncobjects.cpp
+++ b/src/vk/vksyncobjects.cpp
@@ -1,6 +1,6 @@
 #include "vksyncobjects.hpp"
 
-bool vksyncobjects::init(vkobjs &rdata) {
+bool vksyncobjects::init(rvk &rdata) {
 
 	VkFenceCreateInfo fenceinfo{};
 	fenceinfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
@@ -17,7 +17,7 @@ bool vksyncobjects::init(vkobjs &rdata) {
 	}
 	return true;
 }
-void vksyncobjects::cleanup(vkobjs &rdata) {
+void vksyncobjects::cleanup(rvk &rdata) {
 	vkDestroySemaphore(rdata.vkdevice.device, rdata.presentsemaphore, nullptr);
 	vkDestroySemaphore(rdata.vkdevice.device, rdata.rendersemaphore, nullptr);
 	vkDestroyFence(rdata.vkdevice.device, rdata.renderfence, nullptr);
diff --git a/sub/absl b/sub/absl
index e4c4385..f60bfd8 160000
--- a/sub/absl
+++ b/sub/absl
@@ -1 +1 @@
-Subproject commit e4c43850ad008b362b53622cb3c88fd915d8f714
+Subproject commit f60bfd822e5be101269561043eeea5f1937392cb
diff --git a/sub/fastgltf b/sub/fastgltf
index 9c8a6ef..68b749b 160000
--- a/sub/fastgltf
+++ b/sub/fastgltf
@@ -1 +1 @@
-Subproject commit 9c8a6ef8909b0f0a38aac5f2aa96ac6503f9ddea
+Subproject commit 68b749bde0d6049193458266e771fbd74e5ad1f4
diff --git a/sub/imgui b/sub/imgui
index 407a0b9..afe20dc 160000
--- a/sub/imgui
+++ b/sub/imgui
@@ -1 +1 @@
-Subproject commit 407a0b972eac6166095d2b5b5b0896bad6e9687a
+Subproject commit afe20dc9b608e29b2e75964327287cf5588c1d2d
diff --git a/sub/protobuf b/sub/protobuf
index 8543a71..c02a5fc 160000
--- a/sub/protobuf
+++ b/sub/protobuf
@@ -1 +1 @@
-Subproject commit 8543a716690c03102d3dfcfd98c579001a799a77
+Subproject commit c02a5fcbd5718380caa942994f6e7cb1455ce405
diff --git a/sub/sdl b/sub/sdl
index f625723..e80d084 160000
--- a/sub/sdl
+++ b/sub/sdl
@@ -1 +1 @@
-Subproject commit f62572344ff6106b78d0665b2720fbb8b9c0ba86
+Subproject commit e80d084766fa9ae3e86177e213e9497591e0935d
diff --git a/sub/sdlimg b/sub/sdlimg
index 18486b1..e28c7c7 160000
--- a/sub/sdlimg
+++ b/sub/sdlimg
@@ -1 +1 @@
-Subproject commit 18486b134e7e753935b0e66556d2e9f7634e44a7
+Subproject commit e28c7c7623ed447c10977849013c6e3c815f0788
diff --git a/sub/simdjson b/sub/simdjson
index b717136..0c0ce1b 160000
--- a/sub/simdjson
+++ b/sub/simdjson
@@ -1 +1 @@
-Subproject commit b717136fd9151422acf78995cb27ec6d43bed7cf
+Subproject commit 0c0ce1bd48baa0677dc7c0945ea7cd1e8b52b297
diff --git a/sub/stb b/sub/stb
index 802cd45..f58f558 160000
--- a/sub/stb
+++ b/sub/stb
@@ -1 +1 @@
-Subproject commit 802cd454f25469d3123e678af41364153c132c2a
+Subproject commit f58f558c120e9b32c217290b80bad1a0729fbb2c
diff --git a/sub/vk_boot b/sub/vk_boot
index f9f1aa1..341fbe7 160000
--- a/sub/vk_boot
+++ b/sub/vk_boot
@@ -1 +1 @@
-Subproject commit f9f1aa112a8f46d30aa8755ccf24e644580298d4
+Subproject commit 341fbe7c4aae89133ba8b27bed0f7fd523ae126b