diff --git a/res/shaders/BasePass.slang b/res/shaders/BasePass.slang
index b48756c..354e117 100644
--- a/res/shaders/BasePass.slang
+++ b/res/shaders/BasePass.slang
@@ -34,10 +34,10 @@ FragmentOutput fragmentMain(in FragmentParameter params)
     }
     for(uint i = 0; i < pLightEnv.numPointLights; ++i)
     {
-        //uint lightIndex = pLightCullingData.lightIndexList[startOffset + i];
-        result += pLightEnv.pointLights[i].illuminate(lightingParams, brdf);
+        uint lightIndex = pLightCullingData.lightIndexList[startOffset + i];
+        result += pLightEnv.pointLights[lightIndex].illuminate(lightingParams, brdf);
     }
-    //result += brdf.evaluateAmbient();
+    result += brdf.evaluateAmbient();
     // gamma correction
     result = result / (result + float3(1.0));
     result = pow(result, float3(1.0/2.2));
@@ -46,3 +46,4 @@ FragmentOutput fragmentMain(in FragmentParameter params)
     output.meshletId = params.meshletId;
     return output;
 }
+            
\ No newline at end of file
diff --git a/res/shaders/LightCulling.slang b/res/shaders/LightCulling.slang
index ca2ca6f..a4b33dc 100644
--- a/res/shaders/LightCulling.slang
+++ b/res/shaders/LightCulling.slang
@@ -98,10 +98,10 @@ void cullLights(ComputeShaderInput in)
     {
         PointLight light = pLightEnv.pointLights[i];
         float3 light_VS = mul(viewMatrix, float4(light.position_WS.xyz, 1.0f)).xyz;
-        if(light.insideFrustum(groupFrustum, light_VS, nearClipVS, maxDepthVS))
+        //if(light.insideFrustum(groupFrustum, light_VS, nearClipVS, maxDepthVS))
         {
             tAppendLight(i);
-            if(!light.insidePlane(minPlane, light_VS))
+            //if(!light.insidePlane(minPlane, light_VS))
             {
                 oAppendLight(i);
             }
diff --git a/res/shaders/MeshletPass.slang b/res/shaders/MeshletPass.slang
index 6724f30..1b622e3 100644
--- a/res/shaders/MeshletPass.slang
+++ b/res/shaders/MeshletPass.slang
@@ -19,7 +19,6 @@ void meshMain(
 	out indices uint3 indices[MAX_PRIMITIVES]
 ){
 	InstanceData inst = pScene.instances[meshPayload.instanceId];
-	//MeshData data = pScene.meshData[meshPayload.instanceId];
 	MeshletDescription m = pScene.meshletInfos[meshPayload.culledMeshlets[groupID]];
 	SetMeshOutputCounts(m.vertexCount, m.primitiveCount);
 	
diff --git a/res/shaders/ViewCullingTask.slang b/res/shaders/ViewCullingTask.slang
index 2d36af1..74550cf 100644
--- a/res/shaders/ViewCullingTask.slang
+++ b/res/shaders/ViewCullingTask.slang
@@ -36,7 +36,9 @@ void taskMain(
 	{
 		uint m = mesh.meshletOffset + i;
 		MeshletDescription meshlet = pScene.meshletInfos[m];
+#ifdef VIEW_CULLING
 		if(meshlet.bounding.insideFrustum(viewFrustum))
+#endif
 		{
 			uint index;
 			InterlockedAdd(head, 1, index);
diff --git a/src/Editor/Asset/MeshLoader.cpp b/src/Editor/Asset/MeshLoader.cpp
index 357bf6d..e440e6a 100644
--- a/src/Editor/Asset/MeshLoader.cpp
+++ b/src/Editor/Asset/MeshLoader.cpp
@@ -38,7 +38,7 @@ void MeshLoader::importAsset(MeshImportArgs args)
     PMeshAsset ref = asset;
     asset->setStatus(Asset::Status::Loading);
     AssetRegistry::get().registerMesh(std::move(asset));
-    import(args, ref);
+import(args, ref);
 }
 
 
@@ -59,9 +59,10 @@ void MeshLoader::loadTextures(const aiScene* scene, const std::filesystem::path&
         aiTexture* tex = scene->mTextures[i];
         auto texPath = std::filesystem::path(tex->mFilename.C_Str());
         if (std::filesystem::exists(texPath))
-        { }
-        else if(std::filesystem::exists(meshDirectory / texPath))
-        { 
+        {
+        }
+        else if (std::filesystem::exists(meshDirectory / texPath))
+        {
             texPath = meshDirectory / texPath;
         }
         else
@@ -112,7 +113,7 @@ constexpr const char* KEY_AMBIENT_OCCLUSION_TEXTURE = "tex_ao";
 
 void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>& textures, const std::string& baseName, const std::filesystem::path& meshDirectory, const std::string& importPath, Array<PMaterialInstanceAsset>& globalMaterials)
 {
-    for(uint32 m = 0; m < scene->mNumMaterials; ++m)
+    for (uint32 m = 0; m < scene->mNumMaterials; ++m)
     {
         aiMaterial* material = scene->mMaterials[m];
         aiString texPath;
@@ -191,6 +192,15 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
                         });
                     texture = AssetRegistry::findTexture(importPath, texFilename.stem().string());
                 }
+                else if (std::filesystem::exists(meshDirectory.parent_path() / "textures" / texFilename))
+                {
+                    AssetImporter::importTexture(TextureImportArgs{
+                    .filePath = meshDirectory.parent_path() / "textures" / texFilename,
+                    .importPath = importPath,
+                    .type = type == aiTextureType_NORMALS ? TextureImportType::TEXTURE_NORMAL : TextureImportType::TEXTURE_2D,
+                        });
+                    texture = AssetRegistry::findTexture(importPath, texFilename.stem().string());
+                }
                 else
                 {
                     std::cout << "couldnt find " << texPath.C_Str() << std::endl;
@@ -306,7 +316,7 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
                 expressions.back()->inputs["rhs"].source = strengthKey;
 
                 result = blendKey;
-                
+
             };
 
         // Diffuse
@@ -388,7 +398,7 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
             expressions.back()->key = "NormalMul";
             expressions.back()->inputs["lhs"].source = "2";
             expressions.back()->inputs["rhs"].source = outputNormal;
-            
+
             expressions.add(new SubExpression());
             expressions.back()->key = "NormalSub";
             expressions.back()->inputs["lhs"].source = "NormalMul";
@@ -430,10 +440,10 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
 
         OMaterialAsset baseMat = new MaterialAsset(importPath, materialName);
         baseMat->material = new Material(graphics,
-            std::move(materialLayout), 
-            uniformSize, 0, materialName, 
-            std::move(expressions), 
-            std::move(parameters), 
+            std::move(materialLayout),
+            uniformSize, 0, materialName,
+            std::move(expressions),
+            std::move(parameters),
             std::move(brdf)
         );
         baseMat->material->compile();
@@ -447,7 +457,7 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
     }
 }
 
-void findMeshRoots(aiNode *node, List<aiNode *> &meshNodes)
+void findMeshRoots(aiNode* node, List<aiNode*>& meshNodes)
 {
     if (node->mNumMeshes > 0)
     {
@@ -508,7 +518,7 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
                 tangents[i] = Vector(0, 0, 1);
                 biTangents[i] = Vector(1, 0, 0);
             }
-            if(mesh->HasVertexColors(0))
+            if (mesh->HasVertexColors(0))
             {
                 colors[i] = Vector(mesh->mColors[0][i].r, mesh->mColors[0][i].g, mesh->mColors[0][i].b);
             }
@@ -577,7 +587,7 @@ aiMatrix4x4 loadNodeTransform(aiNode* node)
 
 void MeshLoader::import(MeshImportArgs args, PMeshAsset meshAsset)
 {
-    std::cout << "Starting to import "<<args.filePath<< std::endl;
+    std::cout << "Starting to import " << args.filePath << std::endl;
     meshAsset->setStatus(Asset::Status::Loading);
     Assimp::Importer importer;
     importer.ReadFile(args.filePath.string().c_str(), (uint32)(
@@ -587,28 +597,28 @@ void MeshLoader::import(MeshImportArgs args, PMeshAsset meshAsset)
         aiProcess_SortByPType |
         aiProcess_GenBoundingBoxes |
         aiProcess_GenSmoothNormals |
-        aiProcess_ImproveCacheLocality | 
+        aiProcess_ImproveCacheLocality |
         aiProcess_GenUVCoords |
         aiProcess_FindDegenerates));
-    const aiScene *scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace);
+    const aiScene* scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace);
     std::cout << importer.GetErrorString() << std::endl;
 
     Array<PTextureAsset> textures;
     loadTextures(scene, args.filePath.parent_path(), args.importPath, textures);
     Array<PMaterialInstanceAsset> globalMaterials(scene->mNumMaterials);
     loadMaterials(scene, textures, args.filePath.stem().string(), args.filePath.parent_path(), args.importPath, globalMaterials);
-    
+
     Array<OMesh> globalMeshes(scene->mNumMeshes);
     Component::Collider collider;
     loadGlobalMeshes(scene, globalMaterials, globalMeshes, collider);
 
-    List<aiNode *> meshNodes;
+    List<aiNode*> meshNodes;
     findMeshRoots(scene->mRootNode, meshNodes);
-    
+
     Array<OMesh> meshes;
     for (auto meshNode : meshNodes)
     {
-        for(uint32 i = 0; i < meshNode->mNumMeshes; ++i)
+        for (uint32 i = 0; i < meshNode->mNumMeshes; ++i)
         {
             if (globalMeshes[meshNode->mMeshes[i]] == nullptr)
             {
diff --git a/src/Editor/main.cpp b/src/Editor/main.cpp
index 8ee86a3..8375a80 100644
--- a/src/Editor/main.cpp
+++ b/src/Editor/main.cpp
@@ -59,7 +59,7 @@ int main() {
       .filePath = sourcePath / "import/models/cube.fbx",
       });
   AssetImporter::importMesh(MeshImportArgs{
-      .filePath = sourcePath / "import/models/after-the-rain-vr-sound/source/Whitechapel.gltf",
+      .filePath = sourcePath / "import/models/after-the-rain-vr-sound/source/Whitechapel.fbx",
       .importPath = "Whitechapel"
       });
   //AssetImporter::importMesh(MeshImportArgs{
diff --git a/src/Engine/Graphics/RenderPass/BasePass.cpp b/src/Engine/Graphics/RenderPass/BasePass.cpp
index ada367f..c35721c 100644
--- a/src/Engine/Graphics/RenderPass/BasePass.cpp
+++ b/src/Engine/Graphics/RenderPass/BasePass.cpp
@@ -16,6 +16,8 @@
 
 using namespace Seele;
 
+extern bool useViewCulling;
+
 BasePass::BasePass(Gfx::PGraphics graphics, PScene scene)
     : RenderPass(graphics, scene)
 {
@@ -40,11 +42,11 @@ BasePass::BasePass(Gfx::PGraphics graphics, PScene scene)
 
     if (graphics->supportMeshShading())
     {
-        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "BasePass", "MeshletPass", false, true, true, "BasePass", true, true, "ViewCullingTask");
+        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "BasePass", "MeshletPass", true, true, "BasePass", true, true, "ViewCullingTask");
     }
     else
     {
-        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "BasePass", "LegacyPass", false, true, true, "BasePass");
+        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "BasePass", "LegacyPass", true, true, "BasePass");
     }
 }
 
@@ -97,6 +99,7 @@ void BasePass::render()
         permutation.setVertexFile("LegacyPass");
     }
     permutation.setFragmentFile("BasePass");
+    permutation.setViewCulling(useViewCulling);
     for (VertexData* vertexData : VertexData::getList())
     {
         permutation.setVertexData(vertexData->getTypeName());
@@ -168,7 +171,6 @@ void BasePass::render()
             command->bindDescriptor(scene->getLightEnvironment()->getDescriptorSet());
             command->bindDescriptor(opaqueCulling);
             command->bindDescriptor(vertexData->getInstanceDataSet());
-            command->bindDescriptor(vertexData->getInstanceDataSet());
             for (const auto& drawCall : materialData.instances)
             {
                 command->bindDescriptor(drawCall.materialInstance->getDescriptorSet());
@@ -222,7 +224,7 @@ void BasePass::publishOutputs()
 void BasePass::createRenderPass()
 {
     depthAttachment = resources->requestRenderTarget("DEPTHPREPASS_DEPTH");
-    depthAttachment.setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR);
+    depthAttachment.setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_LOAD);
     depthAttachment.setInitialLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL);
     depthAttachment.setFinalLayout(Gfx::SE_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
     Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
diff --git a/src/Engine/Graphics/RenderPass/CMakeLists.txt b/src/Engine/Graphics/RenderPass/CMakeLists.txt
index 2bf1ec2..192817b 100644
--- a/src/Engine/Graphics/RenderPass/CMakeLists.txt
+++ b/src/Engine/Graphics/RenderPass/CMakeLists.txt
@@ -15,10 +15,10 @@ target_sources(Engine
         RenderPass.cpp
         SkyboxRenderPass.h
         SkyboxRenderPass.cpp
-        StaticDepthPrepass.h
-        StaticDepthPrepass.cpp
-        StaticBasePass.h
-        StaticBasePass.cpp
+        #StaticDepthPrepass.h
+        #StaticDepthPrepass.cpp
+        #StaticBasePass.h
+        #StaticBasePass.cpp
         TextPass.h
         TextPass.cpp
         UIPass.h
@@ -35,7 +35,7 @@ target_sources(Engine
             RenderGraphResources.h
             RenderPass.h
             SkyboxRenderPass.h
-            StaticDepthPrepass.h
-            StaticBasePass.h
+            #StaticDepthPrepass.h
+            #StaticBasePass.h
             TextPass.h
             UIPass.h)
\ No newline at end of file
diff --git a/src/Engine/Graphics/RenderPass/DepthPrepass.cpp b/src/Engine/Graphics/RenderPass/DepthPrepass.cpp
index 48625fa..1958687 100644
--- a/src/Engine/Graphics/RenderPass/DepthPrepass.cpp
+++ b/src/Engine/Graphics/RenderPass/DepthPrepass.cpp
@@ -13,6 +13,9 @@
 
 using namespace Seele;
 
+extern bool usePositionOnly;
+extern bool useViewCulling;
+
 DepthPrepass::DepthPrepass(Gfx::PGraphics graphics, PScene scene)
     : RenderPass(graphics, scene)
 {
@@ -25,11 +28,11 @@ DepthPrepass::DepthPrepass(Gfx::PGraphics graphics, PScene scene)
         });
     if (graphics->supportMeshShading())
     {
-        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "MeshletPass", true, false, false, "", true, true, "ViewCullingTask");
+        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "MeshletPass", false, false, "", true, true, "ViewCullingTask");
     }
     else
     {
-        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "LegacyPass", true);
+        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "LegacyPass");
     }
 }
 
@@ -48,7 +51,8 @@ void DepthPrepass::render()
     Array<Gfx::ORenderCommand> commands;
 
     Gfx::ShaderPermutation permutation;
-    permutation.setPositionOnly();
+    permutation.setPositionOnly(usePositionOnly);
+    permutation.setViewCulling(useViewCulling);
     if (graphics->supportMeshShading())
     {
         permutation.setTaskFile("ViewCullingTask");
diff --git a/src/Engine/Graphics/RenderPass/StaticBasePass.cpp b/src/Engine/Graphics/RenderPass/StaticBasePass.cpp
index 7d99e60..d916b7e 100644
--- a/src/Engine/Graphics/RenderPass/StaticBasePass.cpp
+++ b/src/Engine/Graphics/RenderPass/StaticBasePass.cpp
@@ -22,11 +22,11 @@ StaticBasePass::StaticBasePass(Gfx::PGraphics graphics, PScene scene)
     basePassLayout->addDescriptorLayout(lightCullingLayout);
     if (graphics->supportMeshShading())
     {
-        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "BasePass", "StaticMeshletPass", false, true, true, "BasePass", true);
+        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "BasePass", "StaticMeshletPass", false, true, "BasePass", true);
     }
     else
     {
-        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "StaticBasePass", "StaticLegacyPass", false, true, true, "BasePass");
+        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "StaticBasePass", "StaticLegacyPass", false, true, "BasePass");
     }
 }
 
diff --git a/src/Engine/Graphics/RenderPass/StaticDepthPrepass.cpp b/src/Engine/Graphics/RenderPass/StaticDepthPrepass.cpp
index 7743b92..a875e6e 100644
--- a/src/Engine/Graphics/RenderPass/StaticDepthPrepass.cpp
+++ b/src/Engine/Graphics/RenderPass/StaticDepthPrepass.cpp
@@ -16,11 +16,11 @@ StaticDepthPrepass::StaticDepthPrepass(Gfx::PGraphics graphics, PScene scene)
     depthPrepassLayout->addDescriptorLayout(meshletCullingLayout);
     if (graphics->supportMeshShading())
     {
-        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "MeshletPass", true, false, false, "", true);
+        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "MeshletPass", false, false, "", true);
     }
     else
     {
-        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "LegacyPass", true);
+        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "LegacyPass");
     }
 }
 
diff --git a/src/Engine/Graphics/Shader.cpp b/src/Engine/Graphics/Shader.cpp
index e9b59b3..f59ab75 100644
--- a/src/Engine/Graphics/Shader.cpp
+++ b/src/Engine/Graphics/Shader.cpp
@@ -36,7 +36,6 @@ void ShaderCompiler::registerVertexData(VertexData* vd)
 
 void ShaderCompiler::registerRenderPass(Gfx::PPipelineLayout layout, 
 	std::string name, std::string mainFile, 
-	bool positionOnly,
 	bool useMaterials, 
 	bool hasFragmentShader, 
 	std::string fragmentFile, 
@@ -53,7 +52,6 @@ void ShaderCompiler::registerRenderPass(Gfx::PPipelineLayout layout,
 		.useMeshShading = useMeshShading,
 		.hasTaskShader = hasTaskShader,
 		.useMaterial = useMaterials,
-		.positionOnly = positionOnly,
 	};
 	compile();
 }
@@ -70,12 +68,53 @@ void ShaderCompiler::compile()
 			{
 				for (const auto& [matName, mat] : materials)
 				{
-					//work.add([=]() {
-						ShaderPermutation permutation;
-						if (pass.positionOnly)
+					for (int x = 0; x < 2; x++)
+					{
+						for (int y = 0; y < 2; y++)
 						{
-							permutation.setPositionOnly();
+					work.add([=]() {
+							ShaderPermutation permutation;
+							permutation.setPositionOnly(x);	
+							permutation.setViewCulling(y);
+							if (pass.useMeshShading)
+							{
+								permutation.setMeshFile(pass.mainFile);
+							}
+							else
+							{
+								permutation.setVertexFile(pass.mainFile);
+							}
+							if (pass.hasFragmentShader)
+							{
+								permutation.setFragmentFile(pass.fragmentFile);
+							}
+							if (pass.hasTaskShader)
+							{
+								permutation.setTaskFile(pass.taskFile);
+							}
+							permutation.setVertexData(vd->getTypeName());
+							OPipelineLayout layout = graphics->createPipelineLayout(pass.baseLayout->getName(), pass.baseLayout);
+							layout->addDescriptorLayout(vd->getVertexDataLayout());
+							layout->addDescriptorLayout(vd->getInstanceDataLayout());
+							layout->addDescriptorLayout(mat->getDescriptorLayout());
+							permutation.setMaterial(mat->getName());
+							createShaders(permutation, std::move(layout));
+					});
 						}
+					}
+						
+				}
+			}
+			else
+			{
+				for (int x = 0; x < 2; x++)
+				{
+					for (int y = 0; y < 2; y++)
+					{
+						work.add([=]() {
+						ShaderPermutation permutation;
+						permutation.setPositionOnly(x);
+						permutation.setViewCulling(y);
 						if (pass.useMeshShading)
 						{
 							permutation.setMeshFile(pass.mainFile);
@@ -96,46 +135,14 @@ void ShaderCompiler::compile()
 						OPipelineLayout layout = graphics->createPipelineLayout(pass.baseLayout->getName(), pass.baseLayout);
 						layout->addDescriptorLayout(vd->getVertexDataLayout());
 						layout->addDescriptorLayout(vd->getInstanceDataLayout());
-						layout->addDescriptorLayout(mat->getDescriptorLayout());
-						permutation.setMaterial(mat->getName());
 						createShaders(permutation, std::move(layout));
-					//});
+						});
+					}
 				}
 			}
-			else
-			{
-				//work.add([=]() {
-					ShaderPermutation permutation;
-					if (pass.positionOnly)
-					{
-						permutation.setPositionOnly();
-					}
-					if (pass.useMeshShading)
-					{
-						permutation.setMeshFile(pass.mainFile);
-					}
-					else
-					{
-						permutation.setVertexFile(pass.mainFile);
-					}
-					if (pass.hasFragmentShader)
-					{
-						permutation.setFragmentFile(pass.fragmentFile);
-					}
-					if (pass.hasTaskShader)
-					{
-						permutation.setTaskFile(pass.taskFile);
-					}
-					permutation.setVertexData(vd->getTypeName());
-					OPipelineLayout layout = graphics->createPipelineLayout(pass.baseLayout->getName(), pass.baseLayout);
-					layout->addDescriptorLayout(vd->getVertexDataLayout());
-					layout->addDescriptorLayout(vd->getInstanceDataLayout());
-					createShaders(permutation, std::move(layout));
-					//});
-			}
 		}
 	}
-	//getThreadPool().runAndWait(std::move(work));
+	getThreadPool().runAndWait(std::move(work));
 }
 
 void ShaderCompiler::createShaders(ShaderPermutation permutation, Gfx::OPipelineLayout layout)
@@ -161,6 +168,10 @@ void ShaderCompiler::createShaders(ShaderPermutation permutation, Gfx::OPipeline
 	{
 		createInfo.defines["POS_ONLY"] = "1";
 	}
+	if (permutation.viewCulling)
+	{
+		createInfo.defines["VIEW_CULLING"] = "1";
+	}
 	createInfo.typeParameter.add({ Pair<const char*, const char*>("IVertexData", permutation.vertexDataName) });
 	createInfo.additionalModules.add(permutation.vertexDataName);
 
diff --git a/src/Engine/Graphics/Shader.h b/src/Engine/Graphics/Shader.h
index d112f73..275d026 100644
--- a/src/Engine/Graphics/Shader.h
+++ b/src/Engine/Graphics/Shader.h
@@ -63,6 +63,7 @@ struct ShaderPermutation
     uint8 hasTaskShader;
     uint8 useMaterial;
     uint8 positionOnly;
+    uint8 viewCulling;
     //TODO: lightmapping etc
     ShaderPermutation()
     {
@@ -103,9 +104,13 @@ struct ShaderPermutation
         useMaterial = 1;
         strncpy(materialName, name.data(), sizeof(materialName));
     }
-    void setPositionOnly()
+    void setPositionOnly(bool enable)
     {
-        positionOnly = true;
+        positionOnly = enable;
+    }
+    void setViewCulling(bool enable)
+    {
+        viewCulling = enable;
     }
 };
 //Hashed ShaderPermutation for fast lookup
@@ -146,7 +151,6 @@ public:
     void registerRenderPass(Gfx::PPipelineLayout baseLayout,
         std::string name,
         std::string mainFile,
-        bool positionOnly = true,
         bool useMaterials = false,
         bool hasFragmentShader = false,
         std::string fragmentFile = "",
@@ -170,7 +174,6 @@ private:
         bool useMeshShading;
         bool hasTaskShader;
         bool useMaterial;
-        bool positionOnly;
     };
     Map<std::string, PassConfig> passes;
     Gfx::PGraphics graphics;
diff --git a/src/Engine/Graphics/Vulkan/Descriptor.cpp b/src/Engine/Graphics/Vulkan/Descriptor.cpp
index 246ca9f..12c7899 100644
--- a/src/Engine/Graphics/Vulkan/Descriptor.cpp
+++ b/src/Engine/Graphics/Vulkan/Descriptor.cpp
@@ -388,7 +388,7 @@ void PipelineLayout::create() {
 
   std::unique_lock l(layoutLock);
   if (cachedLayouts.contains(layoutHash)) {
-      std::cout << "New Layout" << std::endl;
+    //  std::cout << "New Layout" << std::endl;
     layoutHandle = cachedLayouts[layoutHash];
     return;
   }
diff --git a/src/Engine/Graphics/Vulkan/Resources.cpp b/src/Engine/Graphics/Vulkan/Resources.cpp
index 3fbd0bd..b8896b7 100644
--- a/src/Engine/Graphics/Vulkan/Resources.cpp
+++ b/src/Engine/Graphics/Vulkan/Resources.cpp
@@ -69,7 +69,8 @@ void Fence::reset()
 {
     if (signaled)
     {
-        vkResetFences(graphics->getDevice(), 1, &fence);
+        VK_CHECK(vkResetFences(graphics->getDevice(), 1, &fence));
+        //std::cout << vkGetFenceStatus(graphics->getDevice(), fence) << std::endl;
         signaled = false;
     }
 }
diff --git a/src/Engine/Graphics/Vulkan/Window.cpp b/src/Engine/Graphics/Vulkan/Window.cpp
index f3e97ad..cf91f1f 100644
--- a/src/Engine/Graphics/Vulkan/Window.cpp
+++ b/src/Engine/Graphics/Vulkan/Window.cpp
@@ -114,7 +114,7 @@ void Window::pollInput()
 
 void Window::beginFrame()
 {
-    imageAvailableFences[currentSemaphoreIndex]->wait(100000);
+    imageAvailableFences[currentSemaphoreIndex]->wait(100000000);
     imageAvailableFences[currentSemaphoreIndex]->reset();
     vkAcquireNextImageKHR(graphics->getDevice(), swapchain, std::numeric_limits<uint64>::max(), imageAvailableSemaphores[currentSemaphoreIndex]->getHandle(), imageAvailableFences[currentSemaphoreIndex]->getHandle(), &currentImageIndex);
     graphics->getGraphicsCommands()->getCommands()->waitForSemaphore(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, imageAvailableSemaphores[currentSemaphoreIndex]);
@@ -284,14 +284,14 @@ void Window::chooseSwapSurfaceFormat()
 
 void Window::chooseSwapPresentMode()
 {
-    /*for (const auto& supportedPresentMode : supportedPresentModes)
+    for (const auto& supportedPresentMode : supportedPresentModes)
     {
         if (supportedPresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
         {
             presentMode = supportedPresentMode;
             return;
         }
-    }*/
+    }
     presentMode = VK_PRESENT_MODE_FIFO_KHR;
 }
 
diff --git a/src/Engine/ThreadPool.cpp b/src/Engine/ThreadPool.cpp
index c442eb2..52cd6ab 100644
--- a/src/Engine/ThreadPool.cpp
+++ b/src/Engine/ThreadPool.cpp
@@ -23,18 +23,18 @@ ThreadPool::~ThreadPool()
     }
 }
 
-//void ThreadPool::runAndWait(List<std::function<void()>> functions)
-//{
-//    std::unique_lock l(taskLock);
-//    currentTask.numRemaining = functions.size();
-//    currentTask.functions = std::move(functions);
-//    taskCV.notify_all();
-//    
-//    while (currentTask.numRemaining > 0)
-//    {
-//        completedCV.wait(l);
-//    }
-//}
+void ThreadPool::runAndWait(List<std::function<void()>> functions)
+{
+    std::unique_lock l(taskLock);
+    currentTask.numRemaining = functions.size();
+    currentTask.functions = std::move(functions);
+    taskCV.notify_all();
+    
+    while (currentTask.numRemaining > 0)
+    {
+        completedCV.wait(l);
+    }
+}
 
 void ThreadPool::work()
 {
diff --git a/src/Engine/ThreadPool.h b/src/Engine/ThreadPool.h
index 861e2ea..6871d46 100644
--- a/src/Engine/ThreadPool.h
+++ b/src/Engine/ThreadPool.h
@@ -9,9 +9,9 @@ namespace Seele
 class ThreadPool
 {
 public:
-    ThreadPool(uint32 numWorkers = std::thread::hardware_concurrency());
+    ThreadPool(uint32 numWorkers = std::thread::hardware_concurrency() - 2);
     ~ThreadPool();
-    //void runAndWait(List<std::function<void()>> functions);
+    void runAndWait(List<std::function<void()>> functions);
 private:
     struct Task
     {
diff --git a/src/Engine/Window/GameView.cpp b/src/Engine/Window/GameView.cpp
index 4ad8c53..f389261 100644
--- a/src/Engine/Window/GameView.cpp
+++ b/src/Engine/Window/GameView.cpp
@@ -12,6 +12,9 @@
 
 using namespace Seele;
 
+bool usePositionOnly = false;
+bool useViewCulling = false;
+
 GameView::GameView(Gfx::PGraphics graphics, PWindow window, const ViewportCreateInfo &createInfo, std::string dllPath)
     : View(graphics, window, createInfo, "Game")
     , scene(new Scene(graphics))
@@ -98,6 +101,22 @@ void GameView::reloadGame()
 void GameView::keyCallback(KeyCode code, InputAction action, KeyModifier modifier)
 {
     keyboardSystem->keyCallback(code, action, modifier);
+    if (code == KeyCode::KEY_P && action == InputAction::RELEASE)
+    {
+        usePositionOnly = true;
+    }
+    if (code == KeyCode::KEY_O && action == InputAction::RELEASE)
+    {
+        usePositionOnly = false;
+    }
+    if (code == KeyCode::KEY_L && action == InputAction::RELEASE)
+    {
+        useViewCulling = true;
+    }
+    if (code == KeyCode::KEY_K && action == InputAction::RELEASE)
+    {
+        useViewCulling = false;
+    }
 }
 
 void GameView::mouseMoveCallback(double xPos, double yPos)
diff --git a/src/Engine/Window/GameView.h b/src/Engine/Window/GameView.h
index 9a89aaf..ac1357d 100644
--- a/src/Engine/Window/GameView.h
+++ b/src/Engine/Window/GameView.h
@@ -6,8 +6,6 @@
 #include "Graphics/RenderPass/BasePass.h"
 #include "Graphics/RenderPass/SkyboxRenderPass.h"
 #include "Graphics/RenderPass/DebugPass.h"
-#include "Graphics/RenderPass/StaticDepthPrepass.h"
-#include "Graphics/RenderPass/StaticBasePass.h"
 #include "System/KeyboardInput.h"
 #ifdef WIN32
 #include "Platform/Windows/GameInterface.h" // TODO