Mercurial > games > semicongine
annotate semiconginev2/rendering.nim @ 1233:1cf698973dca
did: cleanup tests and old platform layer files
| author | sam <sam@basx.dev> |
|---|---|
| date | Fri, 19 Jul 2024 21:25:42 +0700 |
| parents | 70f6c1cfe005 |
| children | 841e12f33c47 |
| rev | line source |
|---|---|
| 1192 | 1 # in this file: |
| 2 # - const defintions for rendering | |
| 3 # - custom pragma defintions for rendering | |
| 4 # - type defintions for rendering | |
| 5 # - some utils code that is used in mutiple rendering files | |
| 6 # - inclusion of all rendering files | |
| 7 | |
| 8 | |
| 9 # const definitions | |
| 1197 | 10 const INFLIGHTFRAMES* = 2'u32 |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
11 const BUFFER_ALIGNMENT = 64'u64 # align offsets inside buffers along this alignment |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
12 const MEMORY_BLOCK_ALLOCATION_SIZE = 100_000_000'u64 # ca. 100mb per block, seems reasonable |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
13 const BUFFER_ALLOCATION_SIZE = 9_000_000'u64 # ca. 9mb per block, seems reasonable, can put 10 buffers into one memory block |
|
1205
f7530247a21f
did: improve descriptor-set handling, add simple descriptor set test
sam <sam@basx.dev>
parents:
1204
diff
changeset
|
14 const MAX_DESCRIPTORSETS = 4 |
|
1229
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
15 const SURFACE_FORMAT* = VK_FORMAT_B8G8R8A8_SRGB |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
16 const DEPTH_FORMAT* = VK_FORMAT_D32_SFLOAT |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
17 |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
18 # custom pragmas to classify shader attributes |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
19 template VertexAttribute* {.pragma.} |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
20 template InstanceAttribute* {.pragma.} |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
21 template Pass* {.pragma.} |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
22 template PassFlat* {.pragma.} |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
23 template ShaderOutput* {.pragma.} |
|
1205
f7530247a21f
did: improve descriptor-set handling, add simple descriptor set test
sam <sam@basx.dev>
parents:
1204
diff
changeset
|
24 template DescriptorSets* {.pragma.} |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
25 |
| 1193 | 26 # there is a big, bad global vulkan object |
| 27 # believe me, this makes everything much, much easier | |
| 28 | |
|
1224
a3fa15c25026
did: cleanup, add audio, change platform-dependent structure
sam <sam@basx.dev>
parents:
1218
diff
changeset
|
29 when defined(windows): |
|
a3fa15c25026
did: cleanup, add audio, change platform-dependent structure
sam <sam@basx.dev>
parents:
1218
diff
changeset
|
30 include ./rendering/platform/windows |
|
a3fa15c25026
did: cleanup, add audio, change platform-dependent structure
sam <sam@basx.dev>
parents:
1218
diff
changeset
|
31 when defined(linux): |
|
a3fa15c25026
did: cleanup, add audio, change platform-dependent structure
sam <sam@basx.dev>
parents:
1218
diff
changeset
|
32 include ./rendering/platform/linux |
| 1193 | 33 |
| 34 type | |
| 35 VulkanGlobals* = object | |
|
1195
cfba2b7e00d0
did: most of swapchain, swap still needs to be done
sam <sam@basx.dev>
parents:
1194
diff
changeset
|
36 # populated through InitVulkan proc |
| 1193 | 37 instance*: VkInstance |
| 38 device*: VkDevice | |
| 39 physicalDevice*: VkPhysicalDevice | |
| 40 surface: VkSurfaceKHR | |
| 41 window: NativeWindow | |
| 42 graphicsQueueFamily*: uint32 | |
| 43 graphicsQueue*: VkQueue | |
| 1199 | 44 debugMessenger: VkDebugUtilsMessengerEXT |
| 1197 | 45 # unclear as of yet |
| 46 anisotropy*: float32 = 0 # needs to be enable during device creation | |
|
1229
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
47 Renderpass* = ref object |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
48 vk*: VkRenderPass |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
49 samples*: VkSampleCountFlagBits |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
50 depthBuffer*: bool |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
51 Swapchain* = ref object |
|
1195
cfba2b7e00d0
did: most of swapchain, swap still needs to be done
sam <sam@basx.dev>
parents:
1194
diff
changeset
|
52 # parameters to InitSwapchain, required for swapchain recreation |
|
1229
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
53 renderPass*: RenderPass |
|
1195
cfba2b7e00d0
did: most of swapchain, swap still needs to be done
sam <sam@basx.dev>
parents:
1194
diff
changeset
|
54 vSync: bool |
|
cfba2b7e00d0
did: most of swapchain, swap still needs to be done
sam <sam@basx.dev>
parents:
1194
diff
changeset
|
55 # populated through InitSwapchain proc |
|
cfba2b7e00d0
did: most of swapchain, swap still needs to be done
sam <sam@basx.dev>
parents:
1194
diff
changeset
|
56 vk: VkSwapchainKHR |
|
1214
04e446a7eb2b
add: multipass renderer, finish tets for now
sam <sam@basx.dev>
parents:
1212
diff
changeset
|
57 width*: uint32 |
|
04e446a7eb2b
add: multipass renderer, finish tets for now
sam <sam@basx.dev>
parents:
1212
diff
changeset
|
58 height*: uint32 |
|
1195
cfba2b7e00d0
did: most of swapchain, swap still needs to be done
sam <sam@basx.dev>
parents:
1194
diff
changeset
|
59 framebuffers: seq[VkFramebuffer] |
|
cfba2b7e00d0
did: most of swapchain, swap still needs to be done
sam <sam@basx.dev>
parents:
1194
diff
changeset
|
60 framebufferViews: seq[VkImageView] |
| 1198 | 61 currentFramebufferIndex: uint32 |
| 62 commandBufferPool: VkCommandPool | |
|
1229
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
63 # depth buffer stuff, if enabled |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
64 depthImage: VkImage |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
65 depthImageView*: VkImageView |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
66 depthMemory: VkDeviceMemory |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
67 # MSAA stuff, if enabled |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
68 msaaImage: VkImage |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
69 msaaImageView*: VkImageView |
|
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
70 msaaMemory: VkDeviceMemory |
| 1198 | 71 # frame-in-flight handling |
| 72 currentFiF: range[0 .. (INFLIGHTFRAMES - 1).int] | |
| 1197 | 73 queueFinishedFence*: array[INFLIGHTFRAMES.int, VkFence] |
| 74 imageAvailableSemaphore*: array[INFLIGHTFRAMES.int, VkSemaphore] | |
| 75 renderFinishedSemaphore*: array[INFLIGHTFRAMES.int, VkSemaphore] | |
| 1198 | 76 commandBuffers: array[INFLIGHTFRAMES.int, VkCommandBuffer] |
|
1229
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
77 oldSwapchain: Swapchain |
|
1200
5c6491f28dcd
did: simplify some swapchain stuff, add many destructor calls
sam <sam@basx.dev>
parents:
1199
diff
changeset
|
78 oldSwapchainCounter: int # swaps until old swapchain will be destroyed |
| 1193 | 79 |
| 80 var vulkan*: VulkanGlobals | |
| 1226 | 81 var fullscreen: bool |
| 1193 | 82 |
| 1202 | 83 func currentFiF*(swapchain: Swapchain): int = swapchain.currentFiF |
| 84 | |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
85 type |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
86 # type aliases |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
87 SupportedGPUType = float32 | float64 | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | TVec2[int32] | TVec2[int64] | TVec3[int32] | TVec3[int64] | TVec4[int32] | TVec4[int64] | TVec2[uint32] | TVec2[uint64] | TVec3[uint32] | TVec3[uint64] | TVec4[uint32] | TVec4[uint64] | TVec2[float32] | TVec2[float64] | TVec3[float32] | TVec3[float64] | TVec4[float32] | TVec4[float64] | TMat2[float32] | TMat2[float64] | TMat23[float32] | TMat23[float64] | TMat32[float32] | TMat32[float64] | TMat3[float32] | TMat3[float64] | TMat34[float32] | TMat34[float64] | TMat43[float32] | TMat43[float64] | TMat4[float32] | TMat4[float64] |
| 1228 | 88 PixelType = TVec1[uint8] | TVec4[uint8] |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
89 |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
90 # shader related types |
|
1205
f7530247a21f
did: improve descriptor-set handling, add simple descriptor set test
sam <sam@basx.dev>
parents:
1204
diff
changeset
|
91 DescriptorSet*[T: object] = object |
| 1192 | 92 data*: T |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
93 vk: array[INFLIGHTFRAMES.int, VkDescriptorSet] |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
94 Pipeline*[TShader] = object |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
95 vk: VkPipeline |
|
1200
5c6491f28dcd
did: simplify some swapchain stuff, add many destructor calls
sam <sam@basx.dev>
parents:
1199
diff
changeset
|
96 vertexShaderModule: VkShaderModule |
|
5c6491f28dcd
did: simplify some swapchain stuff, add many destructor calls
sam <sam@basx.dev>
parents:
1199
diff
changeset
|
97 fragmentShaderModule: VkShaderModule |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
98 layout: VkPipelineLayout |
|
1205
f7530247a21f
did: improve descriptor-set handling, add simple descriptor set test
sam <sam@basx.dev>
parents:
1204
diff
changeset
|
99 descriptorSetLayouts*: array[MAX_DESCRIPTORSETS, VkDescriptorSetLayout] |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
100 |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
101 # memory/buffer related types |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
102 MemoryBlock* = object |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
103 vk: VkDeviceMemory |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
104 size: uint64 |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
105 rawPointer: pointer # if not nil, this is mapped memory |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
106 offsetNextFree: uint64 |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
107 BufferType* = enum |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
108 VertexBuffer |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
109 VertexBufferMapped |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
110 IndexBuffer |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
111 IndexBufferMapped |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
112 UniformBuffer |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
113 UniformBufferMapped |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
114 Buffer* = object |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
115 vk: VkBuffer |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
116 size: uint64 |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
117 rawPointer: pointer # if not nil, buffer is using mapped memory |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
118 offsetNextFree: uint64 |
| 1231 | 119 memoryOffset: uint64 |
| 120 memory: VkDeviceMemory | |
| 1228 | 121 Image*[T: PixelType] = object |
| 1210 | 122 width*: uint32 |
| 123 height*: uint32 | |
| 124 interpolation*: VkFilter = VK_FILTER_LINEAR | |
| 125 data*: seq[T] | |
|
1214
04e446a7eb2b
add: multipass renderer, finish tets for now
sam <sam@basx.dev>
parents:
1212
diff
changeset
|
126 vk*: VkImage |
|
04e446a7eb2b
add: multipass renderer, finish tets for now
sam <sam@basx.dev>
parents:
1212
diff
changeset
|
127 imageview*: VkImageView |
|
04e446a7eb2b
add: multipass renderer, finish tets for now
sam <sam@basx.dev>
parents:
1212
diff
changeset
|
128 sampler*: VkSampler |
|
04e446a7eb2b
add: multipass renderer, finish tets for now
sam <sam@basx.dev>
parents:
1212
diff
changeset
|
129 isRenderTarget*: bool = false |
|
1229
5dcb503ef0c0
did: refactor renderpass a bit, enable depth buffering and msaa on offscreen-rendering
sam <sam@basx.dev>
parents:
1228
diff
changeset
|
130 samples*: VkSampleCountFlagBits = VK_SAMPLE_COUNT_1_BIT |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
131 GPUArray*[T: SupportedGPUType, TBuffer: static BufferType] = object |
| 1192 | 132 data*: seq[T] |
| 1202 | 133 buffer*: Buffer |
| 134 offset*: uint64 | |
| 1210 | 135 GPUValue*[T: object, TBuffer: static BufferType] = object |
| 1192 | 136 data*: T |
| 1231 | 137 buffer*: Buffer |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
138 offset: uint64 |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
139 GPUData = GPUArray | GPUValue |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
140 |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
141 RenderData* = object |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
142 descriptorPool: VkDescriptorPool |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
143 memory: array[VK_MAX_MEMORY_TYPES.int, seq[MemoryBlock]] |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
144 buffers: array[BufferType, seq[Buffer]] |
|
1200
5c6491f28dcd
did: simplify some swapchain stuff, add many destructor calls
sam <sam@basx.dev>
parents:
1199
diff
changeset
|
145 images: seq[VkImage] |
|
5c6491f28dcd
did: simplify some swapchain stuff, add many destructor calls
sam <sam@basx.dev>
parents:
1199
diff
changeset
|
146 imageViews: seq[VkImageView] |
| 1201 | 147 samplers: seq[VkSampler] |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
148 |
| 1192 | 149 template ForDescriptorFields(shader: typed, fieldname, valuename, typename, countname, bindingNumber, body: untyped): untyped = |
|
1205
f7530247a21f
did: improve descriptor-set handling, add simple descriptor set test
sam <sam@basx.dev>
parents:
1204
diff
changeset
|
150 var `bindingNumber` {.inject.} = 0'u32 |
| 1192 | 151 for theFieldname, value in fieldPairs(shader): |
| 1228 | 152 when typeof(value) is Image: |
| 1192 | 153 block: |
| 154 const `fieldname` {.inject.} = theFieldname | |
| 155 const `typename` {.inject.} = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER | |
| 156 const `countname` {.inject.} = 1'u32 | |
| 157 let `valuename` {.inject.} = value | |
| 158 body | |
| 159 `bindingNumber`.inc | |
| 1210 | 160 elif typeof(value) is GPUValue: |
| 1192 | 161 block: |
| 162 const `fieldname` {.inject.} = theFieldname | |
| 163 const `typename` {.inject.} = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER | |
| 164 const `countname` {.inject.} = 1'u32 | |
| 165 let `valuename` {.inject.} = value | |
| 166 body | |
| 167 `bindingNumber`.inc | |
| 168 elif typeof(value) is array: | |
| 1228 | 169 when elementType(value) is Image: |
| 1192 | 170 block: |
| 171 const `fieldname` {.inject.} = theFieldname | |
| 172 const `typename` {.inject.} = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER | |
| 173 const `countname` {.inject.} = uint32(typeof(value).len) | |
| 174 let `valuename` {.inject.} = value | |
| 175 body | |
| 176 `bindingNumber`.inc | |
| 1210 | 177 elif elementType(value) is GPUValue: |
| 1192 | 178 block: |
| 179 const `fieldname` {.inject.} = theFieldname | |
| 180 const `typename` {.inject.} = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER | |
| 1210 | 181 const `countname` {.inject.} = len(value).uint32 |
| 1192 | 182 let `valuename` {.inject.} = value |
| 183 body | |
| 184 `bindingNumber`.inc | |
| 185 else: | |
| 186 {.error: "Unsupported descriptor type: " & typetraits.name(typeof(value)).} | |
| 1210 | 187 else: |
| 188 {.error: "Unsupported descriptor type: " & typetraits.name(typeof(value)).} | |
| 1192 | 189 |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
190 include ./rendering/vulkan_wrappers |
| 1199 | 191 include ./rendering/renderpasses |
| 1194 | 192 include ./rendering/swapchain |
|
1190
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
193 include ./rendering/shaders |
|
a3eb305bcac2
start of complete and total refactoring: the ULTIMATE
sam <sam@basx.dev>
parents:
diff
changeset
|
194 include ./rendering/renderer |
| 1193 | 195 |
| 1199 | 196 proc debugCallback( |
| 197 messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, | |
| 198 messageTypes: VkDebugUtilsMessageTypeFlagsEXT, | |
| 199 pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT, | |
| 200 userData: pointer | |
| 201 ): VkBool32 {.cdecl.} = | |
| 202 const LOG_LEVEL_MAPPING = { | |
| 203 VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: lvlDebug, | |
| 204 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: lvlInfo, | |
| 205 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: lvlWarn, | |
| 206 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: lvlError, | |
| 207 }.toTable | |
| 208 log LOG_LEVEL_MAPPING[messageSeverity], &"{toEnums messageTypes}: {pCallbackData.pMessage}" | |
| 209 if messageSeverity == VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: | |
| 210 stderr.writeLine "-----------------------------------" | |
| 211 stderr.write getStackTrace() | |
| 212 stderr.writeLine LOG_LEVEL_MAPPING[messageSeverity], &"{toEnums messageTypes}: {pCallbackData.pMessage}" | |
| 213 stderr.writeLine "-----------------------------------" | |
| 214 let errorMsg = getStackTrace() & &"\n{toEnums messageTypes}: {pCallbackData.pMessage}" | |
| 215 raise newException(Exception, errorMsg) | |
| 216 return false | |
| 1193 | 217 |
| 1204 | 218 proc InitVulkan*(appName: string = "semicongine app") = |
| 1193 | 219 |
| 220 # instance creation | |
| 1198 | 221 |
| 222 # enagle all kind of debug stuff | |
| 1193 | 223 when not defined(release): |
| 224 let requiredExtensions = REQUIRED_PLATFORM_EXTENSIONS & @["VK_KHR_surface", "VK_EXT_debug_utils"] | |
| 225 let layers: seq[string] = if hasValidationLayer(): @["VK_LAYER_KHRONOS_validation"] else: @[] | |
| 1198 | 226 putEnv("VK_LAYER_ENABLES", "VALIDATION_CHECK_ENABLE_VENDOR_SPECIFIC_AMD,VALIDATION_CHECK_ENABLE_VENDOR_SPECIFIC_NVIDIA,VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXTVK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT") |
| 1193 | 227 else: |
| 228 let requiredExtensions = REQUIRED_PLATFORM_EXTENSIONS & @["VK_KHR_surface"] | |
| 229 let layers: seq[string] | |
| 230 | |
| 231 var | |
| 232 layersC = allocCStringArray(layers) | |
| 233 instanceExtensionsC = allocCStringArray(requiredExtensions) | |
| 234 defer: | |
| 235 deallocCStringArray(layersC) | |
| 236 deallocCStringArray(instanceExtensionsC) | |
| 237 | |
| 238 var | |
| 239 appinfo = VkApplicationInfo( | |
| 240 sType: VK_STRUCTURE_TYPE_APPLICATION_INFO, | |
| 241 pApplicationName: appName, | |
| 242 pEngineName: "semicongine", | |
| 243 apiVersion: VK_MAKE_API_VERSION(0, 1, 3, 0), | |
| 244 ) | |
| 245 createinfo = VkInstanceCreateInfo( | |
| 246 sType: VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, | |
| 247 pApplicationInfo: addr(appinfo), | |
| 248 enabledLayerCount: layers.len.uint32, | |
| 249 ppEnabledLayerNames: layersC, | |
| 250 enabledExtensionCount: requiredExtensions.len.uint32, | |
| 251 ppEnabledExtensionNames: instanceExtensionsC | |
| 252 ) | |
| 1204 | 253 checkVkResult vkCreateInstance(addr(createinfo), nil, addr(vulkan.instance)) |
| 254 loadVulkan(vulkan.instance) | |
| 1193 | 255 |
| 256 # load extensions | |
| 257 # | |
| 258 for extension in requiredExtensions: | |
| 1204 | 259 loadExtension(vulkan.instance, $extension) |
| 260 vulkan.window = CreateWindow(appName) | |
| 261 vulkan.surface = CreateNativeSurface(vulkan.instance, vulkan.window) | |
| 1193 | 262 |
| 263 # logical device creation | |
| 264 | |
| 265 # TODO: allowing support for physical devices without hasUniformBufferStandardLayout | |
| 266 # would require us to ship different shaders, so we don't support standard layout | |
| 267 # if that will be added, check the function vulkan/shaders.nim:glslUniforms and update accordingly | |
| 268 # let hasUniformBufferStandardLayout = "VK_KHR_uniform_buffer_standard_layout" in physicalDevice.getExtensions() | |
| 269 # var deviceExtensions = @["VK_KHR_swapchain", "VK_KHR_uniform_buffer_standard_layout"] | |
| 270 var deviceExtensions = @["VK_KHR_swapchain"] | |
| 271 for extension in deviceExtensions: | |
| 1204 | 272 loadExtension(vulkan.instance, extension) |
| 1193 | 273 |
| 1199 | 274 when not defined(release): |
| 275 var debugMessengerCreateInfo = VkDebugUtilsMessengerCreateInfoEXT( | |
| 276 sType: VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, | |
| 277 messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT.items.toSeq.toBits, | |
| 278 messageType: VkDebugUtilsMessageTypeFlagBitsEXT.items.toSeq.toBits, | |
| 279 pfnUserCallback: debugCallback, | |
| 280 pUserData: nil, | |
| 281 ) | |
| 282 checkVkResult vkCreateDebugUtilsMessengerEXT( | |
| 1204 | 283 vulkan.instance, |
| 1199 | 284 addr(debugMessengerCreateInfo), |
| 285 nil, | |
| 1204 | 286 addr(vulkan.debugMessenger) |
| 1199 | 287 ) |
| 288 | |
| 1193 | 289 # get physical device and graphics queue family |
| 1204 | 290 vulkan.physicalDevice = GetBestPhysicalDevice(vulkan.instance) |
| 291 vulkan.graphicsQueueFamily = GetQueueFamily(vulkan.physicalDevice, VK_QUEUE_GRAPHICS_BIT) | |
| 1193 | 292 |
| 293 let | |
| 294 priority = cfloat(1) | |
| 295 queueInfo = VkDeviceQueueCreateInfo( | |
| 296 sType: VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, | |
| 1204 | 297 queueFamilyIndex: vulkan.graphicsQueueFamily, |
| 1193 | 298 queueCount: 1, |
| 299 pQueuePriorities: addr(priority), | |
| 300 ) | |
| 301 deviceExtensionsC = allocCStringArray(deviceExtensions) | |
| 302 defer: deallocCStringArray(deviceExtensionsC) | |
| 303 var createDeviceInfo = VkDeviceCreateInfo( | |
| 304 sType: VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, | |
| 305 queueCreateInfoCount: 1, | |
| 306 pQueueCreateInfos: addr(queueInfo), | |
| 307 enabledLayerCount: 0, | |
| 308 ppEnabledLayerNames: nil, | |
| 309 enabledExtensionCount: uint32(deviceExtensions.len), | |
| 310 ppEnabledExtensionNames: deviceExtensionsC, | |
| 311 pEnabledFeatures: nil, | |
| 312 ) | |
| 313 checkVkResult vkCreateDevice( | |
| 1204 | 314 physicalDevice = vulkan.physicalDevice, |
| 1193 | 315 pCreateInfo = addr createDeviceInfo, |
| 316 pAllocator = nil, | |
| 1204 | 317 pDevice = addr vulkan.device |
| 1193 | 318 ) |
| 1204 | 319 vulkan.graphicsQueue = svkGetDeviceQueue(vulkan.device, vulkan.graphicsQueueFamily, VK_QUEUE_GRAPHICS_BIT) |
| 1193 | 320 |
|
1200
5c6491f28dcd
did: simplify some swapchain stuff, add many destructor calls
sam <sam@basx.dev>
parents:
1199
diff
changeset
|
321 proc DestroyVulkan*() = |
|
5c6491f28dcd
did: simplify some swapchain stuff, add many destructor calls
sam <sam@basx.dev>
parents:
1199
diff
changeset
|
322 vkDestroyDevice(vulkan.device, nil) |
| 1201 | 323 vkDestroySurfaceKHR(vulkan.instance, vulkan.surface, nil) |
| 324 vkDestroyDebugUtilsMessengerEXT(vulkan.instance, vulkan.debugMessenger, nil) | |
|
1200
5c6491f28dcd
did: simplify some swapchain stuff, add many destructor calls
sam <sam@basx.dev>
parents:
1199
diff
changeset
|
325 vkDestroyInstance(vulkan.instance, nil) |
| 1226 | 326 |
| 327 proc ShowSystemCursor*() = vulkan.window.ShowSystemCursor() | |
| 328 proc HideSystemCursor*() = vulkan.window.HideSystemCursor() | |
| 329 proc Fullscreen*(): bool = fullscreen | |
| 330 proc `Fullscreen=`*(enable: bool) = | |
| 331 if enable != fullscreen: | |
| 332 fullscreen = enable | |
| 333 vulkan.window.Fullscreen(fullscreen) | |
| 334 | |
| 335 func GetAspectRatio*(swapchain: Swapchain): float32 = swapchain.width.float32 / swapchain.height.float32 | |
| 336 | |
| 337 proc MaxFramebufferSampleCount*(maxSamples = VK_SAMPLE_COUNT_8_BIT): VkSampleCountFlagBits = | |
| 338 let limits = svkGetPhysicalDeviceProperties().limits | |
| 339 let available = VkSampleCountFlags( | |
| 340 limits.framebufferColorSampleCounts.uint32 and limits.framebufferDepthSampleCounts.uint32 | |
| 341 ).toEnums | |
| 342 return min(max(available), maxSamples) | |
| 343 | |
| 344 | |
| 1228 | 345 proc `[]`*(image: Image, x, y: uint32): auto = |
| 346 assert x < image.width, &"{x} < {image.width} is not true" | |
| 347 assert y < image.height, &"{y} < {image.height} is not true" | |
| 1226 | 348 |
| 1228 | 349 image[].imagedata[y * image.width + x] |
| 1226 | 350 |
| 1228 | 351 proc `[]=`*[T](image: var Image[T], x, y: uint32, value: T) = |
| 352 assert x < image.width | |
| 353 assert y < image.height | |
| 1226 | 354 |
| 1228 | 355 image[].imagedata[y * image.width + x] = value |