// Sets up the command buffer that renders the scene to the offscreen frame buffer
void buildOffscreenCommandBuffer()
{
if (offscreenPass.commandBuffer == NullHandle)
{
offscreenPass.commandBuffer = createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, false);
}
if (offscreenPass.semaphore == 0)
{
VkSemaphoreCreateInfo semaphoreCreateInfo = Initializers.semaphoreCreateInfo();
Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, out offscreenPass.semaphore));
}
VkCommandBufferBeginInfo cmdBufInfo = Initializers.commandBufferBeginInfo();
FixedArray2 <VkClearValue> clearValues = new FixedArray2 <VkClearValue>();
clearValues.First.color = new VkClearColorValue(0.0f, 0.0f, 0.0f, 0.0f);
clearValues.Second.depthStencil = new VkClearDepthStencilValue {
depth = 1.0f, stencil = 0
};
VkRenderPassBeginInfo renderPassBeginInfo = Initializers.renderPassBeginInfo();
renderPassBeginInfo.renderPass = offscreenPass.renderPass;
renderPassBeginInfo.framebuffer = offscreenPass.frameBuffer;
renderPassBeginInfo.renderArea.extent.width = offscreenPass.width;
renderPassBeginInfo.renderArea.extent.height = offscreenPass.height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = &clearValues.First;
Util.CheckResult(vkBeginCommandBuffer(offscreenPass.commandBuffer, &cmdBufInfo));
VkViewport viewport = Initializers.viewport((float)offscreenPass.width, (float)offscreenPass.height, 0.0f, 1.0f);
vkCmdSetViewport(offscreenPass.commandBuffer, 0, 1, &viewport);
VkRect2D scissor = Initializers.rect2D(offscreenPass.width, offscreenPass.height, 0, 0);
vkCmdSetScissor(offscreenPass.commandBuffer, 0, 1, &scissor);
vkCmdBeginRenderPass(offscreenPass.commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindDescriptorSets(offscreenPass.commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts_scene, 0, 1, ref descriptorSets_scene, 0, null);
vkCmdBindPipeline(offscreenPass.commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines_colorPass);
ulong offsets = 0;
vkCmdBindVertexBuffers(offscreenPass.commandBuffer, VERTEX_BUFFER_BIND_ID, 1, ref models_example.vertices.buffer, &offsets);
vkCmdBindIndexBuffer(offscreenPass.commandBuffer, models_example.indices.buffer, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(offscreenPass.commandBuffer, models_example.indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(offscreenPass.commandBuffer);
Util.CheckResult(vkEndCommandBuffer(offscreenPass.commandBuffer));
}
private void CreateSyncPrimitives()
{
var semaphoreInfo = new VkSemaphoreCreateInfo
{
sType = VkStructureType.SemaphoreCreateInfo
};
vkCreateSemaphore(device, &semaphoreInfo, null, out imageAvailableSemaphore).CheckResult();
vkCreateSemaphore(device, &semaphoreInfo, null, out renderFinishedSemaphore).CheckResult();
}
public static VkResult vkCreateSemaphore(VkDevice device, out VkSemaphore semaphore)
{
VkSemaphoreCreateInfo createInfo = new VkSemaphoreCreateInfo
{
sType = VkStructureType.SemaphoreCreateInfo,
pNext = null,
flags = VkSemaphoreCreateFlags.None
};
return(vkCreateSemaphore(device, &createInfo, null, out semaphore));
}
void createSemaphores()
{
VkSemaphoreCreateInfo semaphoreInfo = new VkSemaphoreCreateInfo();
semaphoreInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
if (Vulkan.vkCreateSemaphore(device, semaphoreInfo, null, out imageAvailableSemaphore) != VkResult.VK_SUCCESS ||
Vulkan.vkCreateSemaphore(device, semaphoreInfo, null, out renderFinishedSemaphore) != VkResult.VK_SUCCESS)
{
throw Program.Throw("failed to create semaphores!");
}
}
public Semaphore(Device dev)
{
Device = dev;
unsafe
{
var info = new VkSemaphoreCreateInfo()
{
SType = VkStructureType.SemaphoreCreateInfo,
Flags = 0
};
Handle = dev.Handle.CreateSemaphore(&info, Instance.AllocationCallbacks);
}
}
private void CreateSemaphores()
{
VkSemaphoreCreateInfo semaphoreCI = VkSemaphoreCreateInfo.New();
vkCreateSemaphore(_device, ref semaphoreCI, null, out _imageAvailableSemaphore);
const int MaxRenderPasses = 10;
_renderPassSemaphores.Resize(MaxRenderPasses);
for (int i = 0; i < MaxRenderPasses; i++)
{
vkCreateSemaphore(_device, ref semaphoreCI, null, out _renderPassSemaphores[i]);
}
}
internal VkSemaphore CreateSemaphore()
{
VkSemaphoreCreateInfo vkSemaphoreCreate = new VkSemaphoreCreateInfo()
{
sType = VkStructureType.SemaphoreCreateInfo,
pNext = null,
flags = 0
};
vkCreateSemaphore(Device, &vkSemaphoreCreate, null, out var Semaphore);
return(Semaphore);
}
void CreateSemaphore()
{
VkSemaphoreCreateInfo info = new VkSemaphoreCreateInfo();
info.sType = VkStructureType.SemaphoreCreateInfo;
var result = Device.Commands.createSemaphore(Device.Native, ref info, Device.Instance.AllocationCallbacks, out semaphore);
if (result != VkResult.Success)
{
throw new SemaphoreException(string.Format("Error creating semaphore: {0}", result));
}
}
private VkSemaphore CreateSemaphore(VkDevice device)
{
VkSemaphoreCreateInfo createInfo = new VkSemaphoreCreateInfo
{
sType = VkStructureType.SemaphoreCreateInfo,
pNext = null
};
VkSemaphore semaphore;
VkResult result = vkCreateSemaphore(device, &createInfo, null, out semaphore);
result.CheckResult();
return(semaphore);
}
// Command: 136
/// <summary>vkCreateSemaphore - Create a new queue semaphore object
/// </summary>
/// <param name="pCreateInfo"> pCreateInfo is a pointer to an instance of the
/// VkSemaphoreCreateInfo structure which contains information about
/// how the semaphore is to be created.</param>
/// <param name="pAllocator"> pAllocator controls host memory allocation as described in the
/// Memory Allocation chapter.</param>
public VkSemaphore CreateSemaphore(VkSemaphoreCreateInfo *pCreateInfo = null, VkAllocationCallbacks *pAllocator = null)
{
VkSemaphore semaphore;
if (pCreateInfo == null)
{
var info = new VkSemaphoreCreateInfo {
sType = VkStructureType.SemaphoreCreateInfo
};
pCreateInfo = &info;
}
vkAPI.vkCreateSemaphore(this, pCreateInfo, pAllocator, &semaphore);
return(semaphore);
}
private void CreateSemaphores()
{
VkSemaphoreCreateInfo semaphoreInfo = new VkSemaphoreCreateInfo()
{
sType = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
};
fixed(VkSemaphore *imageAvailableSemaphorePtr = &this.imageAvailableSemaphore)
{
Helpers.CheckErrors(VulkanNative.vkCreateSemaphore(this.device, &semaphoreInfo, null, imageAvailableSemaphorePtr));
}
fixed(VkSemaphore *renderFinishedSemaphorePtr = &this.renderFinishedSemaphore)
{
Helpers.CheckErrors(VulkanNative.vkCreateSemaphore(this.device, &semaphoreInfo, null, renderFinishedSemaphorePtr));
}
}
private void CreateSemaphores()
{
var semaphoreInfo = new VkSemaphoreCreateInfo()
{
sType = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
};
VkSemaphore vkSemaphore;
var result = VulkanNative.vkCreateSemaphore(vkDevice, &semaphoreInfo, null, &vkSemaphore);
vkImageAvailableSemaphore = vkSemaphore;
Helpers.CheckErrors(result);
result = VulkanNative.vkCreateSemaphore(vkDevice, &semaphoreInfo, null, &vkSemaphore);
vkRenderFinishedSemaphore = vkSemaphore;
Helpers.CheckErrors(result);
}
public static VkResult vkCreateTypedSemaphore(VkDevice device, VkSemaphoreType type, ulong initialValue, out VkSemaphore semaphore)
{
VkSemaphoreTypeCreateInfo typeCreateiInfo = new VkSemaphoreTypeCreateInfo
{
sType = VkStructureType.SemaphoreTypeCreateInfo,
pNext = null,
semaphoreType = type,
initialValue = initialValue
};
VkSemaphoreCreateInfo createInfo = new VkSemaphoreCreateInfo
{
sType = VkStructureType.SemaphoreCreateInfo,
pNext = &typeCreateiInfo,
flags = VkSemaphoreCreateFlags.None
};
return(vkCreateSemaphore(device, &createInfo, null, out semaphore));
}
private ulong CreateQueueSubmitSemaphore()
{
ulong queueSubmitSemaphore;
var queueSubmitSemaphoreCreateInfo = new VkSemaphoreCreateInfo {
sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
pNext = null,
flags = 0,
};
var result = vkCreateSemaphore(Device, &queueSubmitSemaphoreCreateInfo, pAllocator: null, &queueSubmitSemaphore);
if (result != VK_SUCCESS)
{
ThrowExternalException(nameof(vkCreateSemaphore), (int)result);
}
return(queueSubmitSemaphore);
}
public unsafe Semaphore(Device device)
{
_device = device;
var createInfo = new VkSemaphoreCreateInfo
{
sType = VkStructureType.SemaphoreCreateInfo
};
VkSemaphore semaphore;
if (VulkanNative.vkCreateSemaphore(
_device.Handle,
&createInfo,
null,
&semaphore
) != VkResult.Success)
{
throw new Exception("failed to create semaphore");
}
_handle = semaphore;
}
public DummySemaphore(DummyDevice device, VkSemaphoreCreateInfo createInfo)
{
this.m_device = device;
this.m_createInfo = createInfo;
}
public void InitVulkan()
{
VkResult err;
err = CreateInstance(false);
if (err != VkResult.Success)
{
throw new InvalidOperationException("Could not create Vulkan instance. Error: " + err);
}
if (Settings.Validation)
{
}
// Physical Device
uint gpuCount = 0;
Util.CheckResult(vkEnumeratePhysicalDevices(Instance, &gpuCount, null));
Debug.Assert(gpuCount > 0);
// Enumerate devices
IntPtr *physicalDevices = stackalloc IntPtr[(int)gpuCount];
err = vkEnumeratePhysicalDevices(Instance, &gpuCount, (VkPhysicalDevice *)physicalDevices);
if (err != VkResult.Success)
{
throw new InvalidOperationException("Could not enumerate physical devices.");
}
// GPU selection
// Select physical Device to be used for the Vulkan example
// Defaults to the first Device unless specified by command line
uint selectedDevice = 0;
// TODO: Implement arg parsing, etc.
physicalDevice = ((VkPhysicalDevice *)physicalDevices)[selectedDevice];
// Store properties (including limits) and features of the phyiscal Device
// So examples can check against them and see if a feature is actually supported
VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
DeviceProperties = deviceProperties;
VkPhysicalDeviceFeatures deviceFeatures;
vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);
DeviceFeatures = deviceFeatures;
// Gather physical Device memory properties
VkPhysicalDeviceMemoryProperties deviceMemoryProperties;
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);
DeviceMemoryProperties = deviceMemoryProperties;
// Derived examples can override this to set actual features (based on above readings) to enable for logical device creation
getEnabledFeatures();
// Vulkan Device creation
// This is handled by a separate class that gets a logical Device representation
// and encapsulates functions related to a Device
vulkanDevice = new vksVulkanDevice(physicalDevice);
VkResult res = vulkanDevice.CreateLogicalDevice(enabledFeatures, EnabledExtensions);
if (res != VkResult.Success)
{
throw new InvalidOperationException("Could not create Vulkan Device.");
}
device = vulkanDevice.LogicalDevice;
// Get a graphics queue from the Device
VkQueue queue;
vkGetDeviceQueue(device, vulkanDevice.QFIndices.Graphics, 0, &queue);
this.queue = queue;
// Find a suitable depth format
VkFormat depthFormat;
uint validDepthFormat = Tools.getSupportedDepthFormat(physicalDevice, &depthFormat);
Debug.Assert(validDepthFormat == True);
DepthFormat = depthFormat;
Swapchain.Connect(Instance, physicalDevice, device);
// Create synchronization objects
VkSemaphoreCreateInfo semaphoreCreateInfo = Initializers.semaphoreCreateInfo();
// Create a semaphore used to synchronize image presentation
// Ensures that the image is displayed before we start submitting new commands to the queu
Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, &GetSemaphoresPtr()->PresentComplete));
// Create a semaphore used to synchronize command submission
// Ensures that the image is not presented until all commands have been sumbitted and executed
Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, &GetSemaphoresPtr()->RenderComplete));
// Create a semaphore used to synchronize command submission
// Ensures that the image is not presented until all commands for the text overlay have been sumbitted and executed
// Will be inserted after the render complete semaphore if the text overlay is enabled
Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, &GetSemaphoresPtr()->TextOverlayComplete));
// Set up submit info structure
// Semaphores will stay the same during application lifetime
// Command buffer submission info is set by each example
submitInfo = Initializers.SubmitInfo();
submitInfo.pWaitDstStageMask = (VkPipelineStageFlags *)submitPipelineStages.Data;
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &GetSemaphoresPtr()->PresentComplete;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &GetSemaphoresPtr()->RenderComplete;
}
public static extern VkResult CreateSemaphore(
VkDevice device,
ref VkSemaphoreCreateInfo pCreateInfo,
IntPtr pAllocator,
out VkSemaphore pSemaphore
);
public override VkResult CreateSemaphore(VkSemaphoreCreateInfo semaphoreCreateInfo, out VkSemaphore semaphore)
{
semaphore = new DummySemaphore(this, semaphoreCreateInfo);
return(VkResult.VK_SUCCESS);
}
public void Build(int deviceIndex, bool timeline, ulong value)
{
if (!locked)
{
unsafe
{
IntPtr semaphorePtr_l = IntPtr.Zero;
this.timeline = timeline;
if (timeline)
{
var semaphoreTypeInfo = new VkSemaphoreTypeCreateInfo()
{
sType = VkStructureType.StructureTypeSemaphoreTypeCreateInfo,
semaphoreType = VkSemaphoreType.SemaphoreTypeTimeline,
initialValue = value
};
var semaphoreTypeInfo_ptr = semaphoreTypeInfo.Pointer();
var semaphoreInfo = new VkSemaphoreCreateInfo()
{
sType = VkStructureType.StructureTypeSemaphoreCreateInfo,
pNext = semaphoreTypeInfo_ptr
};
if (vkCreateSemaphore(GraphicsDevice.GetDeviceInfo(deviceIndex).Device, semaphoreInfo.Pointer(), null, &semaphorePtr_l) != VkResult.Success)
{
throw new Exception("Failed to create semaphore.");
}
}
else
{
var semaphoreInfo = new VkSemaphoreCreateInfo()
{
sType = VkStructureType.StructureTypeSemaphoreCreateInfo,
};
if (vkCreateSemaphore(GraphicsDevice.GetDeviceInfo(deviceIndex).Device, semaphoreInfo.Pointer(), null, &semaphorePtr_l) != VkResult.Success)
{
throw new Exception("Failed to create semaphore.");
}
}
hndl = semaphorePtr_l;
devID = deviceIndex;
if (GraphicsDevice.EnableValidation && Name != null)
{
var objName = new VkDebugUtilsObjectNameInfoEXT()
{
sType = VkStructureType.StructureTypeDebugUtilsObjectNameInfoExt,
pObjectName = Name,
objectType = VkObjectType.ObjectTypeSemaphore,
objectHandle = (ulong)hndl
};
GraphicsDevice.SetDebugUtilsObjectNameEXT(GraphicsDevice.GetDeviceInfo(deviceIndex).Device, objName.Pointer());
}
}
locked = true;
}
else
{
throw new Exception("GpuSemaphore is locked.");
}
}
public override VkResult CreateSemaphore(VkSemaphoreCreateInfo semaphoreCreateInfo, out VkSemaphore semaphore)
{
return(SoftwareSemaphore.Create(this, semaphoreCreateInfo, out semaphore));
}
public static VkResult Create(SoftwareDevice device, VkSemaphoreCreateInfo semaphoreCreateInfo, out VkSemaphore semaphore)
{
semaphore = new SoftwareSemaphore(device, semaphoreCreateInfo);
return(VkResult.VK_SUCCESS);
}
public SoftwareSemaphore(SoftwareDevice device, VkSemaphoreCreateInfo semaphoreCreateInfo)
{
this.m_Event = new AutoResetEvent(false);
this.m_device = device;
this.m_semaphoreCreateInfo = semaphoreCreateInfo;
}
// Sets up the command buffer that renders the scene to the offscreen frame buffer
void buildOffscreenCommandBuffer()
{
if (offscreenPass.commandBuffer.handle == 0)
{
offscreenPass.commandBuffer = createCommandBuffer(
VkCommandBufferLevel.Primary //VK_COMMAND_BUFFER_LEVEL_PRIMARY
, false);
}
if (offscreenPass.semaphore.handle == 0)
{
var semaphoreCreateInfo = VkSemaphoreCreateInfo.Alloc();
VkSemaphore semaphore;
vkCreateSemaphore(device, semaphoreCreateInfo, null, &semaphore);
offscreenPass.semaphore = semaphore;
}
var cmdBufInfo = VkCommandBufferBeginInfo.Alloc();
var clearValues = new VkClearValue[2];
clearValues[0].color = defaultClearColor;
clearValues[1].depthStencil = new VkClearDepthStencilValue {
depth = 1.0f, stencil = 0
};
var renderPassBeginInfo = VkRenderPassBeginInfo.Alloc();
renderPassBeginInfo->renderPass = offscreenPass.renderPass;
renderPassBeginInfo->framebuffer = offscreenPass.framebuffer;
renderPassBeginInfo->renderArea.extent.width = offscreenPass.width;
renderPassBeginInfo->renderArea.extent.height = offscreenPass.height;
renderPassBeginInfo->clearValues = clearValues;
vkBeginCommandBuffer(offscreenPass.commandBuffer, cmdBufInfo);
VkViewport viewport = new VkViewport(offscreenPass.width, offscreenPass.height, 0.0f, 1.0f);
vkCmdSetViewport(offscreenPass.commandBuffer, 0, 1, &viewport);
VkRect2D scissor = new VkRect2D(0, 0, offscreenPass.width, offscreenPass.height);
vkCmdSetScissor(offscreenPass.commandBuffer, 0, 1, &scissor);
vkCmdBeginRenderPass(offscreenPass.commandBuffer, renderPassBeginInfo, VkSubpassContents.Inline);// VK_SUBPASS_CONTENTS_INLINE);
{
VkDescriptorSet set = setScene;
vkCmdBindDescriptorSets(offscreenPass.commandBuffer, VkPipelineBindPoint.Graphics,// VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineLayoutScene, 0, 1, &set, 0, null);
}
vkCmdBindPipeline(offscreenPass.commandBuffer, VkPipelineBindPoint.Graphics, // VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineColorPass);
{
VkBuffer buffer = model.vertices.buffer;
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(offscreenPass.commandBuffer, VERTEX_BUFFER_BIND_ID, 1, &buffer, &offset);
}
vkCmdBindIndexBuffer(offscreenPass.commandBuffer, model.indices.buffer, 0, VkIndexType.Uint32);// VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(offscreenPass.commandBuffer, model.indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(offscreenPass.commandBuffer);
vkEndCommandBuffer(offscreenPass.commandBuffer);
}
static void Main(string[] args)
{
Console.WriteLine(AppContext.GetData("NATIVE_DLL_SEARCH_DIRECTORIES").ToString());
Console.WriteLine($"Hello Vulkan!");
Init();
if (!GLFW.Vulkan.IsSupported)
{
Console.Error.WriteLine("GLFW says that vulkan is not supported.");
return;
}
WindowHint(Hint.ClientApi, ClientApi.None);
NativeWindow window = new GLFW.NativeWindow(width, height, "Fabricor");
Glfw.SetKeyCallback(window, (a, b, c, d, e) => {
GLFWInput.KeyCallback(a, b, c, d, e);
});
FInstance finst = new FInstance();
VkSurfaceKHR surface = CreateSurface(finst.instance, window);
VkDevice device = CreateDevice(finst.instance, out var physicalDevice, surface, out var queueFamilyIndex);
VkSwapchainKHR swapchain = CreateSwapchain(VkSwapchainKHR.Null, finst.instance, device, physicalDevice, surface, queueFamilyIndex);
VkRenderPass renderPass = CreateRenderPass(device);
uint swapchainImageCount = 0;
Assert(vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, null));////////////IMAGES
VkImage[] swapchainImages = new VkImage[swapchainImageCount];
fixed(VkImage *ptr = &swapchainImages[0])
Assert(vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, ptr));
CommandPoolManager.Init(device, queueFamilyIndex);
int poolId = CommandPoolManager.CreateCommandPool(VkCommandPoolCreateFlags.ResetCommandBuffer);
VkSemaphoreCreateInfo pCreateInfo = VkSemaphoreCreateInfo.New();
VkSemaphore acquireSemaphore = new VkSemaphore();
vkCreateSemaphore(device, &pCreateInfo, null, &acquireSemaphore);
VkSemaphore releaseSemaphore = new VkSemaphore();
vkCreateSemaphore(device, &pCreateInfo, null, &releaseSemaphore);
VkQueue graphicsQueue = VkQueue.Null;
vkGetDeviceQueue(device, queueFamilyIndex, 0, &graphicsQueue);
string[] textures = new string[] {
"res/Linus.png",
"res/Alex.png",
"res/Victor.png",
"res/Alex2.png",
//"res/Cyan.png",
"res/Alex3.png",
//"res/Red.png",
};
FTexture texture = new FTexture(device, physicalDevice, poolId, graphicsQueue, textures, VkFormat.R8g8b8a8Unorm,
512, 512, (uint)(Math.Log(512) / Math.Log(2)) + 1);
VkPipelineCache pipelineCache = VkPipelineCache.Null;//This is critcal for performance.
FGraphicsPipeline voxelPipeline =
new FGraphicsPipeline(device, physicalDevice, pipelineCache, renderPass, "shaders/voxel", swapchainImageCount, texture);
voxelPipeline.CreateDepthBuffer(physicalDevice, (uint)width, (uint)height);
VkImageView[] swapchainImageViews = new VkImageView[swapchainImageCount];
for (int i = 0; i < swapchainImageCount; i++)
{
swapchainImageViews[i] = FTexture.CreateColourImageView(device, swapchainImages[i], surfaceFormat.format);
}
VkFramebuffer[] frambuffers = new VkFramebuffer[swapchainImageCount];
for (int i = 0; i < swapchainImageCount; i++)
{
frambuffers[i] = CreateFramebuffer(device, renderPass, swapchainImageViews[i], voxelPipeline.depthImageView);
}
MeshWrapper <VoxelVertex> mesh = VoxelMeshFactory.GenerateMesh(device, physicalDevice);
Action updateMesh = delegate {
VoxelMeshFactory.UpdateMesh(device, physicalDevice, mesh);
};
GLFWInput.Subscribe(Keys.U, updateMesh, InputState.Press);
Action changeTexture = delegate
{
Span <VoxelVertex> span = mesh.Mesh.vertices.Map();
for (int j = 0; j < span.Length; j++)
{
span[j].textureId++;
}
span = mesh.Mesh.vertices.UnMap();
};
GLFWInput.Subscribe(Keys.F, changeTexture, InputState.Press);
FCommandBuffer[] cmdBuffers = new FCommandBuffer[swapchainImageCount];
VkFence[] fences = new VkFence[swapchainImageCount];
for (int i = 0; i < swapchainImageCount; i++)
{
cmdBuffers[i] = new FCommandBuffer(device, poolId);
VkFenceCreateInfo createInfo = VkFenceCreateInfo.New();
createInfo.flags = VkFenceCreateFlags.Signaled;
VkFence fence = VkFence.Null;
Assert(vkCreateFence(device, &createInfo, null, &fence));
fences[i] = fence;
}
FCamera camera = new FCamera();
camera.AspectWidth = width;
camera.AspectHeight = height;
camera.position.Z = -1f;
//camera.rotation=Quaternion.CreateFromYawPitchRoll(MathF.PI,0,0);
double lastTime = Glfw.Time;
int nbFrames = 0;
while (!WindowShouldClose(window))
{
PollEvents();
GLFWInput.Update();
// Measure speed
double currentTime = Glfw.Time;
nbFrames++;
if (currentTime - lastTime >= 1.0)
{ // If last prinf() was more than 1 sec ago
// printf and reset timer
Console.WriteLine($"ms/frame: {1000.0 / nbFrames}");
nbFrames = 0;
lastTime += 1.0;
}
if (GLFWInput.TimeKeyPressed(Keys.D) > 0)
{
camera.position += Vector3.Transform(Vector3.UnitX * 0.00015f, camera.rotation);
}
if (GLFWInput.TimeKeyPressed(Keys.A) > 0)
{
camera.position -= Vector3.Transform(Vector3.UnitX * 0.00015f, camera.rotation);
}
if (GLFWInput.TimeKeyPressed(Keys.W) > 0)
{
camera.position += Vector3.Transform(Vector3.UnitZ * 0.00015f, camera.rotation);
}
if (GLFWInput.TimeKeyPressed(Keys.S) > 0)
{
camera.position -= Vector3.Transform(Vector3.UnitZ * 0.00015f, camera.rotation);
}
if (GLFWInput.TimeKeyPressed(Keys.Space) > 0)
{
camera.position += Vector3.Transform(Vector3.UnitY * 0.00015f, camera.rotation);
}
if (GLFWInput.TimeKeyPressed(Keys.LeftShift) > 0)
{
camera.position -= Vector3.Transform(Vector3.UnitY * 0.00015f, camera.rotation);
}
if (GLFWInput.TimeKeyPressed(Keys.Right) > 0)
{
camera.rotation *= Quaternion.CreateFromAxisAngle(Vector3.UnitY, 0.00015f);
}
if (GLFWInput.TimeKeyPressed(Keys.Left) > 0)
{
camera.rotation *= Quaternion.CreateFromAxisAngle(Vector3.UnitY, -0.00015f);
}
uint imageIndex = 0;
Assert(vkAcquireNextImageKHR(device, swapchain, ulong.MaxValue, acquireSemaphore, VkFence.Null, &imageIndex));
VkCommandBufferBeginInfo beginInfo = VkCommandBufferBeginInfo.New();
beginInfo.flags = VkCommandBufferUsageFlags.OneTimeSubmit;
voxelPipeline.swapchainFramebuffer = frambuffers[imageIndex];
voxelPipeline.swapchainImage = swapchainImages[imageIndex];
voxelPipeline.swapchainImageIndex = imageIndex;
voxelPipeline.mesh = mesh;
voxelPipeline.camera = camera;
fixed(VkFence *ptr = &(fences[imageIndex]))
{
vkWaitForFences(device, 1, ptr, VkBool32.False, ulong.MaxValue);
vkResetFences(device, 1, ptr);
}
cmdBuffers[imageIndex].RecordCommandBuffer(new Action <VkCommandBuffer>[] {
voxelPipeline.Execute,
});
VkPipelineStageFlags submitStageMask = VkPipelineStageFlags.ColorAttachmentOutput;
VkSubmitInfo submitInfo = VkSubmitInfo.New();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &acquireSemaphore;
submitInfo.pWaitDstStageMask = &submitStageMask;
submitInfo.commandBufferCount = 1;
fixed(VkCommandBuffer *ptr = &(cmdBuffers[imageIndex].buffer))
submitInfo.pCommandBuffers = ptr;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &releaseSemaphore;
Assert(vkQueueSubmit(graphicsQueue, 1, &submitInfo, fences[imageIndex]));
VkPresentInfoKHR presentInfoKHR = VkPresentInfoKHR.New();
presentInfoKHR.swapchainCount = 1;
presentInfoKHR.pSwapchains = &swapchain;
presentInfoKHR.pImageIndices = &imageIndex;
presentInfoKHR.waitSemaphoreCount = 1;
presentInfoKHR.pWaitSemaphores = &releaseSemaphore;
Assert(vkQueuePresentKHR(graphicsQueue, &presentInfoKHR));
vkDeviceWaitIdle(device);
}
finst.Destroy();
DestroyWindow(window);
Terminate();
}
public abstract VkResult CreateSemaphore(VkSemaphoreCreateInfo semaphoreCreateInfo, out VkSemaphore semaphore);
