random offsets in raygen

raytracer/ray_tracing_gltf/hello_vulkan.cpp

@@ -339,10 +339,10 @@ void HelloVulkan::createTextureImages(const VkCommandBuffer& cmdBuf, tinygltf::M
 void HelloVulkan::createPointsetTexture(const VkCommandBuffer& cmdBuf)
 {
   VkSamplerCreateInfo samplerCreateInfo{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
-  samplerCreateInfo.minFilter  = VK_FILTER_NEAREST;
+  samplerCreateInfo.minFilter    = VK_FILTER_NEAREST;
-  samplerCreateInfo.magFilter  = VK_FILTER_NEAREST;
+  samplerCreateInfo.magFilter    = VK_FILTER_NEAREST;
-  samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+  samplerCreateInfo.mipmapMode   = VK_SAMPLER_MIPMAP_MODE_LINEAR;
-  samplerCreateInfo.maxLod     = FLT_MAX;
+  samplerCreateInfo.maxLod       = FLT_MAX;
   samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
   samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
   samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
@@ -351,22 +351,21 @@ void HelloVulkan::createPointsetTexture(const VkCommandBuffer& cmdBuf)
 
   // TODO: generate and parse pointset here
   std::vector<float_t> points{};
-  points.reserve(swapchainExtent.height * swapchainExtent.width * 2);
+  points.reserve(swapchainExtent.height * swapchainExtent.width * 2 * 4);
 
-  for(int y = 0; y < swapchainExtent.height; ++y)
+  for(int y = 0; y < swapchainExtent.height * 4; ++y)
   {
     for(int x = 0; x < swapchainExtent.width; ++x)
     {
       float rand_x = static_cast<float>(rand()) / static_cast<float_t>(RAND_MAX);
       float rand_y = static_cast<float>(rand()) / static_cast<float_t>(RAND_MAX);
-      std::cout << "x: " << rand_x << "|y: " << rand_y << std::endl;
+      points.push_back(rand_x);
-      points.emplace_back(rand_x);
+      points.push_back(rand_y);
-      points.emplace_back(rand_y);
     }
   }
 
-
+  VkImageCreateInfo imageCreateInfo =
-  VkImageCreateInfo imageCreateInfo = nvvk::makeImage2DCreateInfo(swapchainExtent, VK_FORMAT_R32G32_SFLOAT, VK_IMAGE_USAGE_SAMPLED_BIT, false);
+      nvvk::makeImage2DCreateInfo(swapchainExtent, VK_FORMAT_R32G32_SFLOAT, VK_IMAGE_USAGE_SAMPLED_BIT, false);
   nvvk::Image           image  = m_alloc.createImage(cmdBuf, points.size(), points.data(), imageCreateInfo);
   VkImageViewCreateInfo ivInfo = nvvk::makeImageViewCreateInfo(image.image, imageCreateInfo);
   m_pointset                   = m_alloc.createTexture(image, ivInfo, samplerCreateInfo);

raytracer/ray_tracing_gltf/main.cpp

@@ -71,8 +71,8 @@ void renderUI(HelloVulkan& helloVk, bool useRaytracer)
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
-static int const SAMPLE_WIDTH  = 1280;
+static int const SAMPLE_WIDTH  = 800;
-static int const SAMPLE_HEIGHT = 720;
+static int const SAMPLE_HEIGHT = 800;
 
 
 //--------------------------------------------------------------------------------------------------

raytracer/ray_tracing_gltf/shaders/raytrace.rgen

@@ -35,37 +35,37 @@ layout(set = 0, binding = 1, rgba32f) uniform image2D image;
 layout(set = 1, binding = 0) uniform _GlobalUniforms { GlobalUniforms uni; };
 layout(push_constant) uniform _PushConstantRay { PushConstantRay pcRay; };
 
-layout(set = 1, binding = ePointsetTexture) uniform sampler2D pointset; // bluenoise pointset
+layout(set = 1, binding = ePointsetTexture) uniform sampler2D pointset;// bluenoise pointset
 // clang-format on
 
 void main()
 {
-  const vec2 pixelCenter = vec2(gl_LaunchIDEXT.xy) + vec2(0.5);
+    vec2 uv = vec2(float(gl_LaunchIDEXT.x) / float(gl_LaunchSizeEXT.x), float(gl_LaunchIDEXT.y) / float(gl_LaunchSizeEXT.y));
-  const vec2 inUV        = pixelCenter / vec2(gl_LaunchSizeEXT.xy);
-  vec2       d           = inUV * 2.0 - 1.0;
 
-  vec4 origin    = uni.viewInverse * vec4(0, 0, 0, 1);
+    const vec2 rayOriginInPix = vec2(gl_LaunchIDEXT.xy) + texture(pointset, uv).xy;
-  vec4 target    = uni.projInverse * vec4(d.x, d.y, 1, 1);
+    const vec2 inUV        = rayOriginInPix / vec2(gl_LaunchSizeEXT.xy);
-  vec4 direction = uni.viewInverse * vec4(normalize(target.xyz), 0);
+    vec2       d           = inUV * 2.0 - 1.0;
 
-  uint  rayFlags = gl_RayFlagsOpaqueEXT;
+    vec4 origin    = uni.viewInverse * vec4(0, 0, 0, 1);
-  float tMin     = 0.001;
+    vec4 target    = uni.projInverse * vec4(d.x, d.y, 1, 1);
-  float tMax     = 10000.0;
+    vec4 direction = uni.viewInverse * vec4(normalize(target.xyz), 0);
 
-  traceRayEXT(topLevelAS,     // acceleration structure
+    uint  rayFlags = gl_RayFlagsOpaqueEXT;
-              rayFlags,       // rayFlags
+    float tMin     = 0.001;
-              0xFF,           // cullMask
+    float tMax     = 10000.0;
-              0,              // sbtRecordOffset
-              0,              // sbtRecordStride
-              0,              // missIndex
-              origin.xyz,     // ray origin
-              tMin,           // ray min range
-              direction.xyz,  // ray direction
-              tMax,           // ray max range
-              0               // payload (location = 0)
-  );
 
-    //imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(prd.hitValue, 1.0));
+    traceRayEXT(topLevelAS, // acceleration structure
-    vec2 uv = vec2(float(gl_LaunchIDEXT.x) / float(gl_LaunchSizeEXT.x) - 0.5, float(gl_LaunchIDEXT.y) / float(gl_LaunchSizeEXT.y) - 0.5);
+    rayFlags, // rayFlags
-    imageStore(image, ivec2(gl_LaunchIDEXT.xy), texture(pointset, uv));
+    0xFF, // cullMask
+    0, // sbtRecordOffset
+    0, // sbtRecordStride
+    0, // missIndex
+    origin.xyz, // ray origin
+    tMin, // ray min range
+    direction.xyz, // ray direction
+    tMax, // ray max range
+    0// payload (location = 0)
+    );
+
+    imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(prd.hitValue, 1.0));
 }