diff --git a/notes/VKProcessor.txt b/notes/VKProcessor.txt new file mode 100644 index 00000000..15731368 --- /dev/null +++ b/notes/VKProcessor.txt @@ -0,0 +1,64 @@ +Content-Type: text/x-zim-wiki +Wiki-Format: zim 0.4 +Creation-Date: 2020-01-21T00:01:37-08:00 + +====== VKProcessor ====== + +===== Details ===== +Vk Processors is a do_all class for interaction with the render window. And the vulkan state and backend. Unfortunately this explodes out to managing all of the textures, kernels, shaders, and fonts. VKProcessor gives out handles to these stored data which can then be used in other parts of the program. + +[[https://www.draw.io/?lightbox=1&highlight=0000ff&edit=_blank&layers=1&nav=1&title=vkprocessor.drawio#R%3Cmxfile%20pages%3D%222%22%3E%3Cdiagram%20id%3D%22eBoc7Yustm6TUbQq-vnT%22%20name%3D%22VKProcessor%20Overview%22%3E7V1bd5s4EP41Oaf74ByEuD4mzqXppt2cOKfbPspYttli8HLJpb9%2BJYMwIBljG4y8SR5aEBK2Zr75NDO6%2BAwOF6%2B3IVrOvwYT7J2pyuT1DF6dqSqAlkL%2BoyVvWQkwQFoyC91JVrYuGLm%2FcVaYNZwl7gRHpYpxEHixuywXOoHvYyculaEwDF7K1aaBV%2F7UJZpln6isC0YO8jBX7W93Es%2FZtyN%2F6yefsTubx9yjBWL1s4JojibBS6EIXp%2FBYRgEcXq1eB1ijwqQiSZtd7Phaf7dQuzHTRqolwvXhImdzMCvaHb%2Fz%2F3t1esAZK95Rl6SdXqI%2FGcUPeHXOAnxmWp45O2X45BczehV3yUrUcZvTEVhkPgTTLuokMcvczfGoyVy6NMXgkpSNo8XHrkDeeuiyFj3cRjj10JRJsJbHCxwHL6RKtlTjek3w%2FQAQOVcT4teChhh2J8X0aFlhSjD5Sx%2F%2FVpv5CJT3S5qVDeo8W5BIf6hxLISdbuqRGakRRXax1Uh3KDCm4D080ODZQ2anAaBDGZobtBh7%2FLK%2B7ymLZWXliqQFjRakFbwc3nvPH02tLflzWOifPls%2F%2F4%2BMCEnFjwh4292G4TxPJgFPvKu16WXZcGt69wHwTIT1z84jt8yZwIlcVAWJn514x%2BF65%2F0VQQ66d3Va%2Fbm1c0bu%2FFJf3%2BsKioKZAVpS6ibrGDdeHVXav2AQ5eIDYdZYRSjML6gPgop8AMfs7Ibl0oxazhhNRwPRZHrpIVZlVpoREESOrgOq1bmUKFwhuOaitBOK1Ld1EItxB6K3eey79S%2BjVmbeDJEC9y7oQ3UioMAVAEtKQJD687OACcV6e2sbGP6Fgvr35jshsbE0CuLMdmcMV2F6AWNPXzgmDUlYh0GXhCu2sIJwtbUWaklDH7hwhPDsfB42pLxwarxaYAzPpFLoFodCZiNsgUBXzhOskiIdgUiPqJdKvvYJdjNLvc3KOaJbB%2BdFKkMin3v4ugULJZJfKompVUcbRMIIiWR39jGcCbWuM6J%2BCvySZh7guZ0rgCzYlKato87eYCl6U0tDcplaTwMLpPplEhEVYYkZEauj8Oo7zBZzgDcQ2PsPQSRG7uBTx0ighoKpUvKC65D4F%2BpsHAnk5W9IM%2BdCVtcZA%2Fymi1wj2mVuSfnogL35DxTivCtrshHNTbwe%2F%2BRRzUlomu9M7Vxcoxc8Gl%2BFv2d1h0c2NjBkYt24QYHR47oW9Wl81YEEyxUXn%2Fi0KfTZVVi%2F%2BSQp%2B7KV1QIsok83CX2yFj2R%2B%2FChZUcoqb3Llztf%2BMKVohH6Y542ETqiRGP1msWa0%2Bd2rZRdu8twzque8%2B0eGppXiiYDqO8OYqRBL4WqIwzmtWQCrvzTCGfyvv%2B6yEMHBxFQdi7xAZGWWLNJ6AsRT9cZMLEuKGdHqWU6UTdKTO%2BznsXk%2BONM99iGfL0Iq7XW55OPCei9Kn6PecedwpNjjkn0hQZtXMQkiCDD%2FBHy9CVYMwZEH%2F7HBiFP1hiVGALJhq7csfFout1Qr8NPu2dTs3TpFPDOj06PUDzfdCpABmnQKeCFVErN%2F5EOFW0eOO4nKqeHqeeK7AS9hqWscW%2Bti%2BS6oJuBWugToJu7dOj293yW73TbdPVcZLRLb84ji7kl55n9b5pVrCA%2FjPy6UymqjzRNPwIe9PexWiwVAhLoojSTqIJUbUzufFpuos4Rs58QXqZbT5Q2Ly8bNIToU4ova4SUICfv7jCMXK9%2FheMc8ISeUIiYcHOoMZH5hKaqAYqeU5bkOY8ronyLvjdYpGuSJPMQjnhGWbfFsoPqLJYKCcs2FBY3VkoPwUhoYVainKuAk21dHP1r1WWoincR3RUixUsIv2edk8aS90iRE1vLMSuLDfvk3yWu0V4oLHwOrNklXeH88WVTmFxpULEQP4NfI92L4mIEFVlTK%2FjOX3giHe%2FRXO0pJcO8rwgibcLfVlIDGSNCrmCVlYOVTfIqSwk2D4%2F2ZUSeN%2F6kbzYxc9UtIxZD8HyPAjd31SdLKRuQZCA3yDNCxIK5Jjvt20%2FKJZoo6HaMF8yoFsNK1k0qG2b9Ot9q6FQ%2FrDxVGD2xvaSKaumpGforVBhGbh%2BHBXe%2FEAL1hCu7iIaWFoRg3x9vbY%2BuUi%2FwRrBeVcOADUfO8qD8v%2FplHZzIKtyALmygH6gKfVAri64r69uWHpN9Y5gr8uDcvPdw7z1JaL7wbzCv%2FpObJ1tj95U3bLqqncDcsinuoR7m2Tz%2FVRzX9%2BPuWjtT5XxsfQJONEDgRfNp%2FpFklTbONxEPJPPb7jjqVhES6J55XOjxKRA0eqplNxU3doivcLKoRwUd10ts66F2daZZLUpZRb0rAv0zMp2Y1aO3QbVJGI1mk17nrWqoUn%2BfJnKi1LJcC9qizJNnjLfDTplwRIjceYOgnPbUNZ%2FbFTbFVoAaOe2XXgRKH8MiZStwlPtqLiz2sDdpkUSBCl7RfxrIJtlIKtgZyDvz4mM6rZyIgOGJDgGnBej70mK%2BRRBnlRUjsuKFj%2F3907QKQuW1DJZQVtIZTsDi4u8z21TtfM%2F3egKZj%2BDkfXn%2BMv0zrx9%2B%2FF7Ppx8%2BRfkM48yBOVNE6w7rv%2FtdrGZYLWZWNCtJ0gPS6zzs%2BOjOZqU41QOGr1HV9UwlfmO24JUTTtcjkK1qr1uRNsrdbvjSVAF88kyWmvbaexliGXX0HTan1s4TOWCgTk7C4AdBXD37en68eZieM2ekA8abz4SZpgeHDBZHcbtOtFDdnDAI05lKDgL59OF59FDskn%2FHLpP9Cw7cyCkTUhB%2F2cODLRq%2Bk10BozIWttYKirUHM95vOa%2BPtxff73%2B9nTxdPfXt2bqe0z8mLg26UKPKzwVaCuKw8ShXgCRuzOnfWPqWxKvKAVtpsFnnC4XmeCp66en%2BKxm7onko9VN33oFNhmqNQBNGwIFaloldgRAcHrNcfUsOBq9oOiC8Ix%2FkyBfwzCIUrFdkCp%2BEC6Qt66ws2Ef8iHsPaSqf9ibNhFL4dunHyJrBz7dYuKHEI%2BNaJweWzWlLejPAay%2B4cphoVS36dQtrn99206VEy2joa3oZle20mQ424MU6eYF5lFydJi7mqkiJyF6cf0ZZUDSSoKhq3pIRP9Dl2BNXCtqyuxrd02FeDWeIX9CdZU4cwnV1ti6ulNb%2B85i7mbk3gGntDuOKserOcgoVxiK49AdJ7GUjiJQbKtvvfEL%2BNrR2ygNivbR2TNbSOwni3E67kmnOSDY1nRkzbWaN90tVN4o0u0hbvYlJcl9DnKdMSatzk03TXcOqin5%2FFy%2FIyU4VVHQJz0eJMuF83gw98ZDZYy2q8jqGg%2BntwFbmoSd6ORTyZLdtd%2F7I2VXP55Dq7zV29TKRs%2FvbTnu2C44kfUjr%2FOR1%2Bk%2Fr7PFcIBgu%2FpxszyCHzN591ke4omWlSYZ2TUJQd95xqdehY3NrjsdNtnpI13wwchCkuDDgGUll9fPAFjZhtw0EjHsOuxUXtr1Kpw2FmgfHydyLYjeghNjT5zUc4xahd%2FeSCG361%2BUTquvf5sbXv8H%3C%2Fdiagram%3E%3Cdiagram%20id%3D%22nTcplhR32HdN3I8OFsts%22%20name%3D%22Drawable%20Flow%22%3E7V1bc5s4FP41nmkf7OF%2Beazjpk2bzmaazG7ztCODbKvFyAU5jvPrVwJhDMI1SYyleN3JNHAAGb7v3HR0cHrmxfzxUwIWs284hFHP0MLHnjnqGYah%2Bzr9xSTrXEIFXDJNUMhlpeAWPUEu1Lh0iUKYVk4kGEcELarCAMcxDEhFBpIEr6qnTXBU%2FdQFmEJBcBuASJT%2Bg0Iyy6WerZXyzxBNZ8Un6xo%2FMgfFyVyQzkCIV1si82PPvEgwJvnW%2FPECRgy9ApfrH7%2BeroaO9hTGiy%2B%2FJy6Jrz%2F188Eun3PJ5hESGJMXD73%2B7ST3lu3Bp6t1%2BvDl6%2Bzrw5pfoj2AaMnxuoOPhD8vWRcgpis0j0BM94YTHJNbfkSn%2ByBC05huB%2FTeYEIFDzAhiOL%2FgR8geEGlwQxF4TVY4yV7gpSA4FexN5zhBD3RYUHEx6SHE8JVyXAqZ9yyK6lYo9IEpvScmwIWvSb6Bh4rJ16DlHBBgKMILFI03jzGHCRTFA8xIXjOT%2BLQ0MeBjzVd2kOEvtEOalcQzyFJ1vQ6PorPQecWZRaWsirVU3e4bLalmp7DrYJbxHQzcsk63eDEP0MJdEEJesaQ2RqCzNg%2BMJNdL6CgFYSpCmMrwb%2FgBY4wpX8U41xNUBTVRIWmRHBCdupJugABiqfX2Tkjq5R850AwEabXTqLMFmcoDGHMOMYEEJATythbYBSTDCl7SH8onhfawO7Z9MYv6L5e7tMfdnpCLnBMnwWgjFtItWUFmca0U4Td5iUqAmfecNoRb3RFvNFAfI3jCGXc5RwXDlR%2FEcFzSlUES0bvGOGjvi6wboqsmw0MR2AMoxucIoIwGz%2FJz60xL4tc22hp1R1xa%2B4wajr6DIfvmEG%2FP9t2Z%2FQ7LZ16Z7ZtCfzfLhJERKbPsb272G5rsmO7fY7tHdm%2FpXZsd86xvTNyZcd29xzbZdq29NjuCfzf4Gh9juxHjOyWZkmO7P45sndk%2FZ7akV0Xi3bn0H4odmWHdn1XMe4c24%2FCv%2FTYrovGDMMpLII3hWSGpzgG0cdSSoFexiEMOczlOdc4M1Zmqz8hIWsencGSYBafybyI3fARkR%2Fscgp%2Fvne%2FdWRUhORsZ13sxPR5ty5iu%2Ffbx8rLsr3iuvz52EO9ID5TYPAyCeCfEOSlL5qOTOGfNEH3m1UhgREg6KF6e4cnWqzQjRKwyszFcCKm5OOEbk1zdT9VST1nnYEF21wkOIApxXy4miECb6nDYeJVAhZVzR3TzHKa6f9fS5KHvUzeVR5o1pdvTFPwGJbR5DEK4eE1yZLpMort%2B4r72OMy%2BtpA04yK1xgY5h7Hke3dwARR2Nik5TjepK0zMaU6E%2FvNqYBWZd%2FeQ37XPPtvg2fnrfPsyibafhtEu%2BqkgVpLoqtpoC47DfRaEm25UokWi3nflzGhMY4K%2F87TF0MbwQmK8xlzi6zqMsHzd1fz6Xvx0Ds2QVwm8N8A4yRsOmHBp%2BZNx1hB7r2gmFW125OvdZWXuZ5fycv6RtPaW1NipneXmIk1OpbiU8llAubi5F0JIG2ntobpiQWvxhmx3xWMhljwUh9Gx1IORrG0pD6MrqEcjMYbhNHTlIOxqUGpnvHE4QfWAkz3ggikKQqa0HphCiFitYWF3YBFIWudF%2FBPuGFVz5IKy61S4Tg1iPPMhl9VoiwM5Dt7BsozH2GgjK7NY7%2BCQbHF6P%2FJoGceiEFhoK4ZFLuDaO4puyKomqSm0spXKAW%2FoIu%2B3m5e0%2BjM2YvdSHR6QgWfQcwWF5WMmWw%2BW5lRmFbLGUV3OIqdP3f5fE5xLHVTRTTFqfclzvyzylD2dcNXEEtxqnuXrU9rXEHD16G5vXbdM8wQQG%2FCconqQjc94gQeHE%2B6VeUq%2BK4hGfvihva9xfUawCdeAINGwMeebdlddl41KbzV9NLUcUHXBXzPBdpnFWhNbjf7C7ROs34cp0Bb3OaxCrRoPj254qxje3ULVqA8a4olCB6zsuT0NMJVX0i85Mcrqf0KJ%2BE62y5iWrZU19lYXziA62TpTZMLDJhhPddvojglIKZzeUWdp13k1iq5TnFCv5Xun4zvVDDXl9oX8LIGkIGhlPO02rZ02Tu040jO0zszfSymJYdJ%2F8z00ZiWOpcsynRnpo%2FAtNS2ruI2txKkTzCGCQq2ysvaFXv7csISoYNmTDb0QqspY%2FKMsek4HWZMNPFpqE0PTN%2Bxbd01LN10fckZlCXWc0pmGicl2zQ1zB6CaMm%2B4Yx%2BLJ9IvHIeoRSbys08LLFoU9JXlG9O0Kxq8xB94G3blC7bqJ7XC8LfPgxBOsvI0A8D%2FBvrIzFrvW2uaw5c39Q107I8w7Vr75i27SqpD9sXjLHjthJLLPts%2FCr1m2DO7Cz%2FPzPW3GvSzeFyMoHUtWp4%2FBMGJH2d%2BXZljHat%2Fae%2Fed1LnvmJ5ZgN4jVQ1cTU8X3lMBV7LXZgqiakXr1sqACkYsMFj9iZTz%2BdHoG%2BGLBlFw4tqUWGU1h0KaK%2B4nXD4jYPvujCbfRg6y4Kr1eb9XCkwMTHFisKp5RVWZZyWVXxXTB%2FtqTd2LOawAgQoCbgrK2qpuTupngjD3Nxet%2FkvdRDVSkQxdn42wBxV4ulEqC2a2ZQFtS%2BYato71K%2F0OAk0lI%2BT93%2FhQY7vvnqSGlpw6sLp9kg7nrewDPLf1bN6qSnNVIbC07C5Np%2BWUzeOyzN5Ha%2Bk3FC%2Fa2stdhU2NqKgc%2FW9lJrc9qu%2BJtSu3gccX5%2Bgi2RtqF2cHOMs7m90tzafn1mXmiUZm47X944sbUE069aXNEBfASTo7vln7fLV4fLvxJofvwP%3C%2Fdiagram%3E%3C%2Fmxfile%3E|VK]] + +[[./vkprocessor.drawio]] + +-------------------- + +===== Data ===== + +**Borrowed:** + instance + device + qeueue + +**Owns:** + [[CanvasState]] + [[CompuState]] + +-------------------- + +===== CanvasState ===== +<[[CanvasState]]> + +* Is used for storage of texture and image buffers in addition to vertex buffers +* Also contains logic for writing the stored buffers to the command_buffer + +===== CompuState ===== + +**Holds:** + * A very generic 2d compute buffer for computation + * The kernels which will compute them + +2D list storage. So all kernels and buffers are indexed by integer handles + +compute_commands is a fairly benign function which takes the 3 types of + + + + + + + + + + + + + + + + + + + + + diff --git a/notes/VKProcessor/diagram.dot b/notes/VKProcessor/diagram.dot new file mode 100644 index 00000000..f49dd782 --- /dev/null +++ b/notes/VKProcessor/diagram.dot @@ -0,0 +1 @@ +Bob->Alice \ No newline at end of file diff --git a/notes/VKProcessor/diagram001.dot b/notes/VKProcessor/diagram001.dot new file mode 100644 index 00000000..46db45db --- /dev/null +++ b/notes/VKProcessor/diagram001.dot @@ -0,0 +1,5 @@ +strict graph { + a -- b + a -- b + b -- a [color=blue] +} \ No newline at end of file diff --git a/notes/VKProcessor/diagram001.png b/notes/VKProcessor/diagram001.png new file mode 100644 index 00000000..1e4c5d6b Binary files /dev/null and b/notes/VKProcessor/diagram001.png differ diff --git a/notes/VKProcessor/vkprocessor.drawio b/notes/VKProcessor/vkprocessor.drawio new file mode 100644 index 00000000..31bf96a4 --- /dev/null +++ b/notes/VKProcessor/vkprocessor.drawio @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/notes/notebook.zim b/notes/notebook.zim new file mode 100644 index 00000000..a2c77db2 --- /dev/null +++ b/notes/notebook.zim @@ -0,0 +1,12 @@ +[Notebook] +version=0.4 +name=zim-notes +interwiki= +home=Home +icon= +document_root= +shared=True +endofline=unix +disable_trash=False +profile= + diff --git a/notes/vkprocessor.drawio b/notes/vkprocessor.drawio index 453ad9c1..31bf96a4 100644 --- a/notes/vkprocessor.drawio +++ b/notes/vkprocessor.drawio @@ -1 +1 @@ -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 \ No newline at end of file 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 \ No newline at end of file diff --git a/resources/shaders/simple_text.vert b/resources/shaders/simple_text.vert index 24c8c470..0e60d68a 100644 --- a/resources/shaders/simple_text.vert +++ b/resources/shaders/simple_text.vert @@ -10,7 +10,7 @@ layout(location = 2) in vec2 ti_position; layout(location = 3) in vec2 screen_position; layout(location = 4) in vec2 atlas_position; layout(location = 5) in vec2 atlas_size; -layout(location = 6 in float scale; +layout(location = 6) in float scale; // These are made up in the shader themselves layout(location = 0) out vec2 tex_coords; diff --git a/src/canvas/canvas.rs b/src/canvas/canvas.rs index 0860b6aa..85eab17c 100644 --- a/src/canvas/canvas.rs +++ b/src/canvas/canvas.rs @@ -21,6 +21,11 @@ use vulkano::pipeline::viewport::Viewport; use vulkano::descriptor::descriptor::DescriptorDescTy::TexelBuffer; use crate::canvas::canvas_frame::CanvasFrame; use std::hash::Hash; +use crate::canvas::shader::generic_shader::GenericShader; +use crate::canvas::shader::common::CompiledGraphicsPipeline; +use shade_runner::CompiledShader; +use crate::canvas::{CanvasTextureHandle, CanvasImageHandle}; +use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef; // Canvas is the accumulator of Sprites for drawing @@ -61,15 +66,6 @@ pub trait Vertex { } -impl Vertex for ColoredVertex2D { - fn position(&self) -> (f32, f32) { - (0.0, 0.0) - } - - fn color(&self) -> Option<(f32, f32, f32, f32)> { - Some((0., 0., 0., 0.)) - } -} pub trait Drawable { fn get_vertices(&self) -> Vec<(f32, f32)>; @@ -87,20 +83,7 @@ pub enum ShaderType { } -#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] -pub struct CanvasTextureHandle { - pub handle: u32 -} - -#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] -pub struct CanvasImageHandle { - pub handle: u32 -} -#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] -pub struct CanvasShaderHandle { - pub handle: u32 -} #[derive(Clone)] pub struct CanvasTexture { @@ -112,7 +95,7 @@ pub struct CanvasTexture { impl CanvasTexture { fn get_descriptor_set(&self, - shader: Arc, + shader: Arc, sampler: Arc) -> Box { let o: Box = Box::new( PersistentDescriptorSet::start( @@ -132,7 +115,7 @@ pub struct CanvasImage { } impl CanvasImage { - fn get_descriptor_set(&mut self, shader: Arc) + fn get_descriptor_set(&mut self, shader: Arc) -> Box { let o: Box = Box::new( PersistentDescriptorSet::start( @@ -152,17 +135,17 @@ pub struct CanvasState { // hold the image, texture, and shader buffers the same was as we do CompuState image_buffers: Vec>, texture_buffers: Vec>, - shader_buffers: HashMap>, + shader_buffers: HashMap>, // Hold onto the vertices we get from the Compu and Canvas Frames // When the run comes around, push the vertices to the GPU - colored_drawables: Vec, + colored_drawables: Vec, colored_vertex_buffer: Vec>, - textured_drawables: HashMap, Vec>>, + textured_drawables: HashMap, Vec>>, textured_vertex_buffer: HashMap, Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>, - image_drawables: HashMap, Vec>>, + image_drawables: HashMap, Vec>>, image_vertex_buffer: HashMap, Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>, // Looks like we gotta hold onto the queue for managing textures @@ -186,7 +169,7 @@ impl CanvasState { images.iter().map(|image| { Arc::new( - Framebuffer::start(self.shader_buffers.get("color-passthrough").unwrap().render_pass.clone()) + Framebuffer::start(self.shader_buffers.get("color-passthrough").unwrap().get_renderpass().clone()) .add(image.clone()).unwrap() .build().unwrap() ) as Arc @@ -210,18 +193,25 @@ impl CanvasState { image_buffers: vec![], texture_buffers: vec![], shader_buffers: HashMap::from_iter(vec![ - (solid_color_kernel.clone(), Arc::new(CanvasShader::new_colored(solid_color_kernel.clone(), - capabilities.clone(), - queue.clone(), - physical.clone(), - device.clone())) - ), - (texture_kernel.clone(), Arc::new(CanvasShader::new_textured(texture_kernel.clone(), - capabilities.clone(), - queue.clone(), - physical.clone(), - device.clone())) - ), +// (solid_color_kernel.clone(), Arc::new(GenericShader::new(solid_color_kernel.clone(), +// device.clone(), +// +// capabilities.clone(), +// queue.clone(), +// physical.clone(), +// ))), +// (solid_color_kernel.clone(), Arc::new(CanvasShader::new_colored(solid_color_kernel.clone(), +// capabilities.clone(), +// queue.clone(), +// physical.clone(), +// device.clone())) +// ), +// (texture_kernel.clone(), Arc::new(CanvasShader::new_textured(texture_kernel.clone(), +// capabilities.clone(), +// queue.clone(), +// physical.clone(), +// device.clone())) +// ), ]), colored_drawables: vec![], @@ -389,7 +379,7 @@ impl CanvasState { } } - fn get_solid_color_descriptor_set(&self, kernel: Arc) -> Box { + fn get_solid_color_descriptor_set(&self, kernel: Arc) -> Box { let o: Box = Box::new( PersistentDescriptorSet::start( diff --git a/src/canvas/canvas_buffer.rs b/src/canvas/canvas_buffer.rs index cd256326..133ab4c1 100644 --- a/src/canvas/canvas_buffer.rs +++ b/src/canvas/canvas_buffer.rs @@ -1,4 +1,3 @@ -use crate::canvas::canvas_state::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle}; use vulkano::image::{ImmutableImage, AttachmentImage}; use std::sync::Arc; use vulkano::format::{Format, R8Unorm}; @@ -8,6 +7,7 @@ use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; use vulkano::buffer::{CpuAccessibleBuffer, BufferAccess}; use vulkano::pipeline::GraphicsPipelineAbstract; use rusttype::Font; +use crate::canvas::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle}; /// Canvas buffer which represents an allocated Texture with a key and dimensions diff --git a/src/canvas/canvas_frame.rs b/src/canvas/canvas_frame.rs index 9767ea9a..6aeb4d84 100644 --- a/src/canvas/canvas_frame.rs +++ b/src/canvas/canvas_frame.rs @@ -1,15 +1,17 @@ use crate::util::vertex_3d::{Vertex3D}; use std::sync::Arc; use std::collections::HashMap; -use crate::canvas::canvas_state::{Drawable, CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, DrawableTest}; +use crate::canvas::canvas_state::{Drawable}; use crate::canvas::shader::text_shader::GlyphInstance; use std::hash::Hash; +use crate::canvas::*; +use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef; /// pub struct CanvasFrame { - pub colored_drawables: Vec, - pub textured_drawables: HashMap, Vec>>, - pub image_drawables: HashMap, Vec>>, + pub colored_drawables: Vec, + pub textured_drawables: HashMap, Vec>>, + pub image_drawables: HashMap, Vec>>, pub text_drawables: HashMap, Vec> } diff --git a/src/canvas/canvas_state.rs b/src/canvas/canvas_state.rs index 6da40733..8da318e8 100644 --- a/src/canvas/canvas_state.rs +++ b/src/canvas/canvas_state.rs @@ -23,7 +23,7 @@ use std::hash::Hash; use crate::canvas::canvas_buffer::{CanvasImage, CanvasTexture, CanvasFont}; use crate::util::vertex_3d::{Vertex3D, TextVertex3D}; use vulkano::pipeline::depth_stencil::{StencilFaceFlags, DynamicStencilValue}; -use crate::canvas::shader::common::{CompiledGraphicsPipeline, CompiledGraphicsPipelineHandle}; +use crate::canvas::shader::common::{CompiledGraphicsPipeline}; use crate::canvas::shader::generic_shader::GenericShader; use vulkano::memory::pool::PotentialDedicatedAllocation::Generic; use std::borrow::Borrow; @@ -32,6 +32,8 @@ use std::fs::File; use std::io::Read; use rusttype::{Font, PositionedGlyph, Scale, Rect, point, GlyphId}; use vulkano::pipeline::vertex::VertexDefinition; +use crate::canvas::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, CompiledGraphicsPipelineHandle}; +use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef; // I don't think this is going to work without getting into Box'ing @@ -57,34 +59,20 @@ pub trait Drawable { fn get_image_handle(&self) -> Option>; // fn get_text_handle(&self) -> Option>; - fn collect(&self) -> Vec { + fn collect(&self) -> Vec { let color = self.get_color(); - self.get_vertices().iter().zip(self.get_ti_coords().iter()).map(|(a, b)| - Vertex3D { - v_position: [a.0, a.1, a.2], - color: [color.0, color.1, color.2, color.3], - ti_position: [b.0, b.1], - }).collect() +// self.get_vertices().iter().zip(self.get_ti_coords().iter()).map(|(a, b)| +// Vertex3D { +// v_position: [a.0, a.1, a.2], +// color: [color.0, color.1, color.2, color.3], +// ti_position: [b.0, b.1], +// }).collect() + // TODO + vec![RuntimeVertexDef::from_primitive(0)] } } -/// Typed wrapper for a u32 texture handle (index id) -#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] -pub struct CanvasTextureHandle { - pub handle: u32 -} - -/// Typed wrapper for a u32 image handle (index id) -#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] -pub struct CanvasImageHandle { - pub handle: u32 -} -/// Typed wrapper for a u32 font handle (index id) -#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] -pub struct CanvasFontHandle { - pub handle: u32 -} /// Canvas state is used for storage of texture and image buffers in addition to vertex buffers /// Canvas state also contains logic for writing the stored buffers to the command_buffer @@ -100,6 +88,7 @@ pub struct CanvasState { texture_buffers: Vec>, font_buffers: Vec>, + // Compiled Graphics pipelines have a handle which self describe their position in this vector shader_buffers: Vec>>, // Hold onto the vertices we get from the Compu and Canvas Frames @@ -455,7 +444,7 @@ impl CanvasState { let g = hprof::enter("Textured Vertex Buffer"); for (k, v) in textured_drawables.drain() { let vertex_buffer = v.clone().iter() - .fold(Vec::new(), |mut a: Vec, b| { + .fold(Vec::new(), |mut a: Vec, b| { a.extend(b); a }); @@ -476,7 +465,7 @@ impl CanvasState { let g = hprof::enter("Image Vertex Buffer"); for (k, v) in image_drawables.drain() { let vertex_buffer = v.clone().iter() - .fold(Vec::new(), |mut a: Vec, b| { + .fold(Vec::new(), |mut a: Vec<&RuntimeVertexDef>, b| { a.extend(b); a }); diff --git a/src/canvas/mod.rs b/src/canvas/mod.rs index 81bf0cfd..8d661b44 100644 --- a/src/canvas/mod.rs +++ b/src/canvas/mod.rs @@ -8,3 +8,35 @@ pub mod canvas; use crate::canvas::canvas_frame::CanvasFrame; + +/// Typed wrapper for a u32 font handle (index id) +#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] +pub struct CanvasFontHandle { + pub handle: u32 +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] +pub struct CanvasTextureHandle { + pub handle: u32 +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] +pub struct CanvasImageHandle { + pub handle: u32 +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] +pub struct CanvasShaderHandle { + pub handle: u32 +} + +/// Typed wrapper for a u32 handle +#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] +pub struct CompiledGraphicsPipelineHandle { + pub handle: u32 +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] +pub struct CompuBufferHandle { + pub handle: u32, +} diff --git a/src/canvas/shader/common.rs b/src/canvas/shader/common.rs index 8085e05c..a3131473 100644 --- a/src/canvas/shader/common.rs +++ b/src/canvas/shader/common.rs @@ -8,6 +8,7 @@ use vulkano::pipeline::shader::{ShaderModule, GraphicsShaderType, GeometryShader use vulkano::device::Device; use shade_runner::Entry; use shaderc::ShaderKind; +use crate::canvas::CompiledGraphicsPipelineHandle; /* @@ -96,11 +97,7 @@ pub(super) trait CompiledGraphicsPipelineResources { } } -/// Typed wrapper for a u32 handle -#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] -pub struct CompiledGraphicsPipelineHandle { - pub handle: u32 -} + pub trait CompiledGraphicsPipeline { fn new(filename: String, @@ -110,6 +107,7 @@ pub trait CompiledGraphicsPipeline { fn get_name(&self) -> String; fn get_handle(&self) -> Arc; fn get_pipeline(&self) -> Arc; + fn get_renderpass(&self) -> Arc; fn recompile(self, render_pass: Arc) -> Self where Self: Sized; } diff --git a/src/canvas/shader/dynamic_vertex.rs b/src/canvas/shader/dynamic_vertex.rs index 38fc5232..07b360be 100644 --- a/src/canvas/shader/dynamic_vertex.rs +++ b/src/canvas/shader/dynamic_vertex.rs @@ -6,6 +6,8 @@ use cgmath::num_traits::real::Real; use std::vec::IntoIter as VecIntoIter; /// Runtime Vertex def is just a generic holder of "dynamic vertex definitions" +// This baby needs to be able to be copied.... +#[derive(Default, Debug, Clone)] pub struct RuntimeVertexDef { buffers: Vec<(u32, usize, InputRate)>, // (attribute id, stride, Vertex or Instance data) vertex_buffer_ids: Vec<(usize, usize)>,// @@ -25,6 +27,12 @@ impl RuntimeVertexDef { let mut attributes = Vec::new(); let mut num_vertices = u32::max_value(); + // https://github.com/KhronosGroup/glTF-Sample-Models/blob/master/2.0/Box/glTF/Box.gltf + // https://github.com/tomaka/vulkano-examples/blob/gltf/gltf/gltf_system.rs + + + + // for (attribute_id, attribute) in primitive.attributes().enumerate() { // let (name, accessor) = match attribute.clone() { @@ -56,7 +64,10 @@ impl RuntimeVertexDef { // }; // // let view = accessor.view(); -// buffers.push((attribute_id as u32, view.stride().unwrap_or(accessor.size()), InputRate::Vertex)); +// buffers.push((attribute_id as u32, +// view.stride().unwrap_or(accessor.size()), +// InputRate::Vertex +// )); // attributes.push((name, attribute_id as u32, infos)); // vertex_buffer_ids.push((view.buffer().index(), view.offset() + accessor.offset())); // } diff --git a/src/canvas/shader/generic_shader.rs b/src/canvas/shader/generic_shader.rs index 24327050..959f8534 100644 --- a/src/canvas/shader/generic_shader.rs +++ b/src/canvas/shader/generic_shader.rs @@ -1,7 +1,7 @@ use vulkano::pipeline::GraphicsPipelineAbstract; use std::sync::Arc; -use crate::canvas::shader::common::{CompiledGraphicsPipelineHandle, ShaderType, CompiledGraphicsPipeline}; +use crate::canvas::shader::common::{ShaderType, CompiledGraphicsPipeline}; use std::collections::{HashSet, HashMap}; use vulkano::device::Device; use vulkano::framebuffer::{RenderPassAbstract, Subpass}; @@ -19,6 +19,7 @@ use crate::canvas::shader::common::CompiledGraphicsPipelineResources; use vulkano::memory::pool::PotentialDedicatedAllocation::Generic; use vulkano::SafeDeref; use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef; +use crate::canvas::CompiledGraphicsPipelineHandle; /// CanvasShader holds the pipeline and render pass for the input shader source #[derive(Clone)] @@ -29,6 +30,7 @@ pub struct GenericShader { name: String, device: Arc, + renderpass: Arc, } @@ -113,6 +115,7 @@ impl CompiledGraphicsPipeline for GenericShader { device: device, handle: handle.clone(), name: filename.clone(), + renderpass: render_pass.clone(), } } @@ -128,6 +131,10 @@ impl CompiledGraphicsPipeline for GenericShader { self.graphics_pipeline.clone().unwrap() } + fn get_renderpass(&self) -> Arc { + self.renderpass.clone() + } + fn recompile(self, render_pass: Arc) -> GenericShader { GenericShader::new(self.name, self.device, diff --git a/src/canvas/shader/text_shader.rs b/src/canvas/shader/text_shader.rs index b918c876..b58dbf99 100644 --- a/src/canvas/shader/text_shader.rs +++ b/src/canvas/shader/text_shader.rs @@ -1,6 +1,6 @@ use vulkano::pipeline::GraphicsPipelineAbstract; use std::sync::Arc; -use crate::canvas::shader::common::{CompiledGraphicsPipelineHandle, ShaderType, CompiledGraphicsPipeline, CompiledGraphicsPipelineResources}; +use crate::canvas::shader::common::{ShaderType, CompiledGraphicsPipeline, CompiledGraphicsPipelineResources}; use std::collections::{HashSet, HashMap}; use vulkano::device::Device; use vulkano::framebuffer::{RenderPassAbstract, Subpass}; @@ -16,6 +16,7 @@ use crate::util::vertex_3d::Vertex3D; use crate::canvas::shader::generic_shader::GenericShader; use shade_runner as sr; use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef; +use crate::canvas::CompiledGraphicsPipelineHandle; #[derive(Default, Debug, Clone, Copy)] pub struct GlyphInstance { @@ -35,6 +36,7 @@ pub struct TextShader { name: String, device: Arc, + renderpass: Arc, } impl TextShader {} @@ -141,6 +143,7 @@ impl CompiledGraphicsPipeline for TextShader { device: device, handle: handle.clone(), name: filename.clone(), + renderpass: render_pass.clone(), } } @@ -155,12 +158,14 @@ impl CompiledGraphicsPipeline for TextShader { fn get_pipeline(&self) -> Arc { self.graphics_pipeline.clone().unwrap() } - + fn get_renderpass(&self) -> Arc { + self.renderpass.clone() + } fn recompile(self, render_pass: Arc) -> TextShader { TextShader::new(self.name, self.device, self.handle, - render_pass.clone()) + self.renderpass.clone()) } } diff --git a/src/compute/compu_buffer.rs b/src/compute/compu_buffer.rs index 9e46c268..8f5e5e04 100644 --- a/src/compute/compu_buffer.rs +++ b/src/compute/compu_buffer.rs @@ -7,11 +7,7 @@ use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, PersistentDes use image::ImageBuffer; use image::Rgba; use shade_runner::Layout; - -#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] -pub struct CompuBufferHandle { - pub handle: u32, -} +use crate::canvas::CompuBufferHandle; #[derive(Clone)] diff --git a/src/compute/compu_frame.rs b/src/compute/compu_frame.rs index 07beaba6..13ed01b3 100644 --- a/src/compute/compu_frame.rs +++ b/src/compute/compu_frame.rs @@ -1,8 +1,9 @@ -use crate::canvas::canvas_state::{CanvasImageHandle, Drawable}; +use crate::canvas::canvas_state::{Drawable}; use std::sync::Arc; use crate::compute::compu_sprite::CompuSprite; use crate::compute::compu_kernel::{CompuKernel, CompuKernelHandle}; -use crate::compute::compu_buffer::{CompuBuffers, CompuBufferHandle}; +use crate::compute::compu_buffer::{CompuBuffers}; +use crate::canvas::{CompuBufferHandle, CanvasImageHandle}; pub struct CompuFrame { // Vec<(Buffer, Kernel)> diff --git a/src/compute/compu_kernel.rs b/src/compute/compu_kernel.rs index 9e2cc852..f57e4ac5 100644 --- a/src/compute/compu_kernel.rs +++ b/src/compute/compu_kernel.rs @@ -8,7 +8,7 @@ use vulkano::descriptor::pipeline_layout::PipelineLayout; use shade_runner::{CompileError, Layout, Input, Output, CompiledShaders, Entry, CompiledShader}; use shaderc::CompileOptions; use vulkano::pipeline::shader::{ShaderModule, GraphicsEntryPoint, SpecializationConstants, SpecializationMapEntry}; -use crate::compute::compu_buffer::{CompuBuffers, CompuBufferHandle}; +use crate::compute::compu_buffer::{CompuBuffers}; #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] pub struct CompuKernelHandle { diff --git a/src/compute/compu_sprite.rs b/src/compute/compu_sprite.rs index a57e04ca..050ff34a 100644 --- a/src/compute/compu_sprite.rs +++ b/src/compute/compu_sprite.rs @@ -1,5 +1,6 @@ -use crate::canvas::canvas_state::{CanvasImageHandle, Drawable, CanvasTextureHandle}; +use crate::canvas::canvas_state::{Drawable}; use std::sync::Arc; +use crate::canvas::{CanvasImageHandle, CanvasTextureHandle}; pub struct CompuSprite { pub vertices: [(f32, f32, f32); 6], diff --git a/src/compute/compu_state.rs b/src/compute/compu_state.rs index eed27649..0d3d74fe 100644 --- a/src/compute/compu_state.rs +++ b/src/compute/compu_state.rs @@ -1,7 +1,7 @@ use std::ffi::CStr; use vulkano::buffer::{CpuAccessibleBuffer, BufferUsage}; use std::sync::Arc; -use crate::canvas::canvas_state::{Drawable, CanvasState, CanvasImageHandle, CanvasTextureHandle}; +use crate::canvas::canvas_state::{Drawable, CanvasState}; use vulkano::framebuffer::RenderPassAbstract; use vulkano::pipeline::{GraphicsPipelineAbstract, ComputePipeline}; use vulkano::device::Device; @@ -19,8 +19,9 @@ use shade_runner::{CompiledShaders, Entry, CompileError}; use vulkano::pipeline::shader::ShaderModule; use shaderc::CompileOptions; use crate::compute::compu_kernel::{CompuKernel, CompuKernelHandle}; -use crate::compute::compu_buffer::{CompuBuffers, CompuBufferHandle}; +use crate::compute::compu_buffer::{CompuBuffers}; use crate::compute::compu_frame::CompuFrame; +use crate::canvas::CompuBufferHandle; /// State holding the compute buffers for computation and the kernels which will compute them diff --git a/src/main.rs b/src/main.rs index 73e3b1cf..b6686a7c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -178,11 +178,11 @@ pub fn main() { break; } -// let mut compu_frame = CompuFrame::new(); + let mut compu_frame = CompuFrame::new(); // compu_frame.add(compute_buffer.clone(), compute_kernel.clone()); // compu_frame.add_with_image_swap(compute_buffer.clone(), compute_kernel.clone(), &compu_sprite1); // -// let mut canvas = CanvasFrame::new(); + let mut canvas = CanvasFrame::new(); // canvas.draw(&funky_sprite); // canvas.draw(&test_polygon); diff --git a/src/sprite.rs b/src/sprite.rs index 99deeaeb..7c0653a6 100644 --- a/src/sprite.rs +++ b/src/sprite.rs @@ -1,8 +1,9 @@ -use crate::canvas::canvas_state::{Drawable, CanvasTextureHandle, CanvasImageHandle, DrawableTest, CanvasFontHandle}; +use crate::canvas::canvas_state::{Drawable, DrawableTest}; use std::sync::Arc; use crate::canvas::shader::text_shader::GlyphInstance; use crate::canvas::canvas_buffer::CanvasFont; use crate::util::vertex_3d::Vertex3D; +use crate::canvas::*; #[derive(Debug, Clone)] pub struct Sprite { diff --git a/src/vkprocessor.rs b/src/vkprocessor.rs index 8c914dff..c546bef4 100644 --- a/src/vkprocessor.rs +++ b/src/vkprocessor.rs @@ -11,17 +11,17 @@ use winit::Window; use crate::compute::compu_state::CompuState; use vulkano::image::ImageUsage; use crate::compute::compu_frame::CompuFrame; -use crate::canvas::canvas_state::{CanvasState, CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle}; +use crate::canvas::canvas_state::{CanvasState}; use crate::canvas::canvas_frame::CanvasFrame; use crate::compute::compu_kernel::{CompuKernel, CompuKernelHandle}; -use crate::compute::compu_buffer::{CompuBuffers, CompuBufferHandle}; +use crate::compute::compu_buffer::{CompuBuffers}; use std::time::Duration; use vulkano::pipeline::depth_stencil::{DynamicStencilValue, StencilFaceFlags}; -use crate::canvas::shader::common::CompiledGraphicsPipelineHandle; use crate::canvas::shader::generic_shader::GenericShader; use crate::canvas::shader::text_shader::{TextShader, GlyphInstance}; use vulkano::pipeline::vertex::{OneVertexOneInstanceDefinition, SingleBufferDefinition}; use crate::util::vertex_3d::Vertex3D; +use crate::canvas::{CanvasTextureHandle, CompiledGraphicsPipelineHandle, CanvasFontHandle, CanvasImageHandle, CompuBufferHandle}; /// VKProcessor holds the vulkan instance information, the swapchain, /// and the compute and canvas states @@ -90,7 +90,8 @@ impl<'a> VkProcessor<'a> { /// VKProcessor controls the window. So it will let the main loop know when it is done pub fn is_open(&mut self) -> bool { - self.surfcae + // self.surface + true } /// Using the surface, we calculate the surface capabilities and create the swapchain and swapchain images