halotroop
/
Ginger3D
1
0
Fork 0
Code Pull Requests Packages Releases Activity

possibly working vulkan demo

pull/12/head
hYdos 2020-03-02 17:33:37 +10:00
parent b747ba2c48
commit 034fd9b0c7
5 changed files with 2388 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
.classpath
View File

@ -15,5 +15,18 @@
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="target/classes" path="src/main/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="target/test-classes" path="src/test/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
<attribute name="test" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="target/classes"/>
</classpath>

15
pom.xml
View File

@ -91,13 +91,28 @@
</build>
<repositories>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
</repository>
<repository>
<id>sonatype-snapshots</id>
<url>https://oss.sonatype.org/content/repositories/snapshots</url>
<releases><enabled>false</enabled></releases>
<snapshots><enabled>true</enabled></snapshots>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>org.lwjgl</groupId>
<artifactId>lwjgl-vma</artifactId>
</dependency>
<dependency>
<groupId>org.lwjgl</groupId>
<artifactId>lwjgl-shaderc</artifactId>
</dependency>
<dependency>
<groupId>org.joml</groupId>
<artifactId>joml</artifactId>

1461
src/main/java/com/github/hydos/ginger/VulkanStarter.java Normal file
View File

File diff suppressed because it is too large Load Diff

432
src/main/java/com/github/hydos/ginger/engine/vulkan/utils/VKFactory.java Normal file
View File

@ -0,0 +1,432 @@
package com.github.hydos.ginger.engine.vulkan.utils;
import java.nio.Buffer;
import org.lwjgl.system.MemoryStack;
import org.lwjgl.util.vma.VmaAllocationCreateInfo;
import org.lwjgl.util.vma.VmaAllocationInfo;
import org.lwjgl.util.vma.VmaAllocatorCreateInfo;
import org.lwjgl.util.vma.VmaVulkanFunctions;
import org.lwjgl.vulkan.*;
import static org.lwjgl.vulkan.EXTDebugReport.*;
import static org.lwjgl.vulkan.KHR8bitStorage.*;
import static org.lwjgl.vulkan.KHRGetMemoryRequirements2.*;
import static org.lwjgl.vulkan.KHRGetPhysicalDeviceProperties2.*;
import static org.lwjgl.vulkan.KHRShaderFloat16Int8.*;
import static org.lwjgl.vulkan.KHRSwapchain.*;
import static org.lwjgl.vulkan.NVRayTracing.*;
import static org.lwjgl.vulkan.VK10.*;
public class VKFactory {
static VmaVulkanFunctions VmaVulkanFunctions(MemoryStack stack) {
return VmaVulkanFunctions.callocStack(stack);
}
static VmaAllocatorCreateInfo VmaAllocatorCreateInfo(MemoryStack stack) {
return VmaAllocatorCreateInfo.callocStack(stack);
}
static VkInstanceCreateInfo VkInstanceCreateInfo(MemoryStack stack) {
return VkInstanceCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
}
static VkApplicationInfo VkApplicationInfo(MemoryStack stack) {
return VkApplicationInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_APPLICATION_INFO);
}
static VkDebugReportCallbackCreateInfoEXT VkDebugReportCallbackCreateInfoEXT(MemoryStack stack) {
return VkDebugReportCallbackCreateInfoEXT.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT);
}
static VkDeviceCreateInfo VkDeviceCreateInfo(MemoryStack stack) {
return VkDeviceCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
}
static VkDeviceQueueCreateInfo.Buffer VkDeviceQueueCreateInfo(MemoryStack stack) {
return VkDeviceQueueCreateInfo.callocStack(1, stack).sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO);
}
static VkPhysicalDevice8BitStorageFeaturesKHR VkPhysicalDevice8BitStorageFeaturesKHR(MemoryStack stack) {
return VkPhysicalDevice8BitStorageFeaturesKHR.callocStack(stack).sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR);
}
static VkPhysicalDeviceFloat16Int8FeaturesKHR VkPhysicalDeviceFloat16Int8FeaturesKHR(MemoryStack stack) {
return VkPhysicalDeviceFloat16Int8FeaturesKHR.callocStack(stack).sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR);
}
static VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2(MemoryStack stack) {
return VkPhysicalDeviceProperties2.callocStack(stack).sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR);
}
static VkPhysicalDeviceRayTracingPropertiesNV VkPhysicalDeviceRayTracingPropertiesNV(MemoryStack stack) {
return VkPhysicalDeviceRayTracingPropertiesNV.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
}
static VkSwapchainCreateInfoKHR VkSwapchainCreateInfoKHR(MemoryStack stack) {
return VkSwapchainCreateInfoKHR.callocStack(stack).sType(VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR);
}
static VkImageViewCreateInfo VkImageViewCreateInfo(MemoryStack stack) {
return VkImageViewCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
}
static VkCommandPoolCreateInfo VkCommandPoolCreateInfo(MemoryStack stack) {
return VkCommandPoolCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO);
}
static VkMemoryRequirements VkMemoryRequirements(MemoryStack stack) {
return VkMemoryRequirements.callocStack(stack);
}
static VkImageCreateInfo VkImageCreateInfo(MemoryStack stack) {
return VkImageCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
}
static VkImageMemoryBarrier.Buffer VkImageMemoryBarrier(MemoryStack stack) {
return VkImageMemoryBarrier.callocStack(1, stack).sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER);
}
static VkFenceCreateInfo VkFenceCreateInfo(MemoryStack stack) {
return VkFenceCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
}
static VkSubmitInfo VkSubmitInfo(MemoryStack stack) {
return VkSubmitInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_SUBMIT_INFO);
}
static VkCommandBufferBeginInfo VkCommandBufferBeginInfo(MemoryStack stack) {
return VkCommandBufferBeginInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO);
}
static VkCommandBufferAllocateInfo VkCommandBufferAllocateInfo(MemoryStack stack) {
return VkCommandBufferAllocateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO);
}
static VkMemoryAllocateInfo VkMemoryAllocateInfo(MemoryStack stack) {
return VkMemoryAllocateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
}
static VkBufferCreateInfo VkBufferCreateInfo(MemoryStack stack) {
return VkBufferCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
}
static VkGeometryAABBNV VkGeometryAABBNV(VkGeometryAABBNV geometry) {
return geometry.sType(VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV);
}
static VkGeometryTrianglesNV VkGeometryTrianglesNV(VkGeometryTrianglesNV geometry) {
return geometry.sType(VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV);
}
static VkGeometryNV VkGeometryNV(MemoryStack stack) {
return VkGeometryNV.callocStack(stack).sType(VK_STRUCTURE_TYPE_GEOMETRY_NV);
}
static VkMemoryBarrier.Buffer VkMemoryBarrier(MemoryStack stack) {
return VkMemoryBarrier.callocStack(1, stack).sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER);
}
static VkBindAccelerationStructureMemoryInfoNV.Buffer VkBindAccelerationStructureMemoryInfoNV(MemoryStack stack) {
return VkBindAccelerationStructureMemoryInfoNV.callocStack(1, stack)
.sType(VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV);
}
static VkAccelerationStructureInfoNV VkAccelerationStructureInfoNV(MemoryStack stack) {
return VkAccelerationStructureInfoNV.callocStack(stack).sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV);
}
static VkMemoryRequirements2KHR VkMemoryRequirements2KHR(MemoryStack stack) {
return VkMemoryRequirements2KHR.callocStack(stack).sType(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR);
}
static VkAccelerationStructureMemoryRequirementsInfoNV VkAccelerationStructureMemoryRequirementsInfoNV(
MemoryStack stack) {
return VkAccelerationStructureMemoryRequirementsInfoNV.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV);
}
static VkAccelerationStructureCreateInfoNV VkAccelerationStructureCreateInfoNV(MemoryStack stack) {
return VkAccelerationStructureCreateInfoNV.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV);
}
static VkPipelineShaderStageCreateInfo.Buffer VkPipelineShaderStageCreateInfo(MemoryStack stack, int count) {
VkPipelineShaderStageCreateInfo.Buffer ret = VkPipelineShaderStageCreateInfo.callocStack(count, stack);
ret.forEach(sci -> sci.sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO));
return ret;
}
static VkDescriptorSetLayoutBinding.Buffer VkDescriptorSetLayoutBinding(MemoryStack stack, int count) {
return VkDescriptorSetLayoutBinding.callocStack(count, stack);
}
static VkDescriptorSetLayoutBinding VkDescriptorSetLayoutBinding(MemoryStack stack) {
return VkDescriptorSetLayoutBinding.callocStack(stack);
}
static VkRayTracingPipelineCreateInfoNV.Buffer VkRayTracingPipelineCreateInfoNV(MemoryStack stack) {
return VkRayTracingPipelineCreateInfoNV.callocStack(1, stack)
.sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV);
}
static VkRayTracingShaderGroupCreateInfoNV.Buffer VkRayTracingShaderGroupCreateInfoNV(int size, MemoryStack stack) {
VkRayTracingShaderGroupCreateInfoNV.Buffer buf = VkRayTracingShaderGroupCreateInfoNV.callocStack(size, stack);
buf.forEach(info -> info.sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV)
.anyHitShader(VK_SHADER_UNUSED_NV)
.closestHitShader(VK_SHADER_UNUSED_NV)
.generalShader(VK_SHADER_UNUSED_NV)
.intersectionShader(VK_SHADER_UNUSED_NV));
return buf;
}
static VkPipelineLayoutCreateInfo VkPipelineLayoutCreateInfo(MemoryStack stack) {
return VkPipelineLayoutCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
}
static VkDescriptorSetLayoutCreateInfo VkDescriptorSetLayoutCreateInfo(MemoryStack stack) {
return VkDescriptorSetLayoutCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
}
static VkDescriptorBufferInfo.Buffer VkDescriptorBufferInfo(MemoryStack stack, int count) {
return VkDescriptorBufferInfo.callocStack(count, stack);
}
static VkDescriptorImageInfo.Buffer VkDescriptorImageInfo(MemoryStack stack, int count) {
return VkDescriptorImageInfo.callocStack(count, stack);
}
static VkDescriptorPoolSize.Buffer VkDescriptorPoolSize(MemoryStack stack, int count) {
return VkDescriptorPoolSize.callocStack(count, stack);
}
static VkWriteDescriptorSetAccelerationStructureNV VkWriteDescriptorSetAccelerationStructureNV(MemoryStack stack) {
return VkWriteDescriptorSetAccelerationStructureNV.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV);
}
static VkWriteDescriptorSet VkWriteDescriptorSet(MemoryStack stack) {
return VkWriteDescriptorSet.callocStack(stack).sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET);
}
static VkDescriptorSetAllocateInfo VkDescriptorSetAllocateInfo(MemoryStack stack) {
return VkDescriptorSetAllocateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO);
}
static VkDescriptorPoolCreateInfo VkDescriptorPoolCreateInfo(MemoryStack stack) {
return VkDescriptorPoolCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO);
}
static VkPresentInfoKHR VkPresentInfoKHR(MemoryStack stack) {
return VkPresentInfoKHR.callocStack(stack).sType(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR);
}
static VkSemaphoreCreateInfo VkSemaphoreCreateInfo(MemoryStack stack) {
return VkSemaphoreCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
}
static VkQueueFamilyProperties.Buffer VkQueueFamilyProperties(int count) {
return VkQueueFamilyProperties.callocStack(count);
}
static VkPhysicalDeviceFeatures VkPhysicalDeviceFeatures(MemoryStack stack) {
return VkPhysicalDeviceFeatures.callocStack(stack);
}
static VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2(MemoryStack stack) {
return VkPhysicalDeviceFeatures2.callocStack(stack).sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR);
}
static VkPhysicalDeviceProperties VkPhysicalDeviceProperties(MemoryStack stack) {
return VkPhysicalDeviceProperties.callocStack(stack);
}
static VkGeometryNV.Buffer VkGeometryNV(MemoryStack stack, int count) {
VkGeometryNV.Buffer buf = VkGeometryNV.callocStack(count, stack);
buf.forEach(info -> info.sType(VK_STRUCTURE_TYPE_GEOMETRY_NV));
return buf;
}
static VkPipelineShaderStageCreateInfo VkPipelineShaderStageCreateInfo(MemoryStack stack) {
return VkPipelineShaderStageCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO);
}
static VkShaderModuleCreateInfo VkShaderModuleCreateInfo(MemoryStack stack) {
return VkShaderModuleCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
}
static VkSurfaceCapabilitiesKHR VkSurfaceCapabilitiesKHR(MemoryStack stack) {
return VkSurfaceCapabilitiesKHR.callocStack(stack);
}
static VkSurfaceFormatKHR.Buffer VkSurfaceFormatKHR(MemoryStack stack, int count) {
return VkSurfaceFormatKHR.callocStack(count, stack);
}
static VmaAllocationCreateInfo VmaAllocationCreateInfo(MemoryStack stack) {
return VmaAllocationCreateInfo.callocStack(stack);
}
static VmaAllocationInfo VmaAllocationInfo(MemoryStack stack) {
return VmaAllocationInfo.callocStack(stack);
}
static VkBufferCopy.Buffer VkBufferCopy(MemoryStack stack, int count) {
return VkBufferCopy.callocStack(count, stack);
}
static VkSamplerCreateInfo VkSamplerCreateInfo(MemoryStack stack) {
return VkSamplerCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
}
static VkBufferImageCopy.Buffer VkBufferImageCopy(MemoryStack stack) {
return VkBufferImageCopy.callocStack(1, stack);
}
static VkImageSubresourceRange VkImageSubresourceRange(MemoryStack stack) {
return VkImageSubresourceRange.callocStack(stack);
}
static VkComponentMapping VkComponentMapping(MemoryStack stack) {
return VkComponentMapping.callocStack(stack);
}
static VkAttachmentReference VkAttachmentReference(MemoryStack stack) {
return VkAttachmentReference.callocStack(stack);
}
static VkAttachmentReference.Buffer VkAttachmentReference(MemoryStack stack, int count) {
return VkAttachmentReference.callocStack(count, stack);
}
static VkSubpassDescription.Buffer VkSubpassDescription(MemoryStack stack, int count) {
return VkSubpassDescription.callocStack(count, stack);
}
static VkAttachmentDescription.Buffer VkAttachmentDescription(MemoryStack stack, int count) {
return VkAttachmentDescription.callocStack(count, stack);
}
static VkRenderPassCreateInfo VkRenderPassCreateInfo(MemoryStack stack) {
return VkRenderPassCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
}
static VkOffset3D VkOffset3D(MemoryStack stack) {
return VkOffset3D.callocStack(stack);
}
static VkImageBlit.Buffer VkImageBlit(MemoryStack stack, int count) {
return VkImageBlit.callocStack(count, stack);
}
static VkSpecializationMapEntry.Buffer VkSpecializationMapEntry(MemoryStack stack, int count) {
return VkSpecializationMapEntry.callocStack(count, stack);
}
static VkSpecializationInfo VkSpecializationInfo(MemoryStack stack) {
return VkSpecializationInfo.callocStack(stack);
}
static VkQueryPoolCreateInfo VkQueryPoolCreateInfo(MemoryStack stack) {
return VkQueryPoolCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO);
}
static VkGeometryNV.Buffer VkGeometryNV(int count) {
return VkGeometryNV.calloc(count).sType(VK_STRUCTURE_TYPE_GEOMETRY_NV);
}
static VkFramebufferCreateInfo VkFramebufferCreateInfo(MemoryStack stack) {
return VkFramebufferCreateInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);
}
static VkVertexInputBindingDescription.Buffer VkVertexInputBindingDescription(MemoryStack stack, int count) {
return VkVertexInputBindingDescription.callocStack(count, stack);
}
static VkVertexInputAttributeDescription.Buffer VkVertexInputAttributeDescription(MemoryStack stack, int count) {
return VkVertexInputAttributeDescription.callocStack(count, stack);
}
static VkPipelineVertexInputStateCreateInfo VkPipelineVertexInputStateCreateInfo(MemoryStack stack) {
return VkPipelineVertexInputStateCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO);
}
static VkPipelineInputAssemblyStateCreateInfo VkPipelineInputAssemblyStateCreateInfo(MemoryStack stack) {
return VkPipelineInputAssemblyStateCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO);
}
static VkPipelineRasterizationStateCreateInfo VkPipelineRasterizationStateCreateInfo(MemoryStack stack) {
return VkPipelineRasterizationStateCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO);
}
static VkPipelineColorBlendAttachmentState.Buffer VkPipelineColorBlendAttachmentState(MemoryStack stack,
int count) {
return VkPipelineColorBlendAttachmentState.callocStack(count, stack);
}
static VkPipelineColorBlendStateCreateInfo VkPipelineColorBlendStateCreateInfo(MemoryStack stack) {
return VkPipelineColorBlendStateCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO);
}
static VkPipelineViewportStateCreateInfo VkPipelineViewportStateCreateInfo(MemoryStack stack) {
return VkPipelineViewportStateCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO);
}
static VkPipelineDynamicStateCreateInfo VkPipelineDynamicStateCreateInfo(MemoryStack stack) {
return VkPipelineDynamicStateCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO);
}
static VkPipelineDepthStencilStateCreateInfo VkPipelineDepthStencilStateCreateInfo(MemoryStack stack) {
return VkPipelineDepthStencilStateCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO);
}
static VkPipelineMultisampleStateCreateInfo VkPipelineMultisampleStateCreateInfo(MemoryStack stack) {
return VkPipelineMultisampleStateCreateInfo.callocStack(stack)
.sType(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO);
}
static VkGraphicsPipelineCreateInfo.Buffer VkGraphicsPipelineCreateInfo(MemoryStack stack, int count) {
VkGraphicsPipelineCreateInfo.Buffer ret = VkGraphicsPipelineCreateInfo.callocStack(count, stack);
ret.forEach(pci -> pci.sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO));
return ret;
}
static VkClearValue.Buffer VkClearValue(MemoryStack stack, int count) {
return VkClearValue.callocStack(count, stack);
}
static VkRenderPassBeginInfo VkRenderPassBeginInfo(MemoryStack stack) {
return VkRenderPassBeginInfo.callocStack(stack).sType(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO);
}
static VkViewport.Buffer VkViewport(MemoryStack stack, int count) {
return VkViewport.callocStack(count, stack);
}
static VkRect2D.Buffer VkRect2D(MemoryStack stack, int count) {
return VkRect2D.callocStack(count, stack);
}
static VkFormatProperties VkFormatProperties(MemoryStack stack) {
return VkFormatProperties.callocStack(stack);
}
static VkSubpassDependency.Buffer VkSubpassDependency(MemoryStack stack, int count) {
return VkSubpassDependency.callocStack(count, stack);
}
static VkImageCopy.Buffer VkImageCopy(MemoryStack stack, int count) {
return VkImageCopy.callocStack(count, stack);
}
}

467
src/main/java/com/github/hydos/ginger/engine/vulkan/utils/VKUtils.java Normal file
View File

@ -0,0 +1,467 @@
package com.github.hydos.ginger.engine.vulkan.utils;
import org.lwjgl.assimp.*;
import org.lwjgl.system.Callback;
import org.lwjgl.system.MemoryStack;
import org.lwjgl.util.shaderc.ShadercIncludeResolve;
import org.lwjgl.util.shaderc.ShadercIncludeResult;
import org.lwjgl.util.shaderc.ShadercIncludeResultRelease;
import org.lwjgl.vulkan.*;
import com.github.hydos.ginger.engine.opengl.render.tools.IOUtil;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.LongBuffer;
import java.util.ArrayList;
import java.util.List;
import static org.lwjgl.BufferUtils.*;
import static org.lwjgl.assimp.Assimp.*;
import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.util.shaderc.Shaderc.*;
import static org.lwjgl.vulkan.EXTDebugReport.*;
import static org.lwjgl.vulkan.KHRDisplaySwapchain.*;
import static org.lwjgl.vulkan.KHRSurface.*;
import static org.lwjgl.vulkan.KHRSwapchain.*;
import static org.lwjgl.vulkan.NVRayTracing.*;
import static org.lwjgl.vulkan.VK12.*;
/**
* Utility functions for Vulkan.
*
* @author Kai Burjack
*/
public class VKUtils {
public static final int VK_FLAGS_NONE = 0;
private static int vulkanStageToShadercKind(int stage) {
switch (stage) {
case VK_SHADER_STAGE_VERTEX_BIT:
return shaderc_vertex_shader;
case VK_SHADER_STAGE_FRAGMENT_BIT:
return shaderc_fragment_shader;
case VK_SHADER_STAGE_RAYGEN_BIT_NV:
return shaderc_raygen_shader;
case VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV:
return shaderc_closesthit_shader;
case VK_SHADER_STAGE_MISS_BIT_NV:
return shaderc_miss_shader;
case VK_SHADER_STAGE_ANY_HIT_BIT_NV:
return shaderc_anyhit_shader;
default:
throw new IllegalArgumentException("Stage: " + stage);
}
}
public static ByteBuffer glslToSpirv(String classPath, int vulkanStage) throws IOException {
ByteBuffer src = IOUtil.ioResourceToByteBuffer(classPath, 1024);
long compiler = shaderc_compiler_initialize();
long options = shaderc_compile_options_initialize();
ShadercIncludeResolve resolver;
ShadercIncludeResultRelease releaser;
shaderc_compile_options_set_optimization_level(options, shaderc_optimization_level_performance);
shaderc_compile_options_set_include_callbacks(options, resolver = new ShadercIncludeResolve() {
public long invoke(long user_data, long requested_source, int type, long requesting_source, long include_depth) {
ShadercIncludeResult res = ShadercIncludeResult.calloc();
try {
String src = classPath.substring(0, classPath.lastIndexOf('/')) + "/" + memUTF8(requested_source);
res.content(IOUtil.ioResourceToByteBuffer(src, 1024));
res.source_name(memUTF8(src));
return res.address();
} catch (IOException e) {
throw new AssertionError("Failed to resolve include: " + src);
}
}
}, releaser = new ShadercIncludeResultRelease() {
public void invoke(long user_data, long include_result) {
ShadercIncludeResult result = ShadercIncludeResult.create(include_result);
memFree(result.source_name());
result.free();
}
}, 0L);
long res;
try (MemoryStack stack = MemoryStack.stackPush()) {
res = shaderc_compile_into_spv(compiler, src, vulkanStageToShadercKind(vulkanStage),
stack.UTF8(classPath), stack.UTF8("main"), options);
if (res == 0L)
throw new AssertionError("Internal error during compilation!");
}
if (shaderc_result_get_compilation_status(res) != shaderc_compilation_status_success) {
throw new AssertionError("Shader compilation failed: " + shaderc_result_get_error_message(res));
}
int size = (int) shaderc_result_get_length(res);
ByteBuffer resultBytes = createByteBuffer(size);
resultBytes.put(shaderc_result_get_bytes(res));
resultBytes.flip();
shaderc_compiler_release(res);
shaderc_compiler_release(compiler);
releaser.free();
resolver.free();
return resultBytes;
}
public static void _CHECK_(int ret, String msg) {
if (ret != VK_SUCCESS)
throw new AssertionError(msg + ": " + translateVulkanResult(ret));
}
/**
* Translates a Vulkan {@code VkResult} value to a String describing the result.
*
* @param result
* the {@code VkResult} value
*
* @return the result description
*/
public static String translateVulkanResult(int result) {
switch (result) {
// Success codes
case VK_SUCCESS:
return "Command successfully completed.";
case VK_NOT_READY:
return "A fence or query has not yet completed.";
case VK_TIMEOUT:
return "A wait operation has not completed in the specified time.";
case VK_EVENT_SET:
return "An event is signaled.";
case VK_EVENT_RESET:
return "An event is unsignaled.";
case VK_INCOMPLETE:
return "A return array was too small for the result.";
case VK_SUBOPTIMAL_KHR:
return "A swapchain no longer matches the surface properties exactly, but can still be used to present to the surface successfully.";
// Error codes
case VK_ERROR_OUT_OF_HOST_MEMORY:
return "A host memory allocation has failed.";
case VK_ERROR_OUT_OF_DEVICE_MEMORY:
return "A device memory allocation has failed.";
case VK_ERROR_INITIALIZATION_FAILED:
return "Initialization of an object could not be completed for implementation-specific reasons.";
case VK_ERROR_DEVICE_LOST:
return "The logical or physical device has been lost.";
case VK_ERROR_MEMORY_MAP_FAILED:
return "Mapping of a memory object has failed.";
case VK_ERROR_LAYER_NOT_PRESENT:
return "A requested layer is not present or could not be loaded.";
case VK_ERROR_EXTENSION_NOT_PRESENT:
return "A requested extension is not supported.";
case VK_ERROR_FEATURE_NOT_PRESENT:
return "A requested feature is not supported.";
case VK_ERROR_INCOMPATIBLE_DRIVER:
return "The requested version of Vulkan is not supported by the driver or is otherwise incompatible for implementation-specific reasons.";
case VK_ERROR_TOO_MANY_OBJECTS:
return "Too many objects of the type have already been created.";
case VK_ERROR_FORMAT_NOT_SUPPORTED:
return "A requested format is not supported on this device.";
case VK_ERROR_SURFACE_LOST_KHR:
return "A surface is no longer available.";
case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
return "The requested window is already connected to a VkSurfaceKHR, or to some other non-Vulkan API.";
case VK_ERROR_OUT_OF_DATE_KHR:
return "A surface has changed in such a way that it is no longer compatible with the swapchain, and further presentation requests using the "
+ "swapchain will fail. Applications must query the new surface properties and recreate their swapchain if they wish to continue" + "presenting to the surface.";
case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
return "The display used by a swapchain does not use the same presentable image layout, or is incompatible in a way that prevents sharing an" + " image.";
case VK_ERROR_VALIDATION_FAILED_EXT:
return "A validation layer found an error.";
default:
return String.format("%s [%d]", "Unknown", Integer.valueOf(result));
}
}
public static String format_to_string(int format) {
switch (format) {
case 0: return "UNDEFINED";
case 1: return "R4G4_UNORM_PACK8";
case 2: return "R4G4B4A4_UNORM_PACK16";
case 3: return "B4G4R4A4_UNORM_PACK16";
case 4: return "R5G6B5_UNORM_PACK16";
case 5: return "B5G6R5_UNORM_PACK16";
case 6: return "R5G5B5A1_UNORM_PACK16";
case 7: return "B5G5R5A1_UNORM_PACK16";
case 8: return "A1R5G5B5_UNORM_PACK16";
case 9: return "R8_UNORM";
case 10: return "R8_SNORM";
case 11: return "R8_USCALED";
case 12: return "R8_SSCALED";
case 13: return "R8_UINT";
case 14: return "R8_SINT";
case 15: return "R8_SRGB";
case 16: return "R8G8_UNORM";
case 17: return "R8G8_SNORM";
case 18: return "R8G8_USCALED";
case 19: return "R8G8_SSCALED";
case 20: return "R8G8_UINT";
case 21: return "R8G8_SINT";
case 22: return "R8G8_SRGB";
case 23: return "R8G8B8_UNORM";
case 24: return "R8G8B8_SNORM";
case 25: return "R8G8B8_USCALED";
case 26: return "R8G8B8_SSCALED";
case 27: return "R8G8B8_UINT";
case 28: return "R8G8B8_SINT";
case 29: return "R8G8B8_SRGB";
case 30: return "B8G8R8_UNORM";
case 31: return "B8G8R8_SNORM";
case 32: return "B8G8R8_USCALED";
case 33: return "B8G8R8_SSCALED";
case 34: return "B8G8R8_UINT";
case 35: return "B8G8R8_SINT";
case 36: return "B8G8R8_SRGB";
case 37: return "R8G8B8A8_UNORM";
case 38: return "R8G8B8A8_SNORM";
case 39: return "R8G8B8A8_USCALED";
case 40: return "R8G8B8A8_SSCALED";
case 41: return "R8G8B8A8_UINT";
case 42: return "R8G8B8A8_SINT";
case 43: return "R8G8B8A8_SRGB";
case 44: return "B8G8R8A8_UNORM";
case 45: return "B8G8R8A8_SNORM";
case 46: return "B8G8R8A8_USCALED";
case 47: return "B8G8R8A8_SSCALED";
case 48: return "B8G8R8A8_UINT";
case 49: return "B8G8R8A8_SINT";
case 50: return "B8G8R8A8_SRGB";
case 51: return "A8B8G8R8_UNORM_PACK32";
case 52: return "A8B8G8R8_SNORM_PACK32";
case 53: return "A8B8G8R8_USCALED_PACK32";
case 54: return "A8B8G8R8_SSCALED_PACK32";
case 55: return "A8B8G8R8_UINT_PACK32";
case 56: return "A8B8G8R8_SINT_PACK32";
case 57: return "A8B8G8R8_SRGB_PACK32";
case 58: return "A2R10G10B10_UNORM_PACK32";
case 59: return "A2R10G10B10_SNORM_PACK32";
case 60: return "A2R10G10B10_USCALED_PACK32";
case 61: return "A2R10G10B10_SSCALED_PACK32";
case 62: return "A2R10G10B10_UINT_PACK32";
case 63: return "A2R10G10B10_SINT_PACK32";
case 64: return "A2B10G10R10_UNORM_PACK32";
case 65: return "A2B10G10R10_SNORM_PACK32";
case 66: return "A2B10G10R10_USCALED_PACK32";
case 67: return "A2B10G10R10_SSCALED_PACK32";
case 68: return "A2B10G10R10_UINT_PACK32";
case 69: return "A2B10G10R10_SINT_PACK32";
case 70: return "R16_UNORM";
case 71: return "R16_SNORM";
case 72: return "R16_USCALED";
case 73: return "R16_SSCALED";
case 74: return "R16_UINT";
case 75: return "R16_SINT";
case 76: return "R16_SFLOAT";
case 77: return "R16G16_UNORM";
case 78: return "R16G16_SNORM";
case 79: return "R16G16_USCALED";
case 80: return "R16G16_SSCALED";
case 81: return "R16G16_UINT";
case 82: return "R16G16_SINT";
case 83: return "R16G16_SFLOAT";
case 84: return "R16G16B16_UNORM";
case 85: return "R16G16B16_SNORM";
case 86: return "R16G16B16_USCALED";
case 87: return "R16G16B16_SSCALED";
case 88: return "R16G16B16_UINT";
case 89: return "R16G16B16_SINT";
case 90: return "R16G16B16_SFLOAT";
case 91: return "R16G16B16A16_UNORM";
case 92: return "R16G16B16A16_SNORM";
case 93: return "R16G16B16A16_USCALED";
case 94: return "R16G16B16A16_SSCALED";
case 95: return "R16G16B16A16_UINT";
case 96: return "R16G16B16A16_SINT";
case 97: return "R16G16B16A16_SFLOAT";
case 98: return "R32_UINT";
case 99: return "R32_SINT";
case 100: return "R32_SFLOAT";
case 101: return "R32G32_UINT";
case 102: return "R32G32_SINT";
case 103: return "R32G32_SFLOAT";
case 104: return "R32G32B32_UINT";
case 105: return "R32G32B32_SINT";
case 106: return "R32G32B32_SFLOAT";
case 107: return "R32G32B32A32_UINT";
case 108: return "R32G32B32A32_SINT";
case 109: return "R32G32B32A32_SFLOAT";
case 110: return "R64_UINT";
case 111: return "R64_SINT";
case 112: return "R64_SFLOAT";
case 113: return "R64G64_UINT";
case 114: return "R64G64_SINT";
case 115: return "R64G64_SFLOAT";
case 116: return "R64G64B64_UINT";
case 117: return "R64G64B64_SINT";
case 118: return "R64G64B64_SFLOAT";
case 119: return "R64G64B64A64_UINT";
case 120: return "R64G64B64A64_SINT";
case 121: return "R64G64B64A64_SFLOAT";
case 122: return "B10G11R11_UFLOAT_PACK32";
case 123: return "E5B9G9R9_UFLOAT_PACK32";
case 124: return "D16_UNORM";
case 125: return "X8_D24_UNORM_PACK32";
case 126: return "D32_SFLOAT";
case 127: return "S8_UINT";
case 128: return "D16_UNORM_S8_UINT";
case 129: return "D24_UNORM_S8_UINT";
case 130: return "D32_SFLOAT_S8_UINT";
case 131: return "BC1_RGB_UNORM_BLOCK";
case 132: return "BC1_RGB_SRGB_BLOCK";
case 133: return "BC1_RGBA_UNORM_BLOCK";
case 134: return "BC1_RGBA_SRGB_BLOCK";
case 135: return "BC2_UNORM_BLOCK";
case 136: return "BC2_SRGB_BLOCK";
case 137: return "BC3_UNORM_BLOCK";
case 138: return "BC3_SRGB_BLOCK";
case 139: return "BC4_UNORM_BLOCK";
case 140: return "BC4_SNORM_BLOCK";
case 141: return "BC5_UNORM_BLOCK";
case 142: return "BC5_SNORM_BLOCK";
case 143: return "BC6H_UFLOAT_BLOCK";
case 144: return "BC6H_SFLOAT_BLOCK";
case 145: return "BC7_UNORM_BLOCK";
case 146: return "BC7_SRGB_BLOCK";
case 147: return "ETC2_R8G8B8_UNORM_BLOCK";
case 148: return "ETC2_R8G8B8_SRGB_BLOCK";
case 149: return "ETC2_R8G8B8A1_UNORM_BLOCK";
case 150: return "ETC2_R8G8B8A1_SRGB_BLOCK";
case 151: return "ETC2_R8G8B8A8_UNORM_BLOCK";
case 152: return "ETC2_R8G8B8A8_SRGB_BLOCK";
case 153: return "EAC_R11_UNORM_BLOCK";
case 154: return "EAC_R11_SNORM_BLOCK";
case 155: return "EAC_R11G11_UNORM_BLOCK";
case 156: return "EAC_R11G11_SNORM_BLOCK";
case 157: return "ASTC_4x4_UNORM_BLOCK";
case 158: return "ASTC_4x4_SRGB_BLOCK";
case 159: return "ASTC_5x4_UNORM_BLOCK";
case 160: return "ASTC_5x4_SRGB_BLOCK";
case 161: return "ASTC_5x5_UNORM_BLOCK";
case 162: return "ASTC_5x5_SRGB_BLOCK";
case 163: return "ASTC_6x5_UNORM_BLOCK";
case 164: return "ASTC_6x5_SRGB_BLOCK";
case 165: return "ASTC_6x6_UNORM_BLOCK";
case 166: return "ASTC_6x6_SRGB_BLOCK";
case 167: return "ASTC_8x5_UNORM_BLOCK";
case 168: return "ASTC_8x5_SRGB_BLOCK";
case 169: return "ASTC_8x6_UNORM_BLOCK";
case 170: return "ASTC_8x6_SRGB_BLOCK";
case 171: return "ASTC_8x8_UNORM_BLOCK";
case 172: return "ASTC_8x8_SRGB_BLOCK";
case 173: return "ASTC_10x5_UNORM_BLOCK";
case 174: return "ASTC_10x5_SRGB_BLOCK";
case 175: return "ASTC_10x6_UNORM_BLOCK";
case 176: return "ASTC_10x6_SRGB_BLOCK";
case 177: return "ASTC_10x8_UNORM_BLOCK";
case 178: return "ASTC_10x8_SRGB_BLOCK";
case 179: return "ASTC_10x10_UNORM_BLOCK";
case 180: return "ASTC_10x10_SRGB_BLOCK";
case 181: return "ASTC_12x10_UNORM_BLOCK";
case 182: return "ASTC_12x10_SRGB_BLOCK";
case 183: return "ASTC_12x12_UNORM_BLOCK";
case 184: return "ASTC_12x12_SRGB_BLOCK";
case 1000156000: return "G8B8G8R8_422_UNORM";
case 1000156001: return "B8G8R8G8_422_UNORM";
case 1000156002: return "G8_B8_R8_3PLANE_420_UNORM";
case 1000156003: return "G8_B8R8_2PLANE_420_UNORM";
case 1000156004: return "G8_B8_R8_3PLANE_422_UNORM";
case 1000156005: return "G8_B8R8_2PLANE_422_UNORM";
case 1000156006: return "G8_B8_R8_3PLANE_444_UNORM";
case 1000156007: return "R10X6_UNORM_PACK16";
case 1000156008: return "R10X6G10X6_UNORM_2PACK16";
case 1000156009: return "R10X6G10X6B10X6A10X6_UNORM_4PACK16";
case 1000156010: return "G10X6B10X6G10X6R10X6_422_UNORM_4PACK16";
case 1000156011: return "B10X6G10X6R10X6G10X6_422_UNORM_4PACK16";
case 1000156012: return "G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16";
case 1000156013: return "G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16";
case 1000156014: return "G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16";
case 1000156015: return "G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16";
case 1000156016: return "G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16";
case 1000156017: return "R12X4_UNORM_PACK16";
case 1000156018: return "R12X4G12X4_UNORM_2PACK16";
case 1000156019: return "R12X4G12X4B12X4A12X4_UNORM_4PACK16";
case 1000156020: return "G12X4B12X4G12X4R12X4_422_UNORM_4PACK16";
case 1000156021: return "B12X4G12X4R12X4G12X4_422_UNORM_4PACK16";
case 1000156022: return "G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16";
case 1000156023: return "G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16";
case 1000156024: return "G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16";
case 1000156025: return "G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16";
case 1000156026: return "G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16";
case 1000156027: return "G16B16G16R16_422_UNORM";
case 1000156028: return "B16G16R16G16_422_UNORM";
case 1000156029: return "G16_B16_R16_3PLANE_420_UNORM";
case 1000156030: return "G16_B16R16_2PLANE_420_UNORM";
case 1000156031: return "G16_B16_R16_3PLANE_422_UNORM";
case 1000156032: return "G16_B16R16_2PLANE_422_UNORM";
case 1000156033: return "G16_B16_R16_3PLANE_444_UNORM";
case 1000054000: return "PVRTC1_2BPP_UNORM_BLOCK_IMG";
case 1000054001: return "PVRTC1_4BPP_UNORM_BLOCK_IMG";
case 1000054002: return "PVRTC2_2BPP_UNORM_BLOCK_IMG";
case 1000054003: return "PVRTC2_4BPP_UNORM_BLOCK_IMG";
case 1000054004: return "PVRTC1_2BPP_SRGB_BLOCK_IMG";
case 1000054005: return "PVRTC1_4BPP_SRGB_BLOCK_IMG";
case 1000054006: return "PVRTC2_2BPP_SRGB_BLOCK_IMG";
case 1000054007: return "PVRTC2_4BPP_SRGB_BLOCK_IMG";
default: return "";
}
}
static AIScene loadModel(String classpathResource) {
AIFileIO fileIo = AIFileIO.create();
List<Callback> callbacks = new ArrayList<>();
AIFileOpenProc fileOpenProc = new AIFileOpenProc() {
public long invoke(long pFileIO, long fileName, long openMode) {
AIFile aiFile = AIFile.create();
final ByteBuffer data;
String fileNameUtf8 = memUTF8(fileName);
try {
data = IOUtil.ioResourceToByteBuffer(fileNameUtf8, 8192);
} catch (IOException e) {
throw new RuntimeException("Could not open file: " + fileNameUtf8);
}
AIFileReadProc fileReadProc = new AIFileReadProc() {
public long invoke(long pFile, long pBuffer, long size, long count) {
long max = Math.min(data.remaining(), size * count);
memCopy(memAddress(data) + data.position(), pBuffer, max);
return max;
}
};
callbacks.add(fileReadProc);
AIFileSeek fileSeekProc = new AIFileSeek() {
public int invoke(long pFile, long offset, int origin) {
if (origin == Assimp.aiOrigin_CUR) {
data.position(data.position() + (int) offset);
} else if (origin == Assimp.aiOrigin_SET) {
data.position((int) offset);
} else if (origin == Assimp.aiOrigin_END) {
data.position(data.limit() + (int) offset);
}
return 0;
}
};
callbacks.add(fileSeekProc);
AIFileTellProc fileTellProc = new AIFileTellProc() {
public long invoke(long pFile) {
return data.limit();
}
};
callbacks.add(fileTellProc);
aiFile.ReadProc(fileReadProc);
aiFile.SeekProc(fileSeekProc);
aiFile.FileSizeProc(fileTellProc);
return aiFile.address();
}
};
AIFileCloseProc fileCloseProc = new AIFileCloseProc() {
public void invoke(long pFileIO, long pFile) {
/* Nothing to do */
}
};
callbacks.add(fileOpenProc);
callbacks.add(fileCloseProc);
fileIo.set(fileOpenProc, fileCloseProc, NULL);
AIScene scene = aiImportFileEx(classpathResource,
aiProcess_JoinIdenticalVertices | aiProcess_Triangulate, fileIo);
callbacks.forEach(Callback::free);
return scene;
}
}