games/semicongine: static_utils.nim comparison

comparison static_utils.nim @ 1176:511c9f7cd1da compiletime-tests

sync to notebook in bedroom

author	sam <sam@basx.dev>
date	Sat, 29 Jun 2024 21:04:04 +0700
parents	fafc2f14da0b
children	4ef959278451

comparison

equal deleted inserted replaced

-:a94732d98cc6
+:511c9f7cd1da
 template Pass* {.pragma.}
 template PassFlat* {.pragma.}
 template ShaderOutput* {.pragma.}
 const INFLIGHTFRAMES = 2'u32
 type
 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]
 ShaderObject*[TShader] = object
 vertexShader: VkShaderModule
 fragmentShader: VkShaderModule
 let `fieldname` {.inject.} = theFieldname
 let `valuename` {.inject.} = value
 let `isinstancename` {.inject.} = hasCustomPragma(value, InstanceAttribute)
 body
-template ForDescriptorFields*(inputData: typed, typename, countname, bindingNumber, body: untyped): untyped =
+template ForDescriptorFields*(inputData: typed, fieldname, typename, countname, bindingNumber, body: untyped): untyped =
 var `bindingNumber` {.inject.} = 1'u32
 for theFieldname, value in fieldPairs(inputData):
+let `fieldname` {.inject.} = theFieldname
 when typeof(value) is Texture:
 block:
 let `typename` {.inject.} = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
 let `countname` {.inject.} = 1'u32
 body
 return 1
 type
 IndexType = enum
 None, UInt8, UInt16, UInt32
-RenderBuffers = object
-deviceBuffers: seq[Buffer]      # for fast reads
+IndirectGPUMemory = object
-hostVisibleBuffers: seq[Buffer] # for fast writes
+vk: VkDeviceMemory
+size: uint64
+DirectGPUMemory = object
+vk: VkDeviceMemory
+size: uint64
+data: pointer
+GPUMemory = IndirectGPUMemory | DirectGPUMemory
+Buffer[TMemory: GPUMemory] = object
+vk: VkBuffer
+memory*: TMemory
+offset: uint64
+size: uint64
+GPUArray[T: SupportedGPUType, TMemory: GPUMemory] = object
+data: seq[T]
+buffer: Buffer[TMemory]
+offset: uint64
+GPUValue[T: object|array, TMemory: GPUMemory] = object
+data: T
+buffer: Buffer[TMemory]
+offset: uint64
 Renderable[TMesh, TInstance] = object
 vertexBuffers: seq[VkBuffer]
 bufferOffsets: seq[VkDeviceSize]
 instanceCount: uint32
 case indexType: IndexType
 vertexCount: uint32
 else:
 indexBuffer: VkBuffer
 indexCount: uint32
 indexBufferOffset: VkDeviceSize
 Pipeline[TShader] = object
 pipeline: VkPipeline
 layout: VkPipelineLayout
-descriptorSets: array[INFLIGHTFRAMES.int, VkDescriptorSet]
+descriptorSetLayout: VkDescriptorSetLayout
+RenderData = object
+descriptorPool: VkDescriptorPool
+indirectMemory: seq[IndirectGPUMemory]
+nextFreeIndirectMemoryOffset: seq[uint64]
+indirectBuffers: seq[Buffer[IndirectGPUMemory]]
+directMemory: seq[DirectGPUMemory]
+nextFreeDirectMemoryOffset: seq[uint64]
+directBuffers: seq[Buffer[DirectGPUMemory]]
 converter toVkIndexType(indexType: IndexType): VkIndexType =
 case indexType:
 of None: VK_INDEX_TYPE_NONE_KHR
 of UInt8: VK_INDEX_TYPE_UINT8_EXT
 shader: ShaderObject[TShader],
 topology: VkPrimitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
 polygonMode: VkPolygonMode = VK_POLYGON_MODE_FILL,
 cullMode: VkCullModeFlagBits = VK_CULL_MODE_BACK_BIT,
 frontFace: VkFrontFace = VK_FRONT_FACE_CLOCKWISE,
+descriptorPoolLimit = 1024
 ): Pipeline[TShader] =
-# assumptions/limitations:
-# - we are only using vertex and fragment shaders (2 stages)
-# - we only support one subpass
-# = we only support one Uniform-Block
 # create pipeline
 var layoutbindings: seq[VkDescriptorSetLayoutBinding]
-ForDescriptorFields(default(TShader), descriptorType, descriptorCount, descriptorBindingNumber):
+ForDescriptorFields(default(TShader), fieldName, descriptorType, descriptorCount, descriptorBindingNumber):
 layoutbindings.add VkDescriptorSetLayoutBinding(
 binding: descriptorBindingNumber,
 descriptorType: descriptorType,
 descriptorCount: descriptorCount,
 stageFlags: VkShaderStageFlags(VK_SHADER_STAGE_ALL_GRAPHICS),
 var layoutCreateInfo = VkDescriptorSetLayoutCreateInfo(
 sType: VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
 bindingCount: uint32(layoutbindings.len),
 pBindings: layoutbindings.ToCPointer
 )
-var descriptorSetLayout: VkDescriptorSetLayout
+result.descriptorSetLayout: VkDescriptorSetLayout
-checkVkResult vkCreateDescriptorSetLayout(device, addr(layoutCreateInfo), nil, addr(descriptorSetLayout))
+checkVkResult vkCreateDescriptorSetLayout(device, addr(layoutCreateInfo), nil, addr(result.descriptorSetLayout))
 let pipelineLayoutInfo = VkPipelineLayoutCreateInfo(
 sType: VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
 setLayoutCount: 1,
-pSetLayouts: addr(descriptorSetLayout),
+pSetLayouts: addr(result.descriptorSetLayout),
 # pushConstantRangeCount: uint32(pushConstants.len),
 # pPushConstantRanges: pushConstants.ToCPointer,
 )
 checkVkResult vkCreatePipelineLayout(device, addr(pipelineLayoutInfo), nil, addr(result.layout))
 addr(createInfo),
 nil,
 addr(result.pipeline)
 )
-# create descriptors, one per frame-in-flight
+proc AllocateIndirectMemory(device: VkDevice, pDevice: VkPhysicalDevice, allocationSize: uint64): IndirectGPUMemory =
-let nSamplers = 0'u32
+# chooses biggest memory type that has NOT VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
-let nUniformBuffers = 0'u32
+result.size = allocationSize
-if nSamplers + nUniformBuffers > 0:
+# find a good memory type
-var poolSizes: seq[VkDescriptorPoolSize]
+var physicalProperties: VkPhysicalDeviceMemoryProperties
-if nUniformBuffers > 0:
+vkGetPhysicalDeviceMemoryProperties(pDevice, addr physicalProperties)
-poolSizes.add VkDescriptorPoolSize(thetype: VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, descriptorCount: nSamplers * INFLIGHTFRAMES)
-if nSamplers > 0:
+var biggestHeap: uint64 = -1
-poolSizes.add VkDescriptorPoolSize(thetype: VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, descriptorCount: nUniformBuffers * INFLIGHTFRAMES)
+var memoryTypeIndex = -1
-var poolInfo = VkDescriptorPoolCreateInfo(
+# try to find non-host-visible type
-sType: VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+for i in 0 ..< physicalProperties.memoryTypeCount:
-poolSizeCount: uint32(poolSizes.len),
+if VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT not in toEnums(physicalProperties.memoryTypes[i].propertyFlags)
-pPoolSizes: poolSizes.ToCPointer,
+let size = physicalProperties.memoryHeaps[physicalProperties.memoryTypes[i].heapIndex].size
-maxSets: (nUniformBuffers + nSamplers) * INFLIGHTFRAMES * 2, # good formula? no idea...
+if size > biggestHeap:
-)
+biggest = size
-var pool: VkDescriptorPool
+memoryTypeIndex = i
-checkVkResult vkCreateDescriptorPool(device, addr(poolInfo), nil, addr(pool))
+# If we did not found a device-only memory type, let's just take the biggest overall
-var layouts = newSeqWith(result.descriptorSets.len, descriptorSetLayout)
+if memoryTypeIndex < 0:
-var allocInfo = VkDescriptorSetAllocateInfo(
+for i in 0 ..< physicalProperties.memoryTypeCount:
-sType: VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+let size = physicalProperties.memoryHeaps[physicalProperties.memoryTypes[i].heapIndex].size
-descriptorPool: pool,
+if size > biggestHeap:
-descriptorSetCount: uint32(layouts.len),
+biggest = size
-pSetLayouts: layouts.ToCPointer,
+memoryTypeIndex = i
-)
-checkVkResult vkAllocateDescriptorSets(device, addr(allocInfo), result.descriptorSets.ToCPointer)
+assert memoryTypeIndex >= 0, "Unable to find indirect memory type"
+var allocationInfo = VkMemoryAllocateInfo(
+sType: VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+allocationSize: initialAllocationSize,
+memoryTypeIndex: memoryTypeIndex,
+)
+checkVkResult vkAllocateMemory(
+device,
+addr allocationInfo,
+nil,
+addr result.vk
+)
+proc AllocateDirectMemory(device: VkDevice, allocationSize: uint64): DirectGPUMemory =
+result.size = allocationSize
+# find a good memory type
+var physicalProperties: VkPhysicalDeviceMemoryProperties
+vkGetPhysicalDeviceMemoryProperties(pDevice, addr physicalProperties)
+var biggestHeap: uint64 = -1
+var memoryTypeIndex = -1
+# try to find host-visible type
+for i in 0 ..< physicalProperties.memoryTypeCount:
+if VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT in toEnums(physicalProperties.memoryTypes[i].propertyFlags)
+let size = physicalProperties.memoryHeaps[physicalProperties.memoryTypes[i].heapIndex].size
+if size > biggestHeap:
+biggest = size
+memoryTypeIndex = i
+assert memoryTypeIndex >= 0, "Unable to find direct (aka host-visible) memory type"
+var allocationInfo = VkMemoryAllocateInfo(
+sType: VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+allocationSize: initialAllocationSize,
+memoryTypeIndex: memoryTypeIndex,
+)
+checkVkResult vkAllocateMemory(
+device,
+addr allocationInfo,
+nil,
+addr result.vk
+)
+checkVkResult result.device.vk.vkMapMemory(
+memory = result.vk,
+offset = 0'u64,
+size = result.size,
+flags = VkMemoryMapFlags(0),
+ppData = addr(result.data)
+)
+proc InitRenderData(device: VkDevice, descriptorPoolLimit = 1024): RenderData =
+# allocate descriptor pools
+var poolSizes = [
+VkDescriptorPoolSize(thetype: VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, descriptorCount: descriptorPoolLimit)
+VkDescriptorPoolSize(thetype: VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, descriptorCount: descriptorPoolLimit)
+]
+var poolInfo = VkDescriptorPoolCreateInfo(
+sType: VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+poolSizeCount: poolSizes.len.uint32,
+pPoolSizes: poolSizes.ToCPointer,
+maxSets: descriptorPoolLimit,
+)
+checkVkResult vkCreateDescriptorPool(device, addr(poolInfo), nil, addr(result.descriptorPool))
+# allocate some memory
+var initialAllocationSize: 1_000_000_000 # TODO: make this more dynamic or something
+result.indirectMemory = @[AllocateIndirectMemory(device, size=initialAllocationSize)]
+result.nextFreeIndirectMemoryOffset = @[0'u64]
+result.directMemory = @[AllocateDirectMemory(device, size=initialAllocationSize)]
+result.nextFreeDirectMemoryOffset = @[0'u64]
 proc WriteDescriptors[TShader](device: VkDevice, pipeline: Pipeline[TShader]) =
 var descriptorSetWrites: seq[VkWriteDescriptorSet]
-ForDescriptorFields(default(TShader), descriptorType, descriptorCount, descriptorBindingNumber):
+# map (buffer + offset + range) to descriptor
+# map (texture) to descriptor
+ForDescriptorFields(default(TShader), fieldName, descriptorType, descriptorCount, descriptorBindingNumber):
 for frameInFlight in 0 ..< pipeline.descriptorSets.len:
 if descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 # TODO
 let bufferInfo = VkDescriptorBufferInfo(
 buffer: VkBuffer(0),
 vkUpdateDescriptorSets(device, uint32(descriptorSetWrites.len), descriptorSetWrites.ToCPointer, 0, nil)
 proc CreateRenderable[TMesh, TInstance](
 mesh: TMesh,
 instance: TInstance,
-buffers: RenderBuffers,
 ): Renderable[TMesh, TInstance] =
 result.indexType = None
 proc Bind[T](pipeline: Pipeline[T], commandBuffer: VkCommandBuffer, currentFrameInFlight: int) =
 let a = pipeline.descriptorSets
 proc AssertCompatible(TShader, TMesh, TInstance, TGlobals: typedesc) =
 # assert seq-fields of TMesh|TInstance == seq-fields of TShader
 # assert normal fields of TMesh|Globals == normal fields of TShaderDescriptors
 for inputName, inputValue in default(TShader).fieldPairs:
 var foundField = false
+# Vertex input data
 when hasCustomPragma(inputValue, VertexAttribute):
 assert typeof(inputValue) is SupportedGPUType
 for meshName, meshValue in default(TMesh).fieldPairs:
 when meshName == inputName:
+assert meshValue is GPUArray, "Mesh attribute '" & meshName & "' must be of type 'GPUArray' but is of type " & tt.name(typeof(meshValue))
 assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
-assert elementType(meshValue) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but mesh attribute is of type '" & tt.name(elementType(meshValue)) & "'"
+assert elementType(meshValue.data) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but mesh attribute is of type '" & tt.name(elementType(meshValue.data)) & "'"
 foundField = true
 assert foundField, "Shader input '" & tt.name(TShader) & "." & inputName & ": " & tt.name(typeof(inputValue)) & "' not found in '" & tt.name(TMesh) & "'"
+# Instance input data
 elif hasCustomPragma(inputValue, InstanceAttribute):
 assert typeof(inputValue) is SupportedGPUType
 for instanceName, instanceValue in default(TInstance).fieldPairs:
 when instanceName == inputName:
+assert instanceValue is GPUArray, "Instance attribute '" & instanceName & "' must be of type 'GPUArray' but is of type " & tt.name(typeof(instanceName))
 assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
-assert elementType(instanceValue) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but instance attribute is of type '" & tt.name(elementType(instanceValue)) & "'"
+assert elementType(instanceValue.data) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but instance attribute is of type '" & tt.name(elementType(instanceValue.data)) & "'"
 foundField = true
 assert foundField, "Shader input '" & tt.name(TShader) & "." & inputName & ": " & tt.name(typeof(inputValue)) & "' not found in '" & tt.name(TInstance) & "'"
-elif typeof(inputValue) is Texture or typeof(inputValue) is object:
+# Texture
+elif typeof(inputValue) is Texture:
 for meshName, meshValue in default(TMesh).fieldPairs:
 when meshName == inputName:
 assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
 assert typeof(meshValue) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but mesh attribute is of type '" & tt.name(elementType(meshValue)) & "'"
 foundField = true
 when globalName == inputName:
 assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
 assert typeof(globalValue) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but global attribute is of type '" & tt.name(typeof(globalValue)) & "'"
 foundField = true
 assert foundField, "Shader input '" & tt.name(TShader) & "." & inputName & ": " & tt.name(typeof(inputValue)) & "' not found in '" & tt.name(TMesh) & "|" & tt.name(TGlobals) & "'"
+# Uniform block
+elif typeof(inputValue) is object:
+for meshName, meshValue in default(TMesh).fieldPairs:
+when meshName == inputName:
+assert meshValue is GPUValue, "Mesh attribute '" & meshName & "' must be of type 'GPUValue' but is of type " & tt.name(typeof(meshValue))
+assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
+assert typeof(meshValue.data) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but mesh attribute is of type '" & tt.name(elementType(meshValue.data)) & "'"
+foundField = true
+for globalName, globalValue in default(TGlobals).fieldPairs:
+when globalName == inputName:
+assert globalValue is GPUValue, "global attribute '" & globalName & "' must be of type 'GPUValue' but is of type " & tt.name(typeof(globalValue))
+assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
+assert typeof(globalValue.data) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but global attribute is of type '" & tt.name(typeof(globalValue.data)) & "'"
+foundField = true
+assert foundField, "Shader input '" & tt.name(TShader) & "." & inputName & ": " & tt.name(typeof(inputValue)) & "' not found in '" & tt.name(TMesh) & "|" & tt.name(TGlobals) & "'"
+# array
 elif typeof(inputValue) is array:
-when (elementType(inputValue) is Texture or elementType(inputValue) is object):
+# texture-array
+when elementType(inputValue) is Texture:
 for meshName, meshValue in default(TMesh).fieldPairs:
 when meshName == inputName:
 assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
 assert typeof(meshValue) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but mesh attribute is of type '" & tt.name(elementType(meshValue)) & "'"
 foundField = true
 for globalName, globalValue in default(TGlobals).fieldPairs:
 when globalName == inputName:
 assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
 assert typeof(globalValue) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but global attribute is of type '" & tt.name(typeof(globalValue)) & "'"
+foundField = true
+assert foundField, "Shader input '" & tt.name(TShader) & "." & inputName & ": " & tt.name(typeof(inputValue)) & "' not found in '" & tt.name(TMesh) & "|" & tt.name(TGlobals) & "'"
+# uniform-block array
+elif elementType(inputValue) is object:
+for meshName, meshValue in default(TMesh).fieldPairs:
+when meshName == inputName:
+assert meshValue is GPUValue, "Mesh attribute '" & meshName & "' must be of type 'GPUValue' but is of type " & tt.name(typeof(meshValue))
+assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
+assert typeof(meshValue.data) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but mesh attribute is of type '" & tt.name(elementType(meshValue.data)) & "'"
+foundField = true
+for globalName, globalValue in default(TGlobals).fieldPairs:
+when globalName == inputName:
+assert globalValue is GPUValue, "global attribute '" & globalName & "' must be of type 'GPUValue' but is of type " & tt.name(typeof(globalValue))
+assert foundField == false, "Shader input '" & tt.name(TShader) & "." & inputName & "' has been found more than once"
+assert typeof(globalValue.data) is typeof(inputValue), "Shader input " & tt.name(TShader) & "." & inputName & " is of type '" & tt.name(typeof(inputValue)) & "' but global attribute is of type '" & tt.name(typeof(globalValue.data)) & "'"
 foundField = true
 assert foundField, "Shader input '" & tt.name(TShader) & "." & inputName & ": " & tt.name(typeof(inputValue)) & "' not found in '" & tt.name(TMesh) & "|" & tt.name(TGlobals) & "'"
 proc Render[TShader, TMesh, TInstance, TGlobals](
 reflection: float32
 baseColor: Vec3f
 ShaderSettings = object
 brightness: float32
 MeshA = object
-position: seq[Vec3f]
+position: GPUArray[Vec3f, IndirectGPUMemory]
-transparency: float
+InstanceA = object
-material: array[3, MaterialA]
+rotation: GPUArray[Vec4f, IndirectGPUMemory]
+objPosition: GPUArray[Vec3f, IndirectGPUMemory]
+UniformsA = object
+materials: GPUValue[array[3, MaterialA], IndirectGPUMemory]
 materialTextures: array[3, Texture]
-InstanceA = object
+GlobalsA = object
-transform: seq[Mat4]
-position: seq[Vec3f]
-Globals = object
 fontAtlas: Texture
-settings: ShaderSettings
+settings: GPUValue[ShaderSettings, IndirectGPUMemory]
 ShaderA = object
 # vertex input
 position {.VertexAttribute.}: Vec3f
-transform {.InstanceAttribute.}: Mat4
+objPosition {.InstanceAttribute.}: Vec3f
+rotation {.InstanceAttribute.}: Vec4f
 # intermediate
 test {.Pass.}: float32
 test1 {.PassFlat.}: Vec3f
 # output
 color {.ShaderOutput.}: Vec4f
 # uniforms
-material: array[3, MaterialA]
+materials: array[3, MaterialA]
 settings: ShaderSettings
 # textures
 fontAtlas: Texture
 materialTextures: array[3, Texture]
 # code
 vulkanVersion = VK_MAKE_API_VERSION(0, 1, 3, 0),
 instanceExtensions = @[],
 layers = @["VK_LAYER_KHRONOS_validation"],
 )
 let selectedPhysicalDevice = i.GetPhysicalDevices().FilterBestGraphics()
 let dev = i.CreateDevice(
 selectedPhysicalDevice,
 enabledExtensions = @[],
 selectedPhysicalDevice.FilterForGraphicsPresentationQueues()
 )
 let frameWidth = 100'u32
 let frameHeight = 100'u32
-var myRenderable: Renderable[MeshA, InstanceA]
+var myMesh1 = MeshA(
-var myGlobals: Globals
+position: GPUArray[Vec3f, IndirectGPUMemory](data: @[NewVec3f(0, 0, ), NewVec3f(0, 0, ), NewVec3f(0, 0, )]),
+)
+var uniforms1 = UniformsA(
+materials: GPUValue[array[3, MaterialA], IndirectGPUMemory](data: [
+MaterialA(reflection: 0, baseColor: NewVec3f(1, 0, 0)),
+MaterialA(reflection: 0.1, baseColor: NewVec3f(0, 1, 0)),
+MaterialA(reflection: 0.5, baseColor: NewVec3f(0, 0, 1)),
+]),
+materialTextures: [
+Texture(isGrayscale: false, colorImage: Image[RGBAPixel](width: 1, height: 1, imagedata: @[[255'u8, 0'u8, 0'u8, 255'u8]])),
+Texture(isGrayscale: false, colorImage: Image[RGBAPixel](width: 1, height: 1, imagedata: @[[0'u8, 255'u8, 0'u8, 255'u8]])),
+Texture(isGrayscale: false, colorImage: Image[RGBAPixel](width: 1, height: 1, imagedata: @[[0'u8, 0'u8, 255'u8, 255'u8]])),
+]
+)
+var instances1 = InstanceA(
+rotation: GPUArray[Vec4f, IndirectGPUMemory](data: @[NewVec4f(1, 0, 0, 0.1), NewVec4f(0, 1, 0, 0.1)]),
+objPosition: GPUArray[Vec3f, IndirectGPUMemory](data: @[NewVec3f(0, 0, 0), NewVec3f(1, 1, 1)]),
+)
+var myGlobals: GlobalsA
 # setup for rendering (TODO: swapchain & framebuffers)
 # renderpass
 let renderpass = dev.vk.CreateRenderPass(dev.physicalDevice.GetSurfaceFormats().FilterSurfaceFormat().format)
 # shaders
 const shader = ShaderA()
 let shaderObject = dev.vk.CompileShader(shader)
 var pipeline1 = CreatePipeline(dev.vk, renderPass = renderpass, shaderObject)
+var renderdata = InitRenderData(dev.vk)
+# create descriptor sets
+var descriptorSets: array[INFLIGHTFRAMES.int, VkDescriptorSet]
+var layouts = newSeqWith(descriptorSets.len, pipeline.descriptorSetLayout)
+var allocInfo = VkDescriptorSetAllocateInfo(
+sType: VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+descriptorPool: pool,
+descriptorSetCount: uint32(layouts.len),
+pSetLayouts: layouts.ToCPointer,
+)
+checkVkResult vkAllocateDescriptorSets(device, addr(allocInfo), descriptorSets.ToCPointer)
+#[
 # TODO: probably here: allocate renderables, uniform buffers & textures
+let meshBuffers: seq[(bool, uint64)] = GetBufferSizes[MeshA](item = myMesh1)
+let instanceBuffers: seq[(bool, uint64)] = GetBufferSizes[InstanceA](item = instances1)
+let globalBuffers: seq[(bool, uint64)] = GetBufferSizes[Globals](item = myGlobals)
+var myRenderable = CreateRenderable()
+UploadTextures[MeshA]()
+UploadTextures[Globals]()
+]#
+var myRenderable: Renderable[MeshA, InstanceA]
 # descriptors
 WriteDescriptors(dev.vk, pipeline1)
 # command buffer

Mercurial > games > semicongine

comparison static_utils.nim @ 1176:511c9f7cd1da compiletime-tests