Working simple implicit implementation

src/cube.mesh.glsl

@@ -1,51 +0,0 @@
-/* Copyright (c) 2021, Sascha Willems
-*
-* SPDX-License-Identifier: MIT
-*
-*/
-
-#version 450
-#extension GL_EXT_mesh_shader:require
-
-layout(push_constant)uniform PushConstantData{
-    mat4 world;
-    mat4 view;
-    mat4 proj;
-}pc;
-
-layout(local_size_x=1,local_size_y=1,local_size_z=1)in;
-layout(triangles,max_vertices=3,max_primitives=1)out;
-
-layout(location=0)out VertexOutput
-{
-    vec4 color;
-}vertexOutput[];
-
-const vec4[3]positions={
-    vec4(0.,-1.,0.,1.),
-    vec4(-1.,1.,0.,1.),
-    vec4(1.,1.,0.,1.)
-};
-
-const vec4[3]colors={
-    vec4(0.,1.,0.,1.),
-    vec4(0.,0.,1.,1.),
-    vec4(1.,0.,0.,1.)
-};
-
-void main()
-{
-    uint iid=gl_LocalInvocationID.x;
-    
-    vec4 offset=vec4(0.,0.,gl_GlobalInvocationID.x,0.);
-    
-    SetMeshOutputsEXT(3,1);
-    mat4 mvp=pc.proj*pc.view*pc.world;
-    gl_MeshVerticesEXT[0].gl_Position=mvp*(positions[0]+offset);
-    gl_MeshVerticesEXT[1].gl_Position=mvp*(positions[1]+offset);
-    gl_MeshVerticesEXT[2].gl_Position=mvp*(positions[2]+offset);
-    vertexOutput[0].color=colors[0];
-    vertexOutput[1].color=colors[1];
-    vertexOutput[2].color=colors[2];
-    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex]=uvec3(0,1,2);
-}

src/frag.glsl

@@ -1,21 +0,0 @@
-#version 450
-
-layout(location=0)in vec3 normal;
-layout(location=0)out vec4 f_color;
-
-layout(set=0,binding=0)uniform Data{
-    vec4[32]pos;
-    vec4[32]col;
-    uint light_count;
-}uniforms;
-
-void main(){
-    vec3 accum=vec3(0.,0.,0.);
-    
-    for(int i=0;i<uniforms.light_count;i++)
-    {
-        accum+=uniforms.col[i].xyz*((dot(normalize(normal),uniforms.pos[i].xyz)*.5)+.5);
-    }
-    
-    f_color=vec4(accum,1.);
-}

src/gui.rs

@@ -1,6 +1,6 @@
 use egui::{
     plot::{Line, Plot, PlotPoints},
-    Color32, Frame, Id, ScrollArea, TextEdit, TextStyle,
+    Color32, Frame, Id,
 };
 use egui_winit_vulkano::Gui;
 
@@ -10,14 +10,6 @@ fn sized_text(ui: &mut egui::Ui, text: impl Into<String>, size: f32) {
     ui.label(egui::RichText::new(text).size(size));
 }
 
-const CODE: &str = r#"
-# Some markup
-```
-let mut gui = Gui::new(&event_loop, renderer.surface(), renderer.queue());
-```
-Vulkan(o) is hard, that I know...
-"#;
-
 #[derive(Debug)]
 pub struct GState {
     pub cursor_sensitivity: f32,
@@ -44,7 +36,6 @@ impl Default for GState {
 }
 
 pub fn gui_up(gui: &mut Gui, state: &mut GState) {
-    let mut code = CODE.to_owned();
     gui.immediate_ui(|gui| {
         let ctx = gui.context();
         egui::SidePanel::left(Id::new("main_left"))

src/implicit.frag.glsl

@@ -0,0 +1,86 @@
+// Implicit Fragment shader
+
+#version 450
+
+layout(push_constant)uniform PushConstantData{
+    mat4 world;
+}pc;
+
+layout(set=0,binding=0)uniform Lights{
+    vec4[32]pos;
+    vec4[32]col;
+    uint light_count;
+}light_uniforms;
+
+layout(set=0,binding=1)uniform Camera{
+    mat4 view;
+    mat4 proj;
+    vec3 campos;
+}camera_uniforms;
+
+layout(constant_id=0)const uint RES_X=1920;
+layout(constant_id=1)const uint RES_Y=1080;
+
+layout(location=0)in VertexInput
+{
+    vec4 position;
+}vertexInput;
+
+layout(location=0)out vec4 f_color;
+
+const float EPSILON=.0001;
+const uint MAX_STEPS=50;
+
+float scene(vec3 p)
+{
+    return length(p-vec3(5.))-5.;
+}
+
+vec3 getNormal(vec3 p,float dens){
+    vec3 n;
+    n.x=scene(vec3(p.x+EPSILON,p.y,p.z));
+    n.y=scene(vec3(p.x,p.y+EPSILON,p.z));
+    n.z=scene(vec3(p.x,p.y,p.z+EPSILON));
+    return normalize(n-scene(p));
+}
+
+vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){
+    vec2 td=vec2(0.);
+    for(int i=0;i<MAX_STEPS;i++){
+        p=ori+dir*td.x;
+        td.y=scene(p);
+        if(td.y<EPSILON)break;
+        td.x+=(td.y)*.9;
+    }
+    return td;
+}
+#define frac_pi_2 1.57079632679489661923132169163975144
+void main(){
+    
+    vec3 raypos=vertexInput.position.xyz;
+    vec2 iResolution=vec2(RES_X,RES_Y);
+    vec2 iuv=gl_FragCoord.xy/iResolution.xy*2.-1.;
+    vec2 uv=iuv;
+    uv.x*=iResolution.x/iResolution.y;
+    vec3 p;
+    vec3 raydir=normalize(raypos-camera_uniforms.campos);
+    //raydir=(camera_uniforms.view*vec4(raydir,1.)).xyz;
+    vec2 td=spheretracing(raypos,raydir,p);
+    vec3 n=getNormal(p,td.y);
+    if(td.y<EPSILON)
+    {
+        vec3 accum=vec3(0.,0.,0.);
+        
+        for(int i=0;i<light_uniforms.light_count;i++)
+        {
+            accum+=light_uniforms.col[i].xyz*((dot(normalize(n),light_uniforms.pos[i].xyz)*.5)+.5);
+        }
+        
+        f_color=vec4(accum,1.);
+    }
+    else
+    {
+        //f_color=vec4(raydir,0.);
+        discard;
+    }
+}

src/implicit.mesh.glsl

@@ -0,0 +1,94 @@
+// Implicit Mesh shader
+
+#version 450
+#extension GL_EXT_mesh_shader:require
+
+layout(push_constant)uniform PushConstantData{
+    mat4 world;
+}pc;
+
+layout(set=0,binding=0)uniform Lights{
+    vec4[32]pos;
+    vec4[32]col;
+    uint light_count;
+}light_uniforms;
+
+layout(set=0,binding=1)uniform Camera{
+    mat4 view;
+    mat4 proj;
+    vec3 campos;
+}camera_uniforms;
+
+layout(local_size_x=1,local_size_y=1,local_size_z=1)in;
+layout(triangles,max_vertices=64,max_primitives=162)out;
+
+layout(location=0)out VertexOutput
+{
+    vec4 color;
+}vertexOutput[];
+
+const vec4[8]positions={
+    vec4(0.,0.,0.,1.),
+    vec4(0.,0.,1.,1.),
+    vec4(0.,1.,0.,1.),
+    vec4(0.,1.,1.,1.),
+    vec4(1.,0.,0.,1.),
+    vec4(1.,0.,1.,1.),
+    vec4(1.,1.,0.,1.),
+    vec4(1.,1.,1.,1.),
+};
+const mat4 scale=mat4(
+    10.,0.,0.,0.,
+    0.,10.,0.,0.,
+    0.,0.,10.,0.,
+    0.,0.,0.,1.
+);
+
+void main()
+{
+    uint iid=gl_LocalInvocationID.x;
+    
+    vec4 offset=vec4(0.,0.,gl_GlobalInvocationID.x,0.);
+    
+    SetMeshOutputsEXT(8,12);
+    mat4 mvp=camera_uniforms.proj*camera_uniforms.view*scale;
+    gl_MeshVerticesEXT[0].gl_Position=mvp*(positions[0]+offset);
+    gl_MeshVerticesEXT[1].gl_Position=mvp*(positions[1]+offset);
+    gl_MeshVerticesEXT[2].gl_Position=mvp*(positions[2]+offset);
+    gl_MeshVerticesEXT[3].gl_Position=mvp*(positions[3]+offset);
+    gl_MeshVerticesEXT[4].gl_Position=mvp*(positions[4]+offset);
+    gl_MeshVerticesEXT[5].gl_Position=mvp*(positions[5]+offset);
+    gl_MeshVerticesEXT[6].gl_Position=mvp*(positions[6]+offset);
+    gl_MeshVerticesEXT[7].gl_Position=mvp*(positions[7]+offset);
+    vertexOutput[0].color=scale*positions[0];
+    vertexOutput[1].color=scale*positions[1];
+    vertexOutput[2].color=scale*positions[2];
+    vertexOutput[3].color=scale*positions[3];
+    vertexOutput[4].color=scale*positions[4];
+    vertexOutput[5].color=scale*positions[5];
+    vertexOutput[6].color=scale*positions[6];
+    vertexOutput[7].color=scale*positions[7];
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+0]=uvec3(0,1,2);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+1]=uvec3(1,2,3);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+2]=uvec3(4,5,6);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+3]=uvec3(5,6,7);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+4]=uvec3(0,2,4);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+5]=uvec3(2,4,6);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+6]=uvec3(1,3,5);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+7]=uvec3(3,5,7);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+8]=uvec3(2,3,6);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+9]=uvec3(3,6,7);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+10]=uvec3(0,1,4);
+    gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex+11]=uvec3(1,4,5);
+}
+/*
+0 1 2 3 0
+4 5 6 7 4
+0 1 2
+1 2 3
+4 5 6
+5 6 7
+0 1 4
+1 4 5
+1 2
+*/

src/main.rs

@@ -1,55 +1,24 @@
-// Copyright (c) 2016 The vulkano developers
+use cgmath::{Deg, EuclideanSpace, Euler, Matrix3, Matrix4, Point3, Rad, SquareMatrix, Vector3};
-// Licensed under the Apache License, Version 2.0
-// <LICENSE-APACHE or
-// https://www.apache.org/licenses/LICENSE-2.0> or the MIT
-// license <LICENSE-MIT or https://opensource.org/licenses/MIT>,
-// at your option. All files in the project carrying such
-// notice may not be copied, modified, or distributed except
-// according to those terms.
-
-// Welcome to the triangle example!
-//
-// This is the only example that is entirely detailed. All the other examples avoid code
-// duplication by using helper functions.
-//
-// This example assumes that you are already more or less familiar with graphics programming
-// and that you want to learn Vulkan. This means that for example it won't go into details about
-// what a vertex or a shader is.
-use bytemuck::{Pod, Zeroable};
-use cgmath::{
-    AbsDiffEq, Basis3, Deg, EuclideanSpace, Euler, Matrix3, Matrix4, Point3, Quaternion, Rad,
-    SquareMatrix, Transform, Vector3,
-};
-use obj::{LoadConfig, ObjData};
-use rodio::{source::Source, Decoder, OutputStream};
 use std::io::Cursor;
 use std::{sync::Arc, time::Instant};
 use vulkano::buffer::allocator::{SubbufferAllocator, SubbufferAllocatorCreateInfo};
-use vulkano::buffer::sys::BufferCreateInfo;
+use vulkano::command_buffer::allocator::StandardCommandBufferAllocator;
-use vulkano::buffer::{Buffer, BufferAllocateInfo};
-use vulkano::command_buffer::allocator::{
-    CommandBufferAllocator, CommandBufferBuilderAlloc, StandardCommandBufferAllocator,
-};
-use vulkano::command_buffer::synced::SyncCommandBufferBuilder;
-use vulkano::command_buffer::sys::{CommandBufferBeginInfo, UnsafeCommandBufferBuilder};
-use vulkano::command_buffer::CommandBufferInheritanceInfo;
 use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
 use vulkano::descriptor_set::{PersistentDescriptorSet, WriteDescriptorSet};
-use vulkano::device::{DeviceOwned, QueueFlags};
+use vulkano::device::{DeviceOwned, Features, QueueFlags};
 use vulkano::format::Format;
 use vulkano::image::AttachmentImage;
-use vulkano::memory::allocator::{MemoryUsage, StandardMemoryAllocator};
+use vulkano::memory::allocator::StandardMemoryAllocator;
 use vulkano::pipeline::graphics::depth_stencil::DepthStencilState;
 use vulkano::pipeline::graphics::rasterization::CullMode;
 use vulkano::pipeline::graphics::rasterization::FrontFace::Clockwise;
 use vulkano::pipeline::graphics::vertex_input::Vertex;
 use vulkano::pipeline::PipelineBindPoint;
-use vulkano::shader::ShaderModule;
+use vulkano::shader::{ShaderModule, SpecializationConstants};
 use vulkano::swapchain::{PresentMode, SwapchainPresentInfo};
-use vulkano::{NonExhaustive, VulkanLibrary, VulkanObject};
+use vulkano::VulkanLibrary;
-use winit::event::{DeviceEvent, DeviceId, ElementState, MouseButton, VirtualKeyCode};
+use winit::event::{DeviceEvent, ElementState, MouseButton, VirtualKeyCode};
 
-use ash::vk::CommandBuffer;
 use egui_winit_vulkano::Gui;
 use vulkano::pipeline::StateMode::Fixed;
 use vulkano::{
@@ -61,13 +30,11 @@ use vulkano::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
     },
     image::{view::ImageView, ImageAccess, ImageUsage, SwapchainImage},
-    impl_vertex,
+    instance::{Instance, InstanceCreateInfo, InstanceExtensions},
-    instance::{Instance, InstanceCreateInfo, IntanceExtensions},
     pipeline::{
         graphics::{
             input_assembly::InputAssemblyState,
             rasterization::RasterizationState,
-            vertex_input::BuffersDefinition,
             viewport::{Viewport, ViewportState},
         },
         GraphicsPipeline, Pipeline,
@@ -93,23 +60,14 @@ use crate::objects::*;
 pub type MemoryAllocator = StandardMemoryAllocator;
 
 fn main() {
-    // The first step of any Vulkan program is to create an instance.
-    //
-    // When we create an instance, we have to pass a list of extensions that we want to enable.
-    //
-    // All the window-drawing functionalities are part of non-core extensions that we need
-    // to enable manually. To do so, we ask the `vulkano_win` crate for the list of extensions
-    // required to draw to a window.
     let library = VulkanLibrary::new().expect("Vulkan is not installed???");
     let required_extensions = vulkano_win::required_extensions(&library);
 
-    // Now creating the instance.
     let instance = Instance::new(
         library,
         InstanceCreateInfo {
-            enabled_extensions: IntanceExtensions {
+            enabled_extensions: InstanceExtensions {
-                khr_get_physical_device_properties2,
+                ..required_extensions
-                ..required_extensions,
             },
             // Enable enumerating devices that use non-conformant vulkan implementations. (ex. MoltenVK)
             enumerate_portability: true,
@@ -118,80 +76,32 @@ fn main() {
     )
     .unwrap();
 
-    // The objective of this example is to draw a triangle on a window. To do so, we first need to
-    // create the window.
-    //
-    // This is done by creating a `WindowBuilder` from the `winit` crate, then calling the
-    // `build_vk_surface` method provided by the `VkSurfaceBuild` trait from `vulkano_win`. If you
-    // ever get an error about `build_vk_surface` being undefined in one of your projects, this
-    // probably means that you forgot to import this trait.
-    //
-    // This returns a `vulkano::swapchain::Surface` object that contains both a cross-platform winit
-    // window and a cross-platform Vulkan surface that represents the surface of the window.
     let event_loop = EventLoop::new();
     let surface = WindowBuilder::new()
         .with_title("horizontally spinning bunny")
         .build_vk_surface(&event_loop, instance.clone())
         .unwrap();
 
-    // Choose device extensions that we're going to use.
-    // In order to present images to a surface, we need a `Swapchain`, which is provided by the
-    // `khr_swapchain` extension.
     let device_extensions = DeviceExtensions {
         khr_swapchain: true,
         ext_mesh_shader: true,
-        khr_spirv_1_4: true,
-        khr_shader_float_controls: true,
         ..DeviceExtensions::empty()
     };
 
-    // We then choose which physical device to use. First, we enumerate all the available physical
-    // devices, then apply filters to narrow them down to those that can support our needs.
     let (physical_device, queue_family_index) = instance
         .enumerate_physical_devices()
         .unwrap()
-        .filter(|p| {
+        .filter(|p| p.supported_extensions().contains(&device_extensions))
-            // Some devices may not support the extensions or features that your application, or
-            // report properties and limits that are not sufficient for your application. These
-            // should be filtered out here.
-            p.supported_extensions().contains(&device_extensions)
-        })
         .filter_map(|p| {
-            // For each physical device, we try to find a suitable queue family that will execute
-            // our draw commands.
-            //
-            // Devices can provide multiple queues to run commands in parallel (for example a draw
-            // queue and a compute queue), similar to CPU threads. This is something you have to
-            // have to manage manually in Vulkan. Queues of the same type belong to the same
-            // queue family.
-            //
-            // Here, we look for a single queue family that is suitable for our purposes. In a
-            // real-life application, you may want to use a separate dedicated transfer queue to
-            // handle data transfers in parallel with graphics operations. You may also need a
-            // separate queue for compute operations, if your application uses those.
             p.queue_family_properties()
                 .iter()
                 .enumerate()
                 .position(|(i, q)| {
-                    // We select a queue family that supports graphics operations. When drawing to
-                    // a window surface, as we do in this example, we also need to check that queues
-                    // in this queue family are capable of presenting images to the surface.
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
                         && p.surface_support(i as u32, &surface).unwrap_or(false)
                 })
-                // The code here searches for the first queue family that is suitable. If none is
-                // found, `None` is returned to `filter_map`, which disqualifies this physical
-                // device.
                 .map(|i| (p, i as u32))
         })
-        // All the physical devices that pass the filters above are suitable for the application.
-        // However, not every device is equal, some are preferred over others. Now, we assign
-        // each physical device a score, and pick the device with the
-        // lowest ("best") score.
-        //
-        // In this example, we simply select the best-scoring device to use in the application.
-        // In a real-life setting, you may want to use the best-scoring device only as a
-        // "default" or "recommended" device, and let the user choose the device themselves.
         .min_by_key(|(p, _)| {
             // We assign a lower score to device types that are likely to be faster/better.
             match p.properties().device_type {
@@ -212,48 +122,32 @@ fn main() {
         physical_device.properties().device_type,
     );
 
-    // Now initializing the device. This is probably the most important object of Vulkan.
-    //
-    // The iterator of created queues is returned by the function alongside the device.
     let (device, mut queues) = Device::new(
-        // Which physical device to connect to.
         physical_device,
         DeviceCreateInfo {
-            // A list of optional features and extensions that our program needs to work correctly.
-            // Some parts of the Vulkan specs are optional and must be enabled manually at device
-            // creation. In this example the only thing we are going to need is the `khr_swapchain`
-            // extension that allows us to draw to a window.
             enabled_extensions: device_extensions,
-
-            // The list of queues that we are going to use. Here we only use one queue, from the
-            // previously chosen queue family.
             queue_create_infos: vec![QueueCreateInfo {
                 queue_family_index,
                 ..Default::default()
             }],
-
+            enabled_features: Features {
+                mesh_shader: true,
+                task_shader: true,
+                ..Features::empty()
+            },
             ..Default::default()
         },
     )
     .expect("Unable to initialize device");
 
-    // Since we can request multiple queues, the `queues` variable is in fact an iterator. We
-    // only use one queue in this example, so we just retrieve the first and only element of the
-    // iterator.
     let queue = queues.next().expect("Unable to retrieve queues");
 
-    // Before we can draw on the surface, we have to create what is called a swapchain. Creating
-    // a swapchain allocates the color buffers that will contain the image that will ultimately
-    // be visible on the screen. These images are returned alongside the swapchain.
     let (mut swapchain, images) = {
-        // Querying the capabilities of the surface. When we create the swapchain we can only
-        // pass values that are allowed by the capabilities.
         let surface_capabilities = device
             .physical_device()
             .surface_capabilities(&surface, Default::default())
             .unwrap();
 
-        // Choosing the internal format that the images will have.
         let image_format = Some(
             device
                 .physical_device()
@@ -263,7 +157,6 @@ fn main() {
         );
         let window = surface.object().unwrap().downcast_ref::<Window>().unwrap();
 
-        // Please take a look at the docs for the meaning of the parameters we didn't mention.
         Swapchain::new(
             device.clone(),
             surface.clone(),
@@ -273,26 +166,10 @@ fn main() {
                     .min(surface_capabilities.max_image_count.unwrap_or(u32::MAX)),
 
                 image_format,
-                // The dimensions of the window, only used to initially setup the swapchain.
-                // NOTE:
-                // On some drivers the swapchain dimensions are specified by
-                // `surface_capabilities.current_extent` and the swapchain size must use these
-                // dimensions.
-                // These dimensions are always the same as the window dimensions.
-                //
-                // However, other drivers don't specify a value, i.e.
-                // `surface_capabilities.current_extent` is `None`. These drivers will allow
-                // anything, but the only sensible value is the window
-                // dimensions.
-                //
-                // Both of these cases need the swapchain to use the window dimensions, so we just
-                // use that.
                 image_extent: window.inner_size().into(),
 
                 image_usage: ImageUsage::COLOR_ATTACHMENT,
 
-                // The alpha mode indicates how the alpha value of the final image will behave. For
-                // example, you can choose whether the window will be opaque or transparent.
                 composite_alpha: surface_capabilities
                     .supported_composite_alpha
                     .into_iter()
@@ -307,66 +184,31 @@ fn main() {
         .unwrap()
     };
 
-    // The next step is to create the shaders.
-    //
-    // The raw shader creation API provided by the vulkano library is unsafe for various
-    // reasons, so The `shader!` macro provides a way to generate a Rust module from GLSL
-    // source - in the example below, the source is provided as a string input directly to
-    // the shader, but a path to a source file can be provided as well. Note that the user
-    // must specify the type of shader (e.g., "vertex," "fragment, etc.") using the `ty`
-    // option of the macro.
-    //
-    // The module generated by the `shader!` macro includes a `load` function which loads
-    // the shader using an input logical device. The module also includes type definitions
-    // for layout structures defined in the shader source, for example, uniforms and push
-    // constants.
-    //
-    // A more detailed overview of what the `shader!` macro generates can be found in the
-    // `vulkano-shaders` crate docs. You can view them at https://docs.rs/vulkano-shaders/
     mod mesh_vs {
         vulkano_shaders::shader! {
             ty: "vertex",
-            src: "
+            path: "src/triangle.vert.glsl",
-                #version 450
-            
-                layout(location = 0) in vec3 position;
-                layout(location = 1) in vec3 normal;
-                
-                layout(location = 0) out vec3 v_normal;
-                
-                layout(push_constant) uniform PushConstantData {
-                    mat4 world;
-                    mat4 view;
-                    mat4 proj;
-                } pc;
-                
-                void main() {
-                    mat4 worldview = pc.view * pc.world;
-                    v_normal = normal; //normalize(transpose(inverse(mat3(worldview))) * normal);
-                    gl_Position = pc.proj * worldview * vec4(position*1000.0, 1.0);
-                }
-			",
             types_meta: {
                 use bytemuck::{Pod, Zeroable};
 
                 #[derive(Clone, Copy, Zeroable, Pod, Debug)]
             },
             vulkan_version: "1.2",
-            spirv_version: "1.4"
+            spirv_version: "1.6"
         }
     }
 
     mod mesh_fs {
         vulkano_shaders::shader! {
             ty: "fragment",
-            path: "src/frag.glsl",
+            path: "src/triangle.frag.glsl",
             types_meta: {
                 use bytemuck::{Pod, Zeroable};
 
                 #[derive(Clone, Copy, Zeroable, Pod, Debug)]
             },
             vulkan_version: "1.2",
-            spirv_version: "1.4"
+            spirv_version: "1.6"
         }
     }
 
@@ -376,50 +218,43 @@ fn main() {
     mod implicit_ms {
         vulkano_shaders::shader! {
             ty: "mesh",
-            path: "src/cube.mesh.glsl",
+            path: "src/implicit.mesh.glsl",
             types_meta: {
                 use bytemuck::{Pod, Zeroable};
 
                 #[derive(Clone, Copy, Zeroable, Pod, Debug)]
             },
             vulkan_version: "1.2",
-            spirv_version: "1.4"
+            spirv_version: "1.6"
+        }
+    }
+
+    mod implicit_fs {
+        vulkano_shaders::shader! {
+            ty: "fragment",
+            path: "src/implicit.frag.glsl",
+            types_meta: {
+                use bytemuck::{Pod, Zeroable};
+
+                #[derive(Clone, Copy, Zeroable, Pod, Debug)]
+            },
+            vulkan_version: "1.2",
+            spirv_version: "1.6"
         }
     }
 
     let implicit_ms = implicit_ms::load(device.clone()).unwrap();
-
+    let implicit_fs = implicit_fs::load(device.clone()).unwrap();
-    /*let uniform_buffer =
-    CpuBufferPool::<vs::ty::PushConstantData>::uniform_buffer(memory_allocator);*/
 
     let memory_allocator = Arc::new(MemoryAllocator::new_default(device.clone()));
 
-    // At this point, OpenGL initialization would be finished. However in Vulkan it is not. OpenGL
-    // implicitly does a lot of computation whenever you draw. In Vulkan, you have to do all this
-    // manually.
-
-    // The next step is to create a *render pass*, which is an object that describes where the
-    // output of the graphics pipeline will go. It describes the layout of the images
-    // where the colors, depth and/or stencil information will be written.
     let render_pass = vulkano::ordered_passes_renderpass!(
         device.clone(),
         attachments: {
-            // `color` is a custom name we give to the first and only attachment.
             color: {
-                // `load: Clear` means that we ask the GPU to clear the content of this
-                // attachment at the start of the drawing.
                 load: Clear,
-                // `store: Store` means that we ask the GPU to store the output of the draw
-                // in the actual image. We could also ask it to discard the result.
                 store: Store,
-                // `format: <ty>` indicates the type of the format of the image. This has to
-                // be one of the types of the `vulkano::format` module (or alternatively one
-                // of your structs that implements the `FormatDesc` trait). Here we use the
-                // same format as the swapchain.
                 format: swapchain.image_format(),
-                // `samples: 1` means that we ask the GPU to use one sample to determine the value
-                // of each pixel in the color attachment. We could use a larger value (multisampling)
-                // for antialiasing. An example of this can be found in msaa-renderpass.rs.
                 samples: 1,
             },
             depth: {
@@ -430,69 +265,41 @@ fn main() {
             }
         },
         passes: [{
-            // We use the attachment named `color` as the one and only color attachment.
             color: [color],
-            // No depth-stencil attachment is indicated with empty brackets.
             depth_stencil: {depth},
             input: []
         },{
-            // We use the attachment named `color` as the one and only color attachment.
             color: [color],
-            // No depth-stencil attachment is indicated with empty brackets.
             depth_stencil: {depth},
             input: []
         }]
     )
     .unwrap();
 
-    // Dynamic viewports allow us to recreate just the viewport when the window is resized
-    // Otherwise we would have to recreate the whole pipeline.
     let mut viewport = Viewport {
         origin: [0.0, 0.0],
         dimensions: [0.0, 0.0],
         depth_range: 0.0..1.0,
     };
 
-    // The render pass we created above only describes the layout of our framebuffers. Before we
+    let [RES_X, RES_Y] = images[0].dimensions().width_height();
-    // can draw we also need to create the actual framebuffers.
+    let ([mut mesh_pipeline, mut implicit_pipeline], mut framebuffers) =
-    //
+        window_size_dependent_setup(
-    // Since we need to draw to multiple images, we are going to create a different framebuffer for
+            &memory_allocator,
-    // each image.
+            &mesh_vs,
-    let ([mut mesh_pipeline], mut framebuffers) = window_size_dependent_setup(
+            &mesh_fs,
-        &memory_allocator,
+            &implicit_ms,
-        &mesh_vs,
+            &implicit_fs,
-        &mesh_fs,
+            &images,
-        &implicit_ms,
+            render_pass.clone(),
-        &images,
+            &mut viewport,
-        render_pass.clone(),
+            implicit_fs::SpecializationConstants { RES_X, RES_Y },
-        &mut viewport,
+        );
-    );
 
-    // Before we can start creating and recording command buffers, we need a way of allocating
-    // them. Vulkano provides a command buffer allocator, which manages raw Vulkan command pools
-    // underneath and provides a safe interface for them.
     let command_buffer_allocator =
         StandardCommandBufferAllocator::new(device.clone(), Default::default());
 
-    // Initialization is finally finished!
-
-    // In some situations, the swapchain will become invalid by itself. This includes for example
-    // when the window is resized (as the images of the swapchain will no longer match the
-    // window's) or, on Android, when the application went to the background and goes back to the
-    // foreground.
-    //
-    // In this situation, acquiring a swapchain image or presenting it will return an error.
-    // Rendering to an image of that swapchain will not produce any error, but may or may not work.
-    // To continue rendering, we need to recreate the swapchain by creating a new swapchain.
-    // Here, we remember that we need to do this for the next loop iteration.
     let mut recreate_swapchain = false;
-
-    // In the loop below we are going to submit commands to the GPU. Submitting a command produces
-    // an object that implements the `GpuFuture` trait, which holds the resources for as long as
-    // they are in use by the GPU.
-    //
-    // Destroying the `GpuFuture` blocks until the GPU is finished executing it. In order to avoid
-    // that, we store the submission of the previous frame here.
     let mut previous_frame_end = Some(sync::now(device.clone()).boxed());
 
     /*
@@ -513,7 +320,6 @@ fn main() {
     let uniform_buffer = SubbufferAllocator::new(
         memory_allocator.clone(),
         SubbufferAllocatorCreateInfo {
-            // We want to use the allocated subbuffers as vertex buffers.
             buffer_usage: BufferUsage::UNIFORM_BUFFER,
             ..Default::default()
         },
@@ -578,7 +384,7 @@ fn main() {
                     WindowEvent::ScaleFactorChanged { .. } => {
                         recreate_swapchain = true;
                     }
-                    WindowEvent::DroppedFile(file) => {
+                    WindowEvent::DroppedFile(_file) => {
                         todo!()
                     }
                     WindowEvent::MouseInput {
@@ -622,7 +428,6 @@ fn main() {
                     camforward.x = camforward.x + Deg(360f32) % Deg(360f32);
                     camforward.y = camforward.y + Deg(360f32) % Deg(360f32);
                 }
-                //println!("AXISM {:?}", delta);
             }
             Event::RedrawEventsCleared => {
                 for i in 1..gstate.fps.len() {
@@ -634,55 +439,43 @@ fn main() {
 
                 render_start = Instant::now();
 
-                // Do not draw frame when screen dimensions are zero.
-                // On Windows, this can occur from minimizing the application.
                 let window = surface.object().unwrap().downcast_ref::<Window>().unwrap();
                 let dimensions = window.inner_size();
                 if dimensions.width == 0 || dimensions.height == 0 {
                     return;
                 }
 
-                // It is important to call this function from time to time, otherwise resources will keep
-                // accumulating and you will eventually reach an out of memory error.
-                // Calling this function polls various fences in order to determine what the GPU has
-                // already processed, and frees the resources that are no longer needed.
                 previous_frame_end.as_mut().unwrap().cleanup_finished();
 
-                // Whenever the window resizes we need to recreate everything dependent on the window size.
-                // In this example that includes the swapchain, the framebuffers and the dynamic state viewport.
                 if recreate_swapchain {
-                    // Use the new dimensions of the window.
-
                     let (new_swapchain, new_images) =
                         match swapchain.recreate(SwapchainCreateInfo {
                             image_extent: dimensions.into(),
                             ..swapchain.create_info()
                         }) {
                             Ok(r) => r,
-                            // This error tends to happen when the user is manually resizing the window.
-                            // Simply restarting the loop is the easiest way to fix this issue.
                             Err(SwapchainCreationError::ImageExtentNotSupported { .. }) => return,
                             Err(e) => panic!("Failed to recreate swapchain: {e:?}"),
                         };
 
                     swapchain = new_swapchain;
-                    // Because framebuffers contains an Arc on the old swapchain, we need to
+                    let [RES_X, RES_Y] = images[0].dimensions().width_height();
-                    // recreate framebuffers as well.
+                    ([mesh_pipeline, implicit_pipeline], framebuffers) =
-                    ([mesh_pipeline], framebuffers) = window_size_dependent_setup(
+                        window_size_dependent_setup(
-                        &memory_allocator,
+                            &memory_allocator,
-                        &mesh_vs,
+                            &mesh_vs,
-                        &mesh_fs,
+                            &mesh_fs,
-                        &implicit_ms,
+                            &implicit_ms,
-                        &new_images,
+                            &implicit_fs,
-                        render_pass.clone(),
+                            &new_images,
-                        &mut viewport,
+                            render_pass.clone(),
-                    );
+                            &mut viewport,
+                            implicit_fs::SpecializationConstants { RES_X, RES_Y },
+                        );
                     recreate_swapchain = false;
                 }
 
-                //println!("{:?}", right);
+                let (mut push_constants, cam_set) = {
-
-                let mut push_constants = {
                     if looking {
                         if keys.w {
                             campos -= Matrix3::from_angle_y(camforward.y)
@@ -719,8 +512,6 @@ fn main() {
                         keys.d = false;
                     }
 
-                    // note: this teapot was meant for OpenGL where the origin is at the lower left
-                    //       instead the origin is at the upper left in Vulkan, so we reverse the Y axis
                     let aspect_ratio =
                         swapchain.image_extent()[0] as f32 / swapchain.image_extent()[1] as f32;
                     let proj = cgmath::perspective(
@@ -734,23 +525,25 @@ fn main() {
                         * Matrix4::from_angle_z(Deg(180f32))
                         * Matrix4::from_translation(Point3::origin() - campos)
                         * Matrix4::from_scale(scale);
-                    //*Matrix4::from_angle_z(Deg(180f32));
 
                     let pc = mesh_vs::ty::PushConstantData {
                         world: Matrix4::identity().into(),
-                        view: view.into(),
-                        proj: proj.into(),
                     };
 
+                    let uniform_data = mesh_fs::ty::Camera {
+                        view: view.into(),
+                        proj: proj.into(),
+                        campos: (campos * 100.0).into(),
+                    };
+
+                    let sub = uniform_buffer.allocate_sized().unwrap();
+                    *sub.write().unwrap() = uniform_data;
+
                     if looking {
-                        /*println!(
-                            "world: {:?} view: {:?} proj: {:?}",
-                            pc.world, pc.view, pc.proj
-                        );*/
                         println!("campos: {:?} camforward: {:?}", campos, camforward);
                     }
 
-                    pc
+                    (pc, sub)
                 };
 
                 let uniform_buffer_subbuffer = {
@@ -766,7 +559,7 @@ fn main() {
                         col[i][2] = light.colour.z;
                     }
 
-                    let uniform_data = mesh_fs::ty::Data {
+                    let uniform_data = mesh_fs::ty::Lights {
                         pos,
                         col,
                         light_count: gstate.lights.len() as u32,
@@ -777,21 +570,28 @@ fn main() {
                     sub
                 };
 
-                let layout = mesh_pipeline.layout().set_layouts().get(0).unwrap();
+                let mesh_layout = mesh_pipeline.layout().set_layouts().get(0).unwrap();
-                let set = PersistentDescriptorSet::new(
+                let mesh_set = PersistentDescriptorSet::new(
                     &descriptor_set_allocator,
-                    layout.clone(),
+                    mesh_layout.clone(),
-                    [WriteDescriptorSet::buffer(0, uniform_buffer_subbuffer)],
+                    [
+                        WriteDescriptorSet::buffer(0, uniform_buffer_subbuffer.clone()),
+                        WriteDescriptorSet::buffer(1, cam_set.clone()),
+                    ],
+                )
+                .unwrap();
+
+                let implicit_layout = implicit_pipeline.layout().set_layouts().get(0).unwrap();
+                let implicit_set = PersistentDescriptorSet::new(
+                    &descriptor_set_allocator,
+                    implicit_layout.clone(),
+                    [
+                        WriteDescriptorSet::buffer(0, uniform_buffer_subbuffer.clone()),
+                        WriteDescriptorSet::buffer(1, cam_set.clone()),
+                    ],
                 )
                 .unwrap();
 
-                // Before we can draw on the output, we have to *acquire* an image from the swapchain. If
-                // no image is available (which happens if you submit draw commands too quickly), then the
-                // function will block.
-                // This operation returns the index of the image that we are allowed to draw upon.
-                //
-                // This function can block if no image is available. The parameter is an optional timeout
-                // after which the function call will return an error.
                 let (image_index, suboptimal, acquire_future) =
                     match acquire_next_image(swapchain.clone(), None) {
                         Ok(r) => r,
@@ -802,24 +602,12 @@ fn main() {
                         Err(e) => panic!("Failed to acquire next image: {:?}", e),
                     };
 
-                // acquire_next_image can be successful, but suboptimal. This means that the swapchain image
-                // will still work, but it may not display correctly. With some drivers this can be when
-                // the window resizes, but it may not cause the swapchain to become out of date.
                 if suboptimal {
                     recreate_swapchain = true;
                 }
 
                 gui_up(&mut gui, &mut gstate);
 
-                // In order to draw, we have to build a *command buffer*. The command buffer object holds
-                // the list of commands that are going to be executed.
-                //
-                // Building a command buffer is an expensive operation (usually a few hundred
-                // microseconds), but it is known to be a hot path in the driver and is expected to be
-                // optimized.
-                //
-                // Note that we have to pass a queue family when we create the command buffer. The command
-                // buffer will only be executable on that given queue family.
                 let mut builder = AutoCommandBufferBuilder::primary(
                     &command_buffer_allocator,
                     queue.queue_family_index(),
@@ -830,15 +618,8 @@ fn main() {
                 let cb = gui.draw_on_subpass_image(dimensions.into());
 
                 builder
-                    // Before we can draw, we have to *enter a render pass*.
                     .begin_render_pass(
                         RenderPassBeginInfo {
-                            // A list of values to clear the attachments with. This list contains
-                            // one item for each attachment in the render pass. In this case,
-                            // there is only one attachment, and we clear it with a blue color.
-                            //
-                            // Only attachments that have `LoadOp::Clear` are provided with clear
-                            // values, any others should use `ClearValue::None` as the clear value.
                             clear_values: vec![
                                 Some([0.12, 0.1, 0.1, 1.0].into()),
                                 Some(1.0.into()),
@@ -847,23 +628,16 @@ fn main() {
                                 framebuffers[image_index as usize].clone(),
                             )
                         },
-                        // The contents of the first (and only) subpass. This can be either
-                        // `Inline` or `SecondaryCommandBuffers`. The latter is a bit more advanced
-                        // and is not covered here.
                         SubpassContents::Inline,
                     )
                     .unwrap()
-                    // We are now inside the first subpass of the render pass. We add a draw command.
-                    //
-                    // The last two parameters contain the list of resources to pass to the shaders.
-                    // Since we used an `EmptyPipeline` object, the objects have to be `()`.
                     .set_viewport(0, [viewport.clone()])
                     .bind_pipeline_graphics(mesh_pipeline.clone())
                     .bind_descriptor_sets(
                         PipelineBindPoint::Graphics,
                         mesh_pipeline.layout().clone(),
                         0,
-                        set,
+                        mesh_set,
                     );
 
                 for object in &gstate.meshes {
@@ -880,38 +654,20 @@ fn main() {
                         .unwrap();
                 }
 
-                /*unsafe {
+                push_constants.world = Matrix4::identity().into();
-                    let secondary_builder = AutoCommandBufferBuilder::secondary(
+
-                        &command_buffer_allocator,
+                builder
-                        queue_family_index,
+                    .bind_pipeline_graphics(implicit_pipeline.clone())
-                        CommandBufferUsage::OneTimeSubmit,
+                    .bind_descriptor_sets(
-                        CommandBufferInheritanceInfo {
+                        PipelineBindPoint::Graphics,
-                            render_pass: Some(
+                        implicit_pipeline.layout().clone(),
-                                Subpass::from(render_pass.clone(), 0).unwrap().into(),
+                        0,
-                            ),
+                        implicit_set,
-                            ..Default::default()
-                        },
                     )
-                    .unwrap();
+                    .push_constants(implicit_pipeline.layout().clone(), 0, push_constants);
-
-                    let secondary_buffer = secondary_builder.build().unwrap();
-
-                    (device.fns().ext_mesh_shader.cmd_draw_mesh_tasks_ext)(
-                        secondary_buffer.handle(),
-                        1,
-                        1,
-                        1,
-                    );
-
-                    /*builder
-                    .execute_commands(secondary_buffer)
-                    .expect("Failed to execute chicanery");*/
-                }*/
 
                 builder.draw_mesh([1, 1, 1]).unwrap();
 
-                // We leave the render pass. Note that if we had multiple
-                // subpasses we could have called `next_subpass` to jump to the next subpass.
                 builder
                     .next_subpass(SubpassContents::SecondaryCommandBuffers)
                     .unwrap()
@@ -920,7 +676,6 @@ fn main() {
                     .end_render_pass()
                     .unwrap();
 
-                // Finish building the command buffer by calling `build`.
                 let command_buffer = builder.build().unwrap();
 
                 let future = previous_frame_end
@@ -929,12 +684,6 @@ fn main() {
                     .join(acquire_future)
                     .then_execute(queue.clone(), command_buffer)
                     .unwrap()
-                    // The color output is now expected to contain our triangle. But in order to show it on
-                    // the screen, we have to *present* the image by calling `present`.
-                    //
-                    // This function does not actually present the image immediately. Instead it submits a
-                    // present command at the end of the queue. This means that it will only be presented once
-                    // the GPU has finished executing the command buffer that draws the triangle.
                     .then_swapchain_present(
                         queue.clone(),
                         SwapchainPresentInfo::swapchain_image_index(swapchain.clone(), image_index),
@@ -961,15 +710,20 @@ fn main() {
 }
 
 /// This method is called once during initialization, then again whenever the window is resized
-fn window_size_dependent_setup(
+fn window_size_dependent_setup<Mms>(
     allocator: &StandardMemoryAllocator,
     mesh_vs: &ShaderModule,
     mesh_fs: &ShaderModule,
     implicit_ms: &ShaderModule,
+    implicit_fs: &ShaderModule,
     images: &[Arc<SwapchainImage>],
     render_pass: Arc<RenderPass>,
     viewport: &mut Viewport,
-) -> ([Arc<GraphicsPipeline>; 1], Vec<Arc<Framebuffer>>) {
+    specs: Mms,
+) -> ([Arc<GraphicsPipeline>; 2], Vec<Arc<Framebuffer>>)
+where
+    Mms: SpecializationConstants,
+{
     let dimensions = images[0].dimensions().width_height();
     viewport.dimensions = [dimensions[0] as f32, dimensions[1] as f32];
 
@@ -993,18 +747,10 @@ fn window_size_dependent_setup(
         })
         .collect::<Vec<_>>();
 
-    // Before we draw we have to create what is called a pipeline. This is similar to an OpenGL
-    // program, but much more specific.
     let mesh_pipeline = GraphicsPipeline::start()
-        // We have to indicate which subpass of which render pass this pipeline is going to be used
-        // in. The pipeline will only be usable from this particular subpass.
         .render_pass(Subpass::from(render_pass.clone(), 0).unwrap())
-        // We need to indicate the layout of the vertices.
         .vertex_input_state(OVertex::per_vertex())
-        // The content of the vertex buffer describes a list of triangles.
         .input_assembly_state(InputAssemblyState::new())
-        // A Vulkan shader can in theory contain multiple entry points, so we have to specify
-        // which one.
         .vertex_shader(mesh_vs.entry_point("main").unwrap(), ())
         .viewport_state(ViewportState::viewport_fixed_scissor_irrelevant([
             Viewport {
@@ -1013,18 +759,35 @@ fn window_size_dependent_setup(
                 depth_range: 0.0..1.0,
             },
         ]))
-        // See `vertex_shader`.
         .fragment_shader(mesh_fs.entry_point("main").unwrap(), ())
-        .mesh_shader(implicit_ms.entry_point("main").unwrap(), ())
         .depth_stencil_state(DepthStencilState::simple_depth_test())
         .rasterization_state(RasterizationState {
             front_face: Fixed(Clockwise),
             cull_mode: Fixed(CullMode::Back),
             ..RasterizationState::default()
         })
-        // Now that our builder is filled, we call `build()` to obtain an actual pipeline.
         .build(allocator.device().clone())
         .unwrap();
 
-    ([mesh_pipeline], framebuffers)
+    let implicit_pipeline = GraphicsPipeline::start()
+        .render_pass(Subpass::from(render_pass.clone(), 0).unwrap())
+        .vertex_input_state(OVertex::per_vertex())
+        .input_assembly_state(InputAssemblyState::new())
+        .viewport_state(ViewportState::viewport_fixed_scissor_irrelevant([
+            Viewport {
+                origin: [0.0, 0.0],
+                dimensions: [dimensions[0] as f32, dimensions[1] as f32],
+                depth_range: 0.0..1.0,
+            },
+        ]))
+        .fragment_shader(implicit_fs.entry_point("main").unwrap(), specs)
+        .mesh_shader(implicit_ms.entry_point("main").unwrap(), ())
+        .depth_stencil_state(DepthStencilState::simple_depth_test())
+        .rasterization_state(RasterizationState {
+            ..RasterizationState::default()
+        })
+        .build(allocator.device().clone())
+        .unwrap();
+
+    ([mesh_pipeline, implicit_pipeline], framebuffers)
 }

src/objects.rs

@@ -1,7 +1,7 @@
-use std::{collections::HashMap, io::Read, sync::Arc};
+use std::{collections::HashMap, io::Read};
 
 use bytemuck::{Pod, Zeroable};
-use cgmath::{Deg, Euler, Matrix3, Point3, SquareMatrix, Vector3};
+use cgmath::{Deg, Euler, Point3, Vector3};
 use obj::{LoadConfig, ObjData};
 use vulkano::{
     buffer::{Buffer, BufferAllocateInfo, BufferUsage, Subbuffer},

src/triangle.frag.glsl

@@ -0,0 +1,32 @@
+#version 450
+
+layout(push_constant)uniform PushConstantData{
+    mat4 world;
+}pc;
+
+layout(set=0,binding=0)uniform Lights{
+    vec4[32]pos;
+    vec4[32]col;
+    uint light_count;
+}light_uniforms;
+
+layout(set=0,binding=1)uniform Camera{
+    mat4 view;
+    mat4 proj;
+    vec3 campos;
+}camera_uniforms;
+
+layout(location=0)in vec3 normal;
+
+layout(location=0)out vec4 f_color;
+
+void main(){
+    vec3 accum=vec3(0.,0.,0.);
+    
+    for(int i=0;i<light_uniforms.light_count;i++)
+    {
+        accum+=light_uniforms.col[i].xyz*((dot(normalize(normal),light_uniforms.pos[i].xyz)*.5)+.5);
+    }
+    
+    f_color=vec4(accum,1.);
+}

src/triangle.vert.glsl

@@ -0,0 +1,28 @@
+#version 450
+
+layout(push_constant)uniform PushConstantData{
+    mat4 world;
+}pc;
+
+layout(set=0,binding=0)uniform Lights{
+    vec4[32]pos;
+    vec4[32]col;
+    uint light_count;
+}light_uniforms;
+
+layout(set=0,binding=1)uniform Camera{
+    mat4 view;
+    mat4 proj;
+    vec3 campos;
+}camera_uniforms;
+
+layout(location=0)in vec3 position;
+layout(location=1)in vec3 normal;
+
+layout(location=0)out vec3 v_normal;
+
+void main(){
+    mat4 worldview=camera_uniforms.view*pc.world;
+    v_normal=normal;//normalize(transpose(inverse(mat3(worldview))) * normal);
+    gl_Position=camera_uniforms.proj*worldview*vec4(position*1000.,1.);
+}