From a2a9b79747aca75e64e9614dd336e890383671ac Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Sat, 27 Jul 2024 17:44:51 +0200 Subject: [PATCH 01/18] Initial commit for OpenCL-Vulkan interop sample main subject of this sample is ocean surface simulation --- samples/CMakeLists.txt | 1 + samples/vulkan/CMakeLists.txt | 30 + samples/vulkan/ocean/CMakeLists.txt | 23 + samples/vulkan/ocean/README.md | 59 + samples/vulkan/ocean/fft_kernel.cl | 58 + samples/vulkan/ocean/init_spectrum.cl | 63 + samples/vulkan/ocean/inversion.cl | 30 + samples/vulkan/ocean/main.cpp | 124 ++ samples/vulkan/ocean/normals.cl | 48 + samples/vulkan/ocean/ocean.cpp | 2733 +++++++++++++++++++++++++ samples/vulkan/ocean/ocean.frag | 121 ++ samples/vulkan/ocean/ocean.frag.spv | Bin 0 -> 7448 bytes samples/vulkan/ocean/ocean.hpp | 327 +++ samples/vulkan/ocean/ocean.png | Bin 0 -> 720027 bytes samples/vulkan/ocean/ocean.vert | 42 + samples/vulkan/ocean/ocean.vert.spv | Bin 0 -> 2524 bytes samples/vulkan/ocean/ocean_util.hpp | 272 +++ samples/vulkan/ocean/time_spectrum.cl | 78 + samples/vulkan/ocean/twiddle.cl | 53 + 19 files changed, 4062 insertions(+) create mode 100755 samples/vulkan/CMakeLists.txt create mode 100755 samples/vulkan/ocean/CMakeLists.txt create mode 100755 samples/vulkan/ocean/README.md create mode 100644 samples/vulkan/ocean/fft_kernel.cl create mode 100644 samples/vulkan/ocean/init_spectrum.cl create mode 100644 samples/vulkan/ocean/inversion.cl create mode 100755 samples/vulkan/ocean/main.cpp create mode 100644 samples/vulkan/ocean/normals.cl create mode 100755 samples/vulkan/ocean/ocean.cpp create mode 100755 samples/vulkan/ocean/ocean.frag create mode 100755 samples/vulkan/ocean/ocean.frag.spv create mode 100755 samples/vulkan/ocean/ocean.hpp create mode 100644 samples/vulkan/ocean/ocean.png create mode 100755 samples/vulkan/ocean/ocean.vert create mode 100755 samples/vulkan/ocean/ocean.vert.spv create mode 100755 samples/vulkan/ocean/ocean_util.hpp create mode 100644 samples/vulkan/ocean/time_spectrum.cl create mode 100644 samples/vulkan/ocean/twiddle.cl diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt index 0834853a..cc4ec7ce 100644 --- a/samples/CMakeLists.txt +++ b/samples/CMakeLists.txt @@ -146,3 +146,4 @@ endmacro() add_subdirectory(core) add_subdirectory(extensions) +add_subdirectory(vulkan) diff --git a/samples/vulkan/CMakeLists.txt b/samples/vulkan/CMakeLists.txt new file mode 100755 index 00000000..e8855ce3 --- /dev/null +++ b/samples/vulkan/CMakeLists.txt @@ -0,0 +1,30 @@ +# Copyright (c) 2021 The Khronos Group Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +find_package(Vulkan) +find_package(glfw3 HINTS "../../external") + +set(BUILD_VULKAN_SAMPLES TRUE) +if(NOT VULKAN_FOUND) + message(STATUS "Skipping Vulkan Samples - Vulkan is not found.") + set(BUILD_VULKAN_SAMPLES FALSE) +endif() +if(NOT glfw3_FOUND) + message(STATUS "Skipping Vulkan Samples - GLFW is not found.") + set(BUILD_VULKAN_SAMPLES FALSE) +endif() + +if(BUILD_VULKAN_SAMPLES) + add_subdirectory( ocean ) +endif() diff --git a/samples/vulkan/ocean/CMakeLists.txt b/samples/vulkan/ocean/CMakeLists.txt new file mode 100755 index 00000000..20062295 --- /dev/null +++ b/samples/vulkan/ocean/CMakeLists.txt @@ -0,0 +1,23 @@ +# Copyright (c) 2024 Mobica Limited, Marcin Hajder +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +add_sample( + TARGET ocean_vk_ocl_interop + VERSION 300 # clCreateImageWithProperties + CATEGORY vulkan + SOURCES main.cpp ocean.cpp ocean.hpp ocean_util.hpp + SHADERS ocean.vert.spv ocean.frag.spv + KERNELS twiddle.cl time_spectrum.cl inversion.cl normals.cl fft_kernel.cl init_spectrum.cl + INCLUDES ${Vulkan_INCLUDE_DIR} + LIBS ${Vulkan_LIBRARY} glfw glm::glm) diff --git a/samples/vulkan/ocean/README.md b/samples/vulkan/ocean/README.md new file mode 100755 index 00000000..e8246724 --- /dev/null +++ b/samples/vulkan/ocean/README.md @@ -0,0 +1,59 @@ +# Ocean surface simulation with Opencl and Vulkan interoperability + +[Ocean Simulation With OpenCL and Vulkan](ocean.png) + +## Sample Purpose + +This sample demonstrates how to share compute/render resources between OpenCL and Vulkan to simulate an ocean surface. If the cl_khr_external_memory extension is available and requested (through CLI options), some OpenCL images will be created through a file descriptor handle received with vkGetMemoryFdKHR. These images will then be used for ocean rendering. If cl_khr_external_memory is not available, additional copying from OpenCL buffers to Vulkan images will be performed. + +## Key APIs and Concepts + +The primary focus of this sample is to understand how to set up shared resources between OpenCL and Vulkan interoperability. Additionally, this sample demonstrates how to approach physical, real-time simulations in OpenCL and the API objects involved in executing an OpenCL application such as ocean surface simulation. + + +### Application flow + +The application performs an initial setup during which: + + -An OpenCL platform and Vulkan physical device are selected based on CLI options. + -OpenCL and Vulkan devices are prepared. + -A GLFW window, camera, and related keyboard event callbacks are created. + -Both shared and private resources for OpenCL and Vulkan are set up. + +After the setup, the simulation starts with initial ocean parameters that can be modified with keyboard events in real-time: + + - a/z - Increase/decrease wind magnitude. + - s/x - Change wind heading. + - d/c - Increase/decrease waving amplitude. + - f/v - Increase/decrease wave choppiness. + - g/b - Increase/decrease additional altitude scale. + +Additionally, the simulation and rendering can be paused with the Space key. Rendering can toggle between wireframe and filled modes using the 'w' key. While the simulation is in progress, each frame of the application performs the following general steps: + + -Necessary Vulkan/OpenCL semaphores are signaled/waited. + -Uniform buffers are updated to handle camera and ocean parameters. + -OpenCL kernels are enqueued. + -The ocean grid is rendered using the previous OpenCL computation outcome. + + +### Kernel logic + +Multiple kernels follow the general steps (with multiple optimizations) described in the publication: [Realtime GPGPU FFT ocean water simulation](https://tore.tuhh.de/bitstream/11420/1439/1/GPGPU_FFT_Ocean_Simulation.pdf) + +### Used API surface + +```c++ +cl::util::supports_extension(cl::Device, cl::string) +cl::Context(cl::Device) +cl::CommandQueue(cl::Context, cl::Device) +cl::Platform::get(vector) +cl::Platform::getDevices(Type, vector) +cl::Program::build() +cl::Image2D(cl::Context, cl_mem_flags, ImageFormat, size_type, size_type) +cl::Error::what() +cl::Error::err() +cl::NDRange(size_type, size_type) +cl::Buffer::Buffer(cl::Context, cl_mem_flags, size_type) +``` + + diff --git a/samples/vulkan/ocean/fft_kernel.cl b/samples/vulkan/ocean/fft_kernel.cl new file mode 100644 index 00000000..2976e2f2 --- /dev/null +++ b/samples/vulkan/ocean/fft_kernel.cl @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +constant sampler_t sampler = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST | CLK_NORMALIZED_COORDS_FALSE; + +typedef float2 complex; + +complex mul(complex c0, complex c1) +{ + return (complex)(c0.x * c1.x - c0.y * c1.y, c0.x * c1.y + c0.y * c1.x); +} + +complex add(complex c0, complex c1) +{ + return (complex)(c0.x + c1.x, c0.y + c1.y); +} + +// mode.x - 0-horizontal, 1-vertical +// mode.y - subsequent count + +__kernel void fft_1D( int2 mode, int2 patch_info, + read_only image2d_t twiddle, read_only image2d_t src, write_only image2d_t dst ) +{ + int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); + + int2 data_coords = (int2)(mode.y, uv.x * (1-mode.x) + uv.y * mode.x); + float4 data = read_imagef(twiddle, sampler, data_coords); + + + work_group_barrier(CLK_IMAGE_MEM_FENCE); + + + int2 pp_coords0 = (int2)(data.z, uv.y) * (1-mode.x) + (int2)(uv.x, data.z) * mode.x; + float2 p = read_imagef(src, sampler, pp_coords0).rg; + + int2 pp_coords1 = (int2)(data.w, uv.y) * (1-mode.x) + (int2)(uv.x, data.w) * mode.x; + float2 q = read_imagef(src, sampler, pp_coords1).rg; + + float2 w = (float2)(data.x, data.y); + + //Butterfly operation + complex H = add(p,mul(w,q)); + + write_imagef(dst, uv, (float4)(H.x, H.y, 0, 1)); +} diff --git a/samples/vulkan/ocean/init_spectrum.cl b/samples/vulkan/ocean/init_spectrum.cl new file mode 100644 index 00000000..8e6e47e2 --- /dev/null +++ b/samples/vulkan/ocean/init_spectrum.cl @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +constant float PI = 3.14159265359f; +constant sampler_t sampler = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST | CLK_NORMALIZED_COORDS_FALSE; +constant float GRAVITY = 9.81f; + +float4 gaussRND(float4 rnd) +{ + float u0 = 2.0*PI*rnd.x; + float v0 = sqrt(-2.0 * log(rnd.y)); + float u1 = 2.0*PI*rnd.z; + float v1 = sqrt(-2.0 * log(rnd.w)); + + float4 ret = (float4)(v0 * cos(u0), v0 * sin(u0), v1 * cos(u1), v1 * sin(u1)); + return ret; +} + +// patch_info.x - ocean patch size +// patch_info.y - ocean texture unified resolution +// params.x - wind x +// params.y - wind.y +// params.z - amplitude +// params.w - capillar supress factor + +kernel void init_spectrum( int2 patch_info, float4 params, read_only image2d_t noise, write_only image2d_t dst ) +{ + int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); + int res = patch_info.y; + + float2 fuv = (float2)(get_global_id(0), get_global_id(1)) - (float)(res)/2.f; + float2 k = (2.f * PI * fuv) / patch_info.x; + float k_mag = length(k); + + if (k_mag < 0.00001) k_mag = 0.00001; + + float wind_speed = length((float2)(params.x, params.y)); + float4 params_n = params; + params_n.xy = (float2)(params.x/wind_speed, params.y/wind_speed); + float l_phillips = (wind_speed * wind_speed) / GRAVITY; + float4 rnd = clamp(read_imagef(noise, sampler, uv), 0.001f, 1.f); + + float magSq = k_mag * k_mag; + float h0k = sqrt((params.z/(magSq*magSq)) * pow(dot(normalize(k), params_n.xy), 2.f) * + exp(-(1.0/(magSq * l_phillips * l_phillips))) * exp(-magSq*pow(params.w, 2.f)))/ sqrt(2.0); + float h0minusk = sqrt((params.z/(magSq*magSq)) * pow(dot(normalize(-k), params_n.xy), 2.f) * + exp(-(1.0/(magSq * l_phillips * l_phillips))) * exp(-magSq*pow(params.w, 2.f)))/ sqrt(2.0); + float4 gauss_random = gaussRND(rnd); + write_imagef(dst, uv, (float4)(gauss_random.xy*h0k, gauss_random.zw*h0minusk)); +} diff --git a/samples/vulkan/ocean/inversion.cl b/samples/vulkan/ocean/inversion.cl new file mode 100644 index 00000000..a8c3e196 --- /dev/null +++ b/samples/vulkan/ocean/inversion.cl @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +constant sampler_t sampler = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST | CLK_NORMALIZED_COORDS_FALSE; + +kernel void inversion( int2 patch_info, read_only image2d_t src0, + read_only image2d_t src1, read_only image2d_t src2, write_only image2d_t dst ) +{ + int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); + int res2 = patch_info.y * patch_info.y; + + float x = read_imagef(src0, sampler, uv).r; + float y = read_imagef(src1, sampler, uv).r; + float z = read_imagef(src2, sampler, uv).r; + + write_imagef(dst, uv, (float4)(x/res2, y/res2, z/res2, 1)); +} diff --git a/samples/vulkan/ocean/main.cpp b/samples/vulkan/ocean/main.cpp new file mode 100755 index 00000000..fbf62254 --- /dev/null +++ b/samples/vulkan/ocean/main.cpp @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ocean.hpp" + +namespace { + +void glfw_keyboard(GLFWwindow* window, int key, int scancode, int action, + int mods) +{ + auto app = (OceanApplication*)glfwGetWindowUserPointer(window); + app->keyboard(key, scancode, action, mods); +} + +void glfw_mouse_event(GLFWwindow* window, int button, int action, int mods) +{ + auto app = (OceanApplication*)glfwGetWindowUserPointer(window); + app->mouse_event(button, action, mods); +} + +void glfw_mouse_pos(GLFWwindow* window, double pX, double pY) +{ + auto app = (OceanApplication*)glfwGetWindowUserPointer(window); + app->mouse_pos(pX, pY); +} + +void glfw_mouse_roll(GLFWwindow* window, double oX, double oY) +{ + auto app = (OceanApplication*)glfwGetWindowUserPointer(window); + app->mouse_roll(oX, oY); +} + +} // anonymous namespace + + +void OceanApplication::main_loop() +{ + glfwSetKeyCallback(window, glfw_keyboard); + glfwSetMouseButtonCallback(window, glfw_mouse_event); + glfwSetCursorPosCallback(window, glfw_mouse_pos); + glfwSetScrollCallback(window, glfw_mouse_roll); + + while (!glfwWindowShouldClose(window)) + { + draw_frame(); + glfwPollEvents(); + } + + vkDeviceWaitIdle(device); +} + +template <> auto cl::sdk::parse() +{ + return std::make_tuple( + std::make_shared>("", "window_width", + "Window width", false, 1024, + "positive integral"), + std::make_shared>("", "window_height", + "Window height", false, 1024, + "positive integral"), + std::make_shared>( + "", "immediate", "Prefer VK_PRESENT_MODE_IMMEDIATE_KHR (no vsync)", + false, false, "boolean"), + std::make_shared>( + "", "linear", "Use linearly tiled images", false, false, "boolean"), + std::make_shared>("", "deviceLocalImages", + "Use device local images", + false, true, "boolean"), + std::make_shared>("", "useExternalMemory", + "Use cl_khr_external_memory", + false, true, "boolean")); +} + +template <> +CliOptions cl::sdk::comprehend( + std::shared_ptr> window_width, + std::shared_ptr> window_height, + std::shared_ptr> immediate, + std::shared_ptr> linearImages, + std::shared_ptr> deviceLocalImages, + std::shared_ptr> useExternalMemory) +{ + return CliOptions{ + window_width->getValue(), window_height->getValue(), + immediate->getValue(), linearImages->getValue(), + deviceLocalImages->getValue(), useExternalMemory->getValue() + }; +} + +int main(int argc, char** argv) +{ + OceanApplication app; + + auto opts = cl::sdk::parse_cli( + argc, argv); + + app.dev_opts = std::get<1>(opts); + app.app_opts = std::get<2>(opts); + + try + { + app.run(); + } catch (const std::exception& e) + { + fprintf(stderr, "%s\n", e.what()); + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/samples/vulkan/ocean/normals.cl b/samples/vulkan/ocean/normals.cl new file mode 100644 index 00000000..66af5f6d --- /dev/null +++ b/samples/vulkan/ocean/normals.cl @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +constant sampler_t sampler = CLK_ADDRESS_REPEAT | CLK_FILTER_LINEAR | CLK_NORMALIZED_COORDS_TRUE; +constant float normal_scale_fac = 3.f; +// patch_info.x - ocean patch size +// patch_info.y - ocean texture unified resolution +// scale_fac.x - choppines +// scale_fac.y - altitude scale +kernel void normals( int2 patch_info, float2 scale_fac, read_only image2d_t noise, + read_only image2d_t src, write_only image2d_t dst ) +{ + int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); + float2 fuv = convert_float2(uv) / patch_info.y; + + float texel = 1.f / patch_info.y; + + float dz_c = read_imagef(src, sampler, fuv).g; + float dz_cr = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y)).g; + float dz_ct = read_imagef(src, sampler, (float2)(fuv.x, fuv.y + texel)).g; + float dz_cl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y)).g; + float dz_cb = read_imagef(src, sampler, (float2)(fuv.x, fuv.y - texel)).g; + float dz_tr = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y + texel)).g; + float dz_br = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y - texel)).g; + float dz_tl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y + texel)).g; + float dz_bl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y - texel)).g; + + float3 normal = (float3)(0.f, 0.f, 1.f / normal_scale_fac); + normal.y = dz_c + 2.f * dz_cb + dz_br - dz_tl - 2.f * dz_ct - dz_tr; + normal.x = dz_c + 2.f * dz_cl + dz_tl - dz_br - 2.f * dz_cr - dz_tr; + + float4 n = read_imagef(noise, sampler, fuv*(float2)(4.0)); + + write_imagef(dst, uv, (float4)(normalize(normal), n[(uv.x+uv.y)%4])); +} diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp new file mode 100755 index 00000000..4cf954f3 --- /dev/null +++ b/samples/vulkan/ocean/ocean.cpp @@ -0,0 +1,2733 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// The code in this sample was derived from several samples in the Vulkan +// Tutorial: https://vulkan-tutorial.com +// +// The code samples in the Vulkan Tutorial are licensed as CC0 1.0 Universal. + +#include +#if !defined(cl_khr_external_memory) +#error cl_khr_external_memory not found, please update your OpenCL headers! +#endif + +#ifdef _WIN32 +#define VK_USE_PLATFORM_WIN32_KHR +#endif + +#include +#include +#include +#include + +#include + +// GLM includes +#include +#include + +#include "ocean.hpp" + +void OceanApplication::run() +{ + init_window(); + init_openCL(); + init_vulkan(); + init_openCL_mems(); + main_loop(); + cleanup(); +} + +void OceanApplication::init_window() +{ + if (!glfwInit()) + { + throw std::runtime_error("failed to initialize glfw!"); + } + + glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); + glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); + + window = glfwCreateWindow( + (int)app_opts.window_width, (int)app_opts.window_height, + "Ocean surface simulation with OpenCL and Vulkan", nullptr, nullptr); + glfwSetWindowUserPointer(window, this); +} + +void OceanApplication::init_openCL() +{ + std::vector platforms; + cl::Platform::get(&platforms); + + printf("Running on platform: %s\n", + platforms[dev_opts.triplet.plat_index] + .getInfo() + .c_str()); + std::vector devices; + platforms[dev_opts.triplet.plat_index].getDevices(CL_DEVICE_TYPE_ALL, + &devices); + + printf( + "Running on device: %s\n", + devices[dev_opts.triplet.dev_index].getInfo().c_str()); + + check_openCL_ext_mem_support(devices[dev_opts.triplet.dev_index]); + + if (app_opts.useExternalMemory) + { + clEnqueueAcquireExternalMemObjectsKHR = + (clEnqueueAcquireExternalMemObjectsKHR_fn) + clGetExtensionFunctionAddressForPlatform( + platforms[dev_opts.triplet.plat_index](), + "clEnqueueAcquireExternalMemObjectsKHR"); + clEnqueueReleaseExternalMemObjectsKHR = + (clEnqueueReleaseExternalMemObjectsKHR_fn) + clGetExtensionFunctionAddressForPlatform( + platforms[dev_opts.triplet.plat_index](), + "clEnqueueReleaseExternalMemObjectsKHR"); + if (clEnqueueAcquireExternalMemObjectsKHR == NULL + || clEnqueueReleaseExternalMemObjectsKHR == NULL) + { + throw std::runtime_error("couldn't get function pointers for " + "cl_khr_external_memory"); + } + } + + int error = CL_SUCCESS; + error |= clGetDeviceInfo( + devices[dev_opts.triplet.dev_index](), CL_DEVICE_IMAGE2D_MAX_WIDTH, + sizeof(ocl_max_img2d_width), &ocl_max_img2d_width, NULL); + error |= clGetDeviceInfo( + devices[dev_opts.triplet.dev_index](), CL_DEVICE_MAX_MEM_ALLOC_SIZE, + sizeof(ocl_max_alloc_size), &ocl_max_alloc_size, NULL); + error |= clGetDeviceInfo(devices[dev_opts.triplet.dev_index](), + CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(ocl_mem_size), + &ocl_mem_size, NULL); + + if (error != CL_SUCCESS) printf("clGetDeviceInfo error: %d\n", error); + + context = cl::Context{ devices[dev_opts.triplet.dev_index] }; + command_queue = + cl::CommandQueue{ context, devices[dev_opts.triplet.dev_index] }; + + auto build_opencl_kernel = [&](const char* src_file, cl::Kernel& kernel, + const char* name) { + try + { + std::string kernel_code = read_file(src_file).data(); + cl::Program program{ context, kernel_code }; + program.build(); + kernel = cl::Kernel{ program, name }; + } catch (const cl::BuildError& e) + { + auto bl = e.getBuildLog(); + std::cout << "Build OpenCL " << name + << " kernel error: " << std::endl; + for (auto elem : bl) std::cout << elem.second << std::endl; + exit(1); + } + }; + + build_opencl_kernel("twiddle.cl", twiddle_kernel, "generate"); + build_opencl_kernel("init_spectrum.cl", init_spectrum_kernel, + "init_spectrum"); + build_opencl_kernel("time_spectrum.cl", time_spectrum_kernel, "spectrum"); + build_opencl_kernel("fft_kernel.cl", fft_kernel, "fft_1D"); + build_opencl_kernel("inversion.cl", inversion_kernel, "inversion"); + build_opencl_kernel("normals.cl", normals_kernel, "normals"); +} + +void OceanApplication::init_openCL_mems() +{ + // init opencl resources + try + { + { + std::vector phase_array(ocean_tex_size * ocean_tex_size); + std::random_device dev; + std::mt19937 rng(dev()); + std::uniform_real_distribution dist(0.f, 1.f); + + for (size_t i = 0; i < phase_array.size(); ++i) + phase_array[i] = { dist(rng), dist(rng), dist(rng), dist(rng) }; + + noise_mem = std::make_unique( + context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, + cl::ImageFormat(CL_RGBA, CL_FLOAT), ocean_tex_size, + ocean_tex_size, 0, phase_array.data()); + } + + + hkt_pong_mem = std::make_unique( + context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RG, CL_FLOAT), + ocean_tex_size, ocean_tex_size); + + dxyz_coef_mem[0] = std::make_unique( + context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RG, CL_FLOAT), + ocean_tex_size, ocean_tex_size); + + dxyz_coef_mem[1] = std::make_unique( + context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RG, CL_FLOAT), + ocean_tex_size, ocean_tex_size); + + dxyz_coef_mem[2] = std::make_unique( + context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RG, CL_FLOAT), + ocean_tex_size, ocean_tex_size); + + h0k_mem = std::make_unique( + context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RGBA, CL_FLOAT), + ocean_tex_size, ocean_tex_size); + + int log_2_N = log((float)ocean_tex_size) / log(2.f); + + twiddle_factors_mem = std::make_unique( + context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RGBA, CL_FLOAT), + log_2_N, ocean_tex_size); + + + for (size_t target = 0; target < IOPT_COUNT; target++) + { + ocl_image_mems[target].resize(swap_chain_images.size()); + + for (size_t i = 0; i < swap_chain_images.size(); i++) + { + if (app_opts.useExternalMemory) + { +#ifdef _WIN32 + HANDLE handle = NULL; + VkMemoryGetWin32HandleInfoKHR getWin32HandleInfo{}; + getWin32HandleInfo.sType = + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; + getWin32HandleInfo.memory = + textureImages[target].imageMemories[i]; + getWin32HandleInfo.handleType = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT; + vkGetMemoryWin32HandleKHR(device, &getWin32HandleInfo, + &handle); + + const cl_mem_properties props[] = { + externalMemType, + (cl_mem_properties)handle, + 0, + }; +#elif defined(__linux__) + int fd = 0; + VkMemoryGetFdInfoKHR getFdInfo{}; + getFdInfo.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR; + getFdInfo.memory = + texture_images[target] + .image_memories[i]; // textureImageMemories[i]; + getFdInfo.handleType = external_mem_type + == CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR + ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT + : VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; + vkGetMemoryFdKHR(device, &getFdInfo, &fd); + + const cl_mem_properties props[] = { + external_mem_type, + (cl_mem_properties)fd, + 0, + }; +#else + const cl_mem_properties* props = NULL; +#endif + + cl_image_format format{}; + format.image_channel_order = CL_RGBA; + format.image_channel_data_type = CL_FLOAT; + + cl_image_desc desc{}; + desc.image_type = CL_MEM_OBJECT_IMAGE2D; + desc.image_width = ocean_tex_size; + desc.image_height = ocean_tex_size; + + ocl_image_mems[target][i].reset(new cl::Image2D{ + clCreateImageWithProperties(context(), props, + CL_MEM_READ_WRITE, &format, + &desc, NULL, NULL) }); + } + else + { + ocl_image_mems[target][i].reset( + new cl::Image2D{ context, CL_MEM_READ_WRITE, + cl::ImageFormat{ CL_RGBA, CL_FLOAT }, + ocean_tex_size, ocean_tex_size }); + } + } + } + } catch (const cl::Error& e) + { + printf("initOpenCLMems: OpenCL %s image error: %s\n", e.what(), + IGetErrorString(e.err())); + exit(1); + } +} + +void OceanApplication::init_vulkan() +{ + create_instance(); + setup_dbg_msger(); + create_surface(); + pick_physical_device(); + create_logical_device(); + create_swap_chain(); + create_swap_chain_image_views(); + create_render_pass(); + create_uniform_buffer(); + create_descriptor_det_layout(); + create_graphics_pipeline(); + create_command_pool(); + + create_depth_resources(); + create_vertex_buffers(); + create_index_buffers(); + + create_framebuffers(); + create_texture_images(); + create_texture_image_views(); + create_texture_sampler(); + create_descriptor_pool(); + create_descriptor_sets(); + create_command_buffers(); + create_sync_objects(); +} + +void OceanApplication::keyboard(int key, int scancode, int action, int mods) +{ + if (action == GLFW_PRESS || action == GLFW_REPEAT) + { + switch (key) + { + case GLFW_KEY_ESCAPE: + glfwSetWindowShouldClose(window, GLFW_TRUE); + break; + case GLFW_KEY_SPACE: + animate = !animate; + printf("animation is %s\n", animate ? "ON" : "OFF"); + break; + + case GLFW_KEY_A: + wind_magnitude += 1.f; + changed = true; + break; + case GLFW_KEY_Z: + wind_magnitude -= 1.f; + changed = true; + break; + + case GLFW_KEY_S: + wind_angle += 1.f; + changed = true; + break; + case GLFW_KEY_X: + wind_angle -= 1.f; + changed = true; + break; + + case GLFW_KEY_D: + amplitude += 0.5f; + changed = true; + break; + case GLFW_KEY_C: + amplitude -= 0.5f; + changed = true; + break; + + case GLFW_KEY_F: choppiness += 0.5f; break; + case GLFW_KEY_V: choppiness -= 0.5f; break; + + case GLFW_KEY_G: alt_scale += 0.5f; break; + case GLFW_KEY_B: alt_scale -= 0.5f; break; + + case GLFW_KEY_W: + wireframe_mode = !wireframe_mode; + create_command_buffers(); + break; + } + } +} + +void OceanApplication::mouse_event(int button, int action, int mods) +{ + double x, y; + glfwGetCursorPos(window, &x, &y); + switch (action) + { + case 0: + // Button Up + camera.drag = false; + break; + case 1: + // Button Down + camera.drag = true; + camera.begin = glm::vec2(x, y); + break; + default: break; + } +} + +void OceanApplication::mouse_pos(double pX, double pY) +{ + if (!camera.drag) return; + + glm::vec2 off = camera.begin - glm::vec2(pX, pY); + camera.begin = glm::vec2(pX, pY); + + camera.yaw -= off.x * DRAG_SPEED_FAC; + camera.pitch += off.y * DRAG_SPEED_FAC; + + glm::quat yaw(glm::cos(glm::radians(camera.yaw / 2)), + glm::vec3(0, 0, 1) * glm::sin(glm::radians(camera.yaw / 2))); + glm::quat pitch(glm::cos(glm::radians(camera.pitch / 2)), + glm::vec3(1, 0, 0) + * glm::sin(glm::radians(camera.pitch / 2))); + glm::mat3 rot_mat(yaw * pitch); + glm::vec3 dir = rot_mat * glm::vec3(0, 0, -1); + + camera.dir = glm::normalize(dir); + camera.rvec = glm::normalize(glm::cross(camera.dir, glm::vec3(0, 0, 1))); + camera.up = glm::normalize(glm::cross(camera.rvec, camera.dir)); +} + +void OceanApplication::mouse_roll(double offset_x, double offset_y) +{ + camera.eye += camera.dir * (float)offset_y * ROLL_SPEED_FAC; +} + +void OceanApplication::cleanup() +{ + vkDestroyImageView(device, depth_image_view, nullptr); + vkDestroyImage(device, depth_image, nullptr); + vkFreeMemory(device, depth_image_memory, nullptr); + + for (auto framebuffer : swap_chain_framebuffers) + { + vkDestroyFramebuffer(device, framebuffer, nullptr); + } + + vkDestroyPipeline(device, graphics_pipeline, nullptr); + vkDestroyPipeline(device, wireframe_pipeline, nullptr); + vkDestroyPipelineLayout(device, pipeline_layout, nullptr); + vkDestroyRenderPass(device, render_pass, nullptr); + + for (auto imageView : swap_chain_image_views) + { + vkDestroyImageView(device, imageView, nullptr); + } + + vkDestroySwapchainKHR(device, swap_chain, nullptr); + vkDestroyDescriptorPool(device, descriptor_pool, nullptr); + + vkDestroyBuffer(device, staging_tex_buffer, nullptr); + vkFreeMemory(device, staging_tex_buffer_memory, nullptr); + + for (size_t img_num = 0; img_num < texture_images.size(); img_num++) + { + for (auto textureImageView : texture_images[img_num].image_views) + { + vkDestroyImageView(device, textureImageView, nullptr); + } + for (auto textureImage : texture_images[img_num].images) + { + vkDestroyImage(device, textureImage, nullptr); + } + for (auto textureImageMemory : texture_images[img_num].image_memories) + { + vkFreeMemory(device, textureImageMemory, nullptr); + } + } + + for (size_t sampler_num = 0; sampler_num < texture_sampler.size(); + sampler_num++) + { + vkDestroySampler(device, texture_sampler[sampler_num], nullptr); + } + + // cleanup vertices buffers + for (auto& buffer : vertex_buffers) + { + vkDestroyBuffer(device, buffer, nullptr); + } + + for (auto& bufferMemory : vertex_buffer_memories) + { + vkFreeMemory(device, bufferMemory, nullptr); + } + + // cleanup indices buffers + for (auto& ind_buffer : index_buffers) + { + for (auto buffer : ind_buffer.buffers) + { + vkDestroyBuffer(device, buffer, nullptr); + } + } + + for (auto& ind_buffer : index_buffers) + { + for (auto& bufferMemory : ind_buffer.buffer_memories) + { + vkFreeMemory(device, bufferMemory, nullptr); + } + } + + for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) + { + vkDestroySemaphore(device, render_finished_semaphores[i], nullptr); + vkDestroySemaphore(device, image_available_semaphores[i], nullptr); + vkDestroyFence(device, in_flight_fences[i], nullptr); + } + + for (auto& unif_buffer : uniform_buffers) + { + vkDestroyBuffer(device, unif_buffer, nullptr); + } + + for (auto& unif_buf_mem : uniform_buffers_memory) + { + vkFreeMemory(device, unif_buf_mem, nullptr); + } + + vkDestroyDescriptorSetLayout(device, descriptor_set_layout, nullptr); + + vkDestroyCommandPool(device, command_pool, nullptr); + + vkDestroyDevice(device, nullptr); + + if (enableValidationLayers) + { + DestroyDebugUtilsMessengerEXT(instance, debug_messenger, nullptr); + } + + vkDestroySurfaceKHR(instance, surface, nullptr); + vkDestroyInstance(instance, nullptr); + + glfwDestroyWindow(window); + + glfwTerminate(); +} + +void OceanApplication::create_instance() +{ + if (enableValidationLayers && !check_validation_layer_support()) + { + throw std::runtime_error( + "validation layers requested, but not available!"); + } + + VkApplicationInfo appInfo{}; + appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + appInfo.pApplicationName = + "Ocean Surface Simulation with OpenCL+Vulkan Sample"; + appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); + appInfo.pEngineName = "No Engine"; + appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); + if (app_opts.useExternalMemory) + { + appInfo.apiVersion = VK_API_VERSION_1_1; + } + else + { + appInfo.apiVersion = VK_API_VERSION_1_0; + } + + VkInstanceCreateInfo createInfo{}; + createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + createInfo.pApplicationInfo = &appInfo; + + auto extensions = get_required_exts(); + createInfo.enabledExtensionCount = static_cast(extensions.size()); + createInfo.ppEnabledExtensionNames = extensions.data(); + + VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{}; + if (enableValidationLayers) + { + createInfo.enabledLayerCount = + static_cast(validationLayers.size()); + createInfo.ppEnabledLayerNames = validationLayers.data(); + + populate_dbg_msger_create_info(debugCreateInfo); + createInfo.pNext = + (VkDebugUtilsMessengerCreateInfoEXT*)&debugCreateInfo; + } + else + { + createInfo.enabledLayerCount = 0; + + createInfo.pNext = nullptr; + } + + if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) + { + throw std::runtime_error("failed to create instance!"); + } + +#ifdef _WIN32 + if (app_opps.useExternalMemory) + { + vkGetMemoryWin32HandleKHR = + (PFN_vkGetMemoryWin32HandleKHR)vkGetInstanceProcAddr( + instance, "vkGetMemoryWin32HandleKHR"); + if (vkGetMemoryWin32HandleKHR == NULL) + { + throw std::runtime_error("couldn't get function pointer for " + "vkGetMemoryWin32HandleKHR"); + } + } +#elif defined(__linux__) + if (app_opts.useExternalMemory) + { + vkGetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)vkGetInstanceProcAddr( + instance, "vkGetMemoryFdKHR"); + if (vkGetMemoryFdKHR == NULL) + { + throw std::runtime_error( + "couldn't get function pointer for vkGetMemoryFdKHR"); + } + } +#endif +} + +void OceanApplication::populate_dbg_msger_create_info( + VkDebugUtilsMessengerCreateInfoEXT& createInfo) +{ + createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; + createInfo.pfnUserCallback = debug_callback; +} + +void OceanApplication::setup_dbg_msger() +{ + if (!enableValidationLayers) return; + + VkDebugUtilsMessengerCreateInfoEXT createInfo; + populate_dbg_msger_create_info(createInfo); + + if (CreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, + &debug_messenger) + != VK_SUCCESS) + { + throw std::runtime_error("failed to set up debug messenger!"); + } +} + +void OceanApplication::create_surface() +{ + if (glfwCreateWindowSurface(instance, window, nullptr, &surface) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create window surface!"); + } +} + +void OceanApplication::pick_physical_device() +{ + uint32_t deviceCount = 0; + vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr); + + if (deviceCount == 0) + { + throw std::runtime_error("failed to find GPUs with Vulkan support!"); + } + + std::vector devices(deviceCount); + vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data()); + + for (const auto& device : devices) + { + if (is_device_suitable(device)) + { + physical_device = device; + break; + } + } + + if (physical_device == VK_NULL_HANDLE) + { + throw std::runtime_error("failed to find a suitable GPU!"); + } + + VkPhysicalDeviceProperties properties{}; + vkGetPhysicalDeviceProperties(physical_device, &properties); + + printf("Running on Vulkan physical device: %s\n", properties.deviceName); +} + +void OceanApplication::create_logical_device() +{ + QueueFamilyIndices indices = find_queue_families(physical_device); + + std::vector queueCreateInfos; + std::set uniqueQueueFamilies = { indices.graphicsFamily, + indices.presentFamily }; + + float queuePriority = 1.0f; + for (uint32_t queueFamily : uniqueQueueFamilies) + { + VkDeviceQueueCreateInfo queueCreateInfo{}; + queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queueCreateInfo.queueFamilyIndex = queueFamily; + queueCreateInfo.queueCount = 1; + queueCreateInfo.pQueuePriorities = &queuePriority; + queueCreateInfos.push_back(queueCreateInfo); + } + + VkPhysicalDeviceFeatures deviceFeatures{}; + deviceFeatures.fillModeNonSolid = true; + + VkDeviceCreateInfo createInfo{}; + createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + + createInfo.queueCreateInfoCount = + static_cast(queueCreateInfos.size()); + createInfo.pQueueCreateInfos = queueCreateInfos.data(); + + createInfo.pEnabledFeatures = &deviceFeatures; + + auto extensions = get_required_dev_exts(); + createInfo.enabledExtensionCount = static_cast(extensions.size()); + createInfo.ppEnabledExtensionNames = extensions.data(); + + if (enableValidationLayers) + { + createInfo.enabledLayerCount = + static_cast(validationLayers.size()); + createInfo.ppEnabledLayerNames = validationLayers.data(); + } + else + { + createInfo.enabledLayerCount = 0; + } + + if (vkCreateDevice(physical_device, &createInfo, nullptr, &device) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create logical device!"); + } + + vkGetDeviceQueue(device, indices.graphicsFamily, 0, &graphics_queue); + vkGetDeviceQueue(device, indices.presentFamily, 0, &present_queue); +} + +void OceanApplication::create_swap_chain() +{ + SwapChainSupportDetails swapChainSupport = + query_swap_chain_support(physical_device); + + VkSurfaceFormatKHR surfaceFormat = + choose_swap_surf_format(swapChainSupport.formats); + VkPresentModeKHR presentMode = + choose_swap_present_mode(swapChainSupport.presentModes); + VkExtent2D extent = choose_swap_extent(swapChainSupport.capabilities); + + uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1; + if (swapChainSupport.capabilities.maxImageCount > 0 + && imageCount > swapChainSupport.capabilities.maxImageCount) + { + imageCount = swapChainSupport.capabilities.maxImageCount; + } + + VkSwapchainCreateInfoKHR createInfo{}; + createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + createInfo.surface = surface; + + createInfo.minImageCount = imageCount; + createInfo.imageFormat = surfaceFormat.format; + createInfo.imageColorSpace = surfaceFormat.colorSpace; + createInfo.imageExtent = extent; + createInfo.imageArrayLayers = 1; + createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + + QueueFamilyIndices indices = find_queue_families(physical_device); + uint32_t queueFamilyIndices[] = { indices.graphicsFamily, + indices.presentFamily }; + + if (indices.graphicsFamily != indices.presentFamily) + { + createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; + createInfo.queueFamilyIndexCount = 2; + createInfo.pQueueFamilyIndices = queueFamilyIndices; + } + else + { + createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; + } + + createInfo.preTransform = swapChainSupport.capabilities.currentTransform; + createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; + createInfo.presentMode = presentMode; + createInfo.clipped = VK_TRUE; + + createInfo.oldSwapchain = VK_NULL_HANDLE; + + if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swap_chain) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create swap chain!"); + } + + vkGetSwapchainImagesKHR(device, swap_chain, &imageCount, nullptr); + swap_chain_images.resize(imageCount); + vkGetSwapchainImagesKHR(device, swap_chain, &imageCount, + swap_chain_images.data()); + + swap_chain_image_format = surfaceFormat.format; + swap_chain_extent = extent; +} + +void OceanApplication::create_swap_chain_image_views() +{ + swap_chain_image_views.resize(swap_chain_images.size()); + + for (uint32_t i = 0; i < swap_chain_images.size(); i++) + { + swap_chain_image_views[i] = + create_image_view(swap_chain_images[i], swap_chain_image_format, + VK_IMAGE_ASPECT_COLOR_BIT); + } +} + +void OceanApplication::create_render_pass() +{ + VkAttachmentDescription colorAttachment{}; + colorAttachment.format = swap_chain_image_format; + colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT; + colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; + colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + + VkAttachmentDescription depthAttachment{}; + depthAttachment.format = find_depth_format(); + depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT; + depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + depthAttachment.finalLayout = + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + VkAttachmentReference colorAttachmentRef{}; + colorAttachmentRef.attachment = 0; + colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + + VkAttachmentReference depthAttachmentRef{}; + depthAttachmentRef.attachment = 1; + depthAttachmentRef.layout = + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + VkSubpassDescription subpass{}; + subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + subpass.colorAttachmentCount = 1; + subpass.pColorAttachments = &colorAttachmentRef; + subpass.pDepthStencilAttachment = &depthAttachmentRef; + + VkSubpassDependency dependency{}; + dependency.srcSubpass = VK_SUBPASS_EXTERNAL; + dependency.dstSubpass = 0; + dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT + | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; + dependency.srcAccessMask = 0; + dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT + | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; + dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT + | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + + std::array attachments = { colorAttachment, + depthAttachment }; + VkRenderPassCreateInfo renderPassInfo{}; + renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + renderPassInfo.attachmentCount = static_cast(attachments.size()); + renderPassInfo.pAttachments = attachments.data(); + renderPassInfo.subpassCount = 1; + renderPassInfo.pSubpasses = &subpass; + renderPassInfo.dependencyCount = 1; + renderPassInfo.pDependencies = &dependency; + + if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &render_pass) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create render pass!"); + } +} + +void OceanApplication::create_uniform_buffer() +{ + VkDeviceSize bufferSize = sizeof(UniformBufferObject); + + uniform_buffers.resize(swap_chain_images.size()); + uniform_buffers_memory.resize(swap_chain_images.size()); + + for (size_t i = 0; i < uniform_buffers.size(); i++) + { + create_buffer(bufferSize, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT + | VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, uniform_buffers[i], + uniform_buffers_memory[i]); + } +} + +void OceanApplication::create_descriptor_det_layout() +{ + VkDescriptorSetLayoutBinding sampler0LayoutBinding{}; + sampler0LayoutBinding.binding = 0; + sampler0LayoutBinding.descriptorCount = 1; + sampler0LayoutBinding.descriptorType = + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + sampler0LayoutBinding.pImmutableSamplers = nullptr; + sampler0LayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + + VkDescriptorSetLayoutBinding sampler1LayoutBinding{}; + sampler1LayoutBinding.binding = 1; + sampler1LayoutBinding.descriptorCount = 1; + sampler1LayoutBinding.descriptorType = + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + sampler1LayoutBinding.pImmutableSamplers = nullptr; + sampler1LayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + + VkDescriptorSetLayoutBinding uniformLayoutBinding{}; + uniformLayoutBinding.binding = 2; + uniformLayoutBinding.descriptorCount = 1; + uniformLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + uniformLayoutBinding.pImmutableSamplers = nullptr; + uniformLayoutBinding.stageFlags = + VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; + + std::array bindings = { + sampler0LayoutBinding, sampler1LayoutBinding, uniformLayoutBinding + }; + + VkDescriptorSetLayoutCreateInfo layoutInfo{}; + layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + layoutInfo.bindingCount = static_cast(bindings.size()); + layoutInfo.pBindings = bindings.data(); + + if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, + &descriptor_set_layout) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create descriptor set layout!"); + } +} + +void OceanApplication::create_graphics_pipeline() +{ + auto vertShaderCode = read_file("ocean.vert.spv"); + auto fragShaderCode = read_file("ocean.frag.spv"); + + VkShaderModule vertShaderModule = create_shader_module(vertShaderCode); + VkShaderModule fragShaderModule = create_shader_module(fragShaderCode); + + VkPipelineShaderStageCreateInfo vertShaderStageInfo{}; + vertShaderStageInfo.sType = + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT; + vertShaderStageInfo.module = vertShaderModule; + vertShaderStageInfo.pName = "main"; + + VkPipelineShaderStageCreateInfo fragShaderStageInfo{}; + fragShaderStageInfo.sType = + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + fragShaderStageInfo.module = fragShaderModule; + fragShaderStageInfo.pName = "main"; + + VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, + fragShaderStageInfo }; + + // vertex info + auto bindingDescription = Vertex::getBindingDescription(); + auto attributeDescriptions = Vertex::getAttributeDescriptions(); + + VkPipelineVertexInputStateCreateInfo vertexInputInfo{}; + vertexInputInfo.sType = + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + vertexInputInfo.vertexBindingDescriptionCount = 1; + vertexInputInfo.vertexAttributeDescriptionCount = + static_cast(attributeDescriptions.size()); + vertexInputInfo.pVertexBindingDescriptions = &bindingDescription; + vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data(); + + VkPipelineInputAssemblyStateCreateInfo inputAssembly{}; + inputAssembly.sType = + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + inputAssembly.primitiveRestartEnable = VK_FALSE; + + VkViewport viewport{}; + viewport.x = 0.0f; + viewport.y = 0.0f; + viewport.width = (float)swap_chain_extent.width; + viewport.height = (float)swap_chain_extent.height; + viewport.minDepth = 0.0f; + viewport.maxDepth = 1.0f; + + VkRect2D scissor{}; + scissor.offset = { 0, 0 }; + scissor.extent = swap_chain_extent; + + VkPipelineViewportStateCreateInfo viewportState{}; + viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + viewportState.viewportCount = 1; + viewportState.pViewports = &viewport; + viewportState.scissorCount = 1; + viewportState.pScissors = &scissor; + + VkPipelineRasterizationStateCreateInfo rasterizer{}; + rasterizer.sType = + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterizer.depthClampEnable = VK_FALSE; + rasterizer.rasterizerDiscardEnable = VK_FALSE; + rasterizer.polygonMode = VK_POLYGON_MODE_FILL; + rasterizer.lineWidth = 1.0f; + rasterizer.cullMode = VK_CULL_MODE_BACK_BIT; + rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE; + rasterizer.depthBiasEnable = VK_FALSE; + + VkPipelineMultisampleStateCreateInfo multisampling{}; + multisampling.sType = + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisampling.sampleShadingEnable = VK_FALSE; + multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + + VkPipelineDepthStencilStateCreateInfo depthStencil{}; + depthStencil.sType = + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depthStencil.depthTestEnable = VK_TRUE; + depthStencil.depthWriteEnable = VK_TRUE; + depthStencil.depthCompareOp = VK_COMPARE_OP_LESS; + depthStencil.depthBoundsTestEnable = VK_FALSE; + depthStencil.stencilTestEnable = VK_FALSE; + + VkPipelineColorBlendAttachmentState colorBlendAttachment{}; + colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT + | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT + | VK_COLOR_COMPONENT_A_BIT; + colorBlendAttachment.blendEnable = VK_FALSE; + + VkPipelineColorBlendStateCreateInfo colorBlending{}; + colorBlending.sType = + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + colorBlending.logicOpEnable = VK_FALSE; + colorBlending.logicOp = VK_LOGIC_OP_COPY; + colorBlending.attachmentCount = 1; + colorBlending.pAttachments = &colorBlendAttachment; + colorBlending.blendConstants[0] = 0.0f; + colorBlending.blendConstants[1] = 0.0f; + colorBlending.blendConstants[2] = 0.0f; + colorBlending.blendConstants[3] = 0.0f; + + VkPipelineLayoutCreateInfo pipelineLayoutInfo{}; + pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + pipelineLayoutInfo.setLayoutCount = 1; + pipelineLayoutInfo.pSetLayouts = &descriptor_set_layout; + + if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, + &pipeline_layout) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create pipeline layout!"); + } + + VkGraphicsPipelineCreateInfo pipelineInfo{}; + pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + pipelineInfo.stageCount = 2; + pipelineInfo.pStages = shaderStages; + pipelineInfo.pVertexInputState = &vertexInputInfo; + pipelineInfo.pInputAssemblyState = &inputAssembly; + pipelineInfo.pViewportState = &viewportState; + pipelineInfo.pRasterizationState = &rasterizer; + pipelineInfo.pMultisampleState = &multisampling; + pipelineInfo.pDepthStencilState = &depthStencil; + pipelineInfo.pColorBlendState = &colorBlending; + pipelineInfo.layout = pipeline_layout; + pipelineInfo.renderPass = render_pass; + pipelineInfo.subpass = 0; + pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + + if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, + nullptr, &graphics_pipeline) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create graphics pipeline!"); + } + + rasterizer.polygonMode = VK_POLYGON_MODE_LINE; + if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, + nullptr, &wireframe_pipeline) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create graphics pipeline!"); + } + + vkDestroyShaderModule(device, fragShaderModule, nullptr); + vkDestroyShaderModule(device, vertShaderModule, nullptr); +} + +void OceanApplication::create_framebuffers() +{ + swap_chain_framebuffers.resize(swap_chain_image_views.size()); + + for (size_t i = 0; i < swap_chain_image_views.size(); i++) + { + std::array attachments = { swap_chain_image_views[i], + depth_image_view }; + + VkFramebufferCreateInfo framebufferInfo{}; + framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + framebufferInfo.renderPass = render_pass; + framebufferInfo.attachmentCount = + static_cast(attachments.size()); + framebufferInfo.pAttachments = attachments.data(); + framebufferInfo.width = swap_chain_extent.width; + framebufferInfo.height = swap_chain_extent.height; + framebufferInfo.layers = 1; + + if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, + &swap_chain_framebuffers[i]) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create framebuffer!"); + } + } +} + +void OceanApplication::create_command_pool() +{ + QueueFamilyIndices queueFamilyIndices = + find_queue_families(physical_device); + + VkCommandPoolCreateInfo poolInfo{}; + poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily; + + if (vkCreateCommandPool(device, &poolInfo, nullptr, &command_pool) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create command pool!"); + } +} + +void OceanApplication::create_vertex_buffers() +{ + int iCXY = (ocean_grid_size + 1) * (ocean_grid_size + 1); + ocean_grid_vertices.resize(iCXY); + + cl_float dfY = -0.5 * (ocean_grid_size * mesh_spacing), + dfBaseX = -0.5 * (ocean_grid_size * mesh_spacing); + cl_float tx = 0.f, ty = 0.f, dtx = 1.f / ocean_grid_size, + dty = 1.f / ocean_grid_size; + for (int iBase = 0, iY = 0; iY <= ocean_grid_size; + iY++, iBase += ocean_grid_size + 1) + { + tx = 0.f; + double dfX = dfBaseX; + for (int iX = 0; iX <= ocean_grid_size; iX++) + { + ocean_grid_vertices[iBase + iX].pos = glm::vec3(dfX, dfY, 0.0); + ocean_grid_vertices[iBase + iX].tc = glm::vec2(tx, ty); + tx += dtx; + dfX += mesh_spacing; + } + dfY += mesh_spacing; + ty += dty; + } + + vertex_buffers.resize(swap_chain_images.size()); + vertex_buffer_memories.resize(swap_chain_images.size()); + + VkDeviceSize bufferSize = + sizeof(ocean_grid_vertices[0]) * ocean_grid_vertices.size(); + + VkBuffer stagingBuffer; + VkDeviceMemory stagingBufferMemory; + create_buffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + stagingBuffer, stagingBufferMemory); + + void* data; + vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data); + memcpy(data, ocean_grid_vertices.data(), (size_t)bufferSize); + vkUnmapMemory(device, stagingBufferMemory); + + for (size_t i = 0; i < swap_chain_images.size(); i++) + { + + // create local memory buffer + create_buffer(bufferSize, + VK_BUFFER_USAGE_TRANSFER_DST_BIT + | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vertex_buffers[i], + vertex_buffer_memories[i]); + + copy_buffer(stagingBuffer, vertex_buffers[i], bufferSize); + } + + vkDestroyBuffer(device, stagingBuffer, nullptr); + vkFreeMemory(device, stagingBufferMemory, nullptr); +} + +void OceanApplication::create_index_buffers() +{ + index_buffers.resize(ocean_grid_size); + // Add Tri Strip primitve sets + ocean_grid_indices.resize((ocean_grid_size + 1) * 2); + + VkDeviceSize bufferSize = + sizeof(ocean_grid_indices[0]) * ocean_grid_indices.size(); + + VkBuffer stagingBuffer; + VkDeviceMemory stagingBufferMemory; + create_buffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + stagingBuffer, stagingBufferMemory); + + // Each tri strip draws one row of NX quads + for (int iBaseTo, iBaseFrom = 0, iY = 0; iY < ocean_grid_size; + iY++, iBaseFrom = iBaseTo) + { + iBaseTo = iBaseFrom + ocean_grid_size + 1; + for (int iX = 0; iX <= ocean_grid_size; iX++) + { + ocean_grid_indices[iX * 2 + 0] = iBaseFrom + iX; + ocean_grid_indices[iX * 2 + 1] = iBaseTo + iX; + } + + index_buffers[iY].buffers.resize(swap_chain_images.size()); + index_buffers[iY].buffer_memories.resize(swap_chain_images.size()); + + void* data; + vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data); + memcpy(data, ocean_grid_indices.data(), (size_t)bufferSize); + vkUnmapMemory(device, stagingBufferMemory); + + for (size_t i = 0; i < swap_chain_images.size(); i++) + { + + // create local memory buffer + create_buffer(bufferSize, + VK_BUFFER_USAGE_TRANSFER_DST_BIT + | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + index_buffers[iY].buffers[i], + index_buffers[iY].buffer_memories[i]); + + copy_buffer(stagingBuffer, index_buffers[iY].buffers[i], + bufferSize); + } + } + vkDestroyBuffer(device, stagingBuffer, nullptr); + vkFreeMemory(device, stagingBufferMemory, nullptr); +} + +void OceanApplication::create_texture_images() +{ + VkImageTiling tiling = app_opts.linearImages ? VK_IMAGE_TILING_LINEAR + : VK_IMAGE_TILING_OPTIMAL; + VkMemoryPropertyFlags properties = + app_opts.deviceLocalImages ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : 0; + + uint32_t texWidth = static_cast(ocean_tex_size); + uint32_t texHeight = static_cast(ocean_tex_size); + + VkDeviceSize imageSize = texWidth * texHeight * 4 * sizeof(float); + + create_buffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + staging_tex_buffer, staging_tex_buffer_memory); + + for (size_t target = 0; target < texture_images.size(); target++) + { + texture_images[target].images.resize(swap_chain_images.size()); + texture_images[target].image_memories.resize(swap_chain_images.size()); + + for (size_t i = 0; i < swap_chain_images.size(); i++) + { + create_shareable_image( + texWidth, texHeight, VK_FORMAT_R32G32B32A32_SFLOAT, tiling, + VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, + properties, texture_images[target].images[i], + texture_images[target].image_memories[i]); + if (app_opts.useExternalMemory) + { + transition_image_layout( + texture_images[target].images[i], + VK_FORMAT_R32G32B32A32_SFLOAT, VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + } + } + } +} + +void OceanApplication::create_texture_image_views() +{ + for (size_t img_num = 0; img_num < texture_images.size(); img_num++) + { + texture_images[img_num].image_views.resize(swap_chain_images.size()); + + for (size_t i = 0; i < swap_chain_images.size(); i++) + { + texture_images[img_num].image_views[i] = create_image_view( + texture_images[img_num].images[i], + VK_FORMAT_R32G32B32A32_SFLOAT, VK_IMAGE_ASPECT_COLOR_BIT); + } + } +} + +void OceanApplication::create_texture_sampler() +{ + VkSamplerCreateInfo samplerInfo{}; + samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + samplerInfo.magFilter = VK_FILTER_LINEAR; + samplerInfo.minFilter = VK_FILTER_LINEAR; + samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK; + samplerInfo.unnormalizedCoordinates = VK_FALSE; + samplerInfo.compareEnable = VK_FALSE; + samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS; + samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST; + + for (size_t sampler_num = 0; sampler_num < texture_sampler.size(); + sampler_num++) + { + if (vkCreateSampler(device, &samplerInfo, nullptr, + &texture_sampler[sampler_num]) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create texture sampler!"); + } + } +} + +VkImageView OceanApplication::create_image_view(VkImage image, VkFormat format, + VkImageAspectFlags aspectFlags) +{ + VkImageViewCreateInfo viewInfo{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO }; + viewInfo.pNext = nullptr; + viewInfo.image = image; + viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; + viewInfo.format = format; + viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + viewInfo.subresourceRange.baseMipLevel = 0; + viewInfo.subresourceRange.levelCount = 1; // VK_REMAINING_MIP_LEVELS; + viewInfo.subresourceRange.baseArrayLayer = 0; + viewInfo.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; + viewInfo.subresourceRange.aspectMask = aspectFlags; + + VkImageView imageView; + if (vkCreateImageView(device, &viewInfo, nullptr, &imageView) != VK_SUCCESS) + { + throw std::runtime_error("failed to create texture image view!"); + } + + return imageView; +} + +void OceanApplication::create_shareable_image( + uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, + VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage& image, + VkDeviceMemory& imageMemory, VkImageType type) +{ + VkExternalMemoryImageCreateInfo externalMemCreateInfo{}; + externalMemCreateInfo.sType = + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + +#ifdef _WIN32 + externalMemCreateInfo.handleTypes = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT; +#elif defined(__linux__) + externalMemCreateInfo.handleTypes = + external_mem_type == CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR + ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT + : VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; +#endif + + VkImageCreateInfo imageInfo{}; + imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + if (app_opts.useExternalMemory) + { + imageInfo.pNext = &externalMemCreateInfo; + } + + imageInfo.imageType = type; + imageInfo.extent.width = width; + imageInfo.extent.height = height; + imageInfo.extent.depth = 1; + imageInfo.mipLevels = 1; + imageInfo.arrayLayers = 1; + imageInfo.format = format; + imageInfo.tiling = tiling; + imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + imageInfo.usage = usage; + imageInfo.samples = VK_SAMPLE_COUNT_1_BIT; + imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + + if (vkCreateImage(device, &imageInfo, nullptr, &image) != VK_SUCCESS) + { + throw std::runtime_error("failed to create image!"); + } + + VkMemoryRequirements memRequirements; + vkGetImageMemoryRequirements(device, image, &memRequirements); + + VkExportMemoryAllocateInfo exportMemoryAllocInfo{}; + exportMemoryAllocInfo.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; + exportMemoryAllocInfo.handleTypes = externalMemCreateInfo.handleTypes; + + VkMemoryAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + if (app_opts.useExternalMemory) + { + allocInfo.pNext = &exportMemoryAllocInfo; + } + allocInfo.allocationSize = memRequirements.size; + allocInfo.memoryTypeIndex = + find_memory_type(memRequirements.memoryTypeBits, properties); + + if (vkAllocateMemory(device, &allocInfo, nullptr, &imageMemory) + != VK_SUCCESS) + { + throw std::runtime_error("failed to allocate image memory!"); + } + + vkBindImageMemory(device, image, imageMemory, 0); +} + +void OceanApplication::create_image(uint32_t width, uint32_t height, + VkFormat format, VkImageTiling tiling, + VkImageUsageFlags usage, + VkMemoryPropertyFlags properties, + VkImage& image, VkDeviceMemory& imageMemory) +{ + VkImageCreateInfo imageInfo{}; + imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + imageInfo.imageType = VK_IMAGE_TYPE_2D; + imageInfo.extent.width = width; + imageInfo.extent.height = height; + imageInfo.extent.depth = 1; + imageInfo.mipLevels = 1; + imageInfo.arrayLayers = 1; + imageInfo.format = format; + imageInfo.tiling = tiling; + imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + imageInfo.usage = usage; + imageInfo.samples = VK_SAMPLE_COUNT_1_BIT; + imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + + if (vkCreateImage(device, &imageInfo, nullptr, &image) != VK_SUCCESS) + { + throw std::runtime_error("failed to create image!"); + } + + VkMemoryRequirements memRequirements; + vkGetImageMemoryRequirements(device, image, &memRequirements); + + VkMemoryAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocInfo.allocationSize = memRequirements.size; + allocInfo.memoryTypeIndex = + find_memory_type(memRequirements.memoryTypeBits, properties); + + if (vkAllocateMemory(device, &allocInfo, nullptr, &imageMemory) + != VK_SUCCESS) + { + throw std::runtime_error("failed to allocate image memory!"); + } + + vkBindImageMemory(device, image, imageMemory, 0); +} + +VkFormat +OceanApplication::find_supported_format(const std::vector& candidates, + VkImageTiling tiling, + VkFormatFeatureFlags features) +{ + for (VkFormat format : candidates) + { + VkFormatProperties props; + vkGetPhysicalDeviceFormatProperties(physical_device, format, &props); + + if (tiling == VK_IMAGE_TILING_LINEAR + && (props.linearTilingFeatures & features) == features) + { + return format; + } + else if (tiling == VK_IMAGE_TILING_OPTIMAL + && (props.optimalTilingFeatures & features) == features) + { + return format; + } + } + + throw std::runtime_error("failed to find supported format!"); +} + +VkFormat OceanApplication::find_depth_format() +{ + return find_supported_format( + { VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, + VK_FORMAT_D24_UNORM_S8_UINT }, + VK_IMAGE_TILING_OPTIMAL, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT); +} + +bool OceanApplication::has_stencil_component(VkFormat format) +{ + return format == VK_FORMAT_D32_SFLOAT_S8_UINT + || format == VK_FORMAT_D24_UNORM_S8_UINT; +} + +void OceanApplication::create_depth_resources() +{ + VkFormat depthFormat = find_depth_format(); + + create_image( + swap_chain_extent.width, swap_chain_extent.height, depthFormat, + VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, depth_image, depth_image_memory); + depth_image_view = + create_image_view(depth_image, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT); +} + +void OceanApplication::transition_image_layout(VkImage image, VkFormat format, + VkImageLayout oldLayout, + VkImageLayout newLayout, + uint32_t layers) +{ + + VkCommandBuffer commandBuffer = begin_single_time_commands(); + + VkImageMemoryBarrier barrier{}; + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.oldLayout = oldLayout; + barrier.newLayout = newLayout; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = image; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = 1; + // vulkan spec: If the calling command’s VkImage parameter is of + // VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and + // layerCount members of imageSubresource must be 0 and 1, + // respectively + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = layers; + + VkPipelineStageFlags sourceStage; + VkPipelineStageFlags destinationStage; + + if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED + && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) + { + barrier.srcAccessMask = 0; + barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + + sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; + destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT; + } + else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL + && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) + { + barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + + sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT; + destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + } + else if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED + && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) + { + barrier.srcAccessMask = 0; + barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + + sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; + destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT /*| + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT*/ + ; + } + else + { + throw std::invalid_argument("unsupported layout transition!"); + } + + vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0, 0, + nullptr, 0, nullptr, 1, &barrier); + + end_single_time_commands(commandBuffer); +} + +void OceanApplication::copy_buffer_to_image(VkBuffer buffer, VkImage image, + uint32_t width, uint32_t height) +{ + VkCommandBuffer commandBuffer = begin_single_time_commands(); + + VkBufferImageCopy region{}; + region.bufferOffset = 0; + region.bufferRowLength = 0; + region.bufferImageHeight = 0; + region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + region.imageSubresource.mipLevel = 0; + region.imageSubresource.baseArrayLayer = 0; + region.imageSubresource.layerCount = 1; + region.imageOffset = { 0, 0, 0 }; + region.imageExtent = { width, height, 1 }; + + vkCmdCopyBufferToImage(commandBuffer, buffer, image, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); + end_single_time_commands(commandBuffer); +} + +void OceanApplication::transition_uniform_layout(VkBuffer buffer, + VkAccessFlagBits src, + VkAccessFlagBits dst) +{ + VkCommandBuffer commandBuffer = begin_single_time_commands(); + + VkDeviceSize bufferSize = sizeof(UniformBufferObject); + VkBufferMemoryBarrier barrier{}; + barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; + barrier.pNext = nullptr; + barrier.srcAccessMask = src; // VK_ACCESS_HOST_WRITE_BIT; + barrier.dstAccessMask = dst; // VK_ACCESS_UNIFORM_READ_BIT; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.buffer = buffer; + barrier.offset = 0; + barrier.size = bufferSize; + + VkPipelineStageFlags sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT; + VkPipelineStageFlags destinationStage = + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + + if (src == VK_ACCESS_SHADER_READ_BIT) + { + sourceStage = + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT /*| + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT*/ + /*| VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR*/; + destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT; + } + + vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0, 0, + nullptr, 1, &barrier, 0, nullptr); + + end_single_time_commands(commandBuffer); +} + +void OceanApplication::create_descriptor_pool() +{ + std::array poolSizes{}; + poolSizes[0].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + poolSizes[0].descriptorCount = + static_cast(swap_chain_images.size()); + + poolSizes[1].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + poolSizes[1].descriptorCount = + static_cast(swap_chain_images.size()); + + VkDescriptorPoolCreateInfo poolInfo{}; + poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + poolInfo.poolSizeCount = static_cast(poolSizes.size()); + poolInfo.pPoolSizes = poolSizes.data(); + poolInfo.maxSets = static_cast(swap_chain_images.size()); + + if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptor_pool) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create descriptor pool!"); + } +} + +void OceanApplication::create_descriptor_sets() +{ + std::vector layouts(swap_chain_images.size(), + descriptor_set_layout); + VkDescriptorSetAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + allocInfo.descriptorPool = descriptor_pool; + allocInfo.descriptorSetCount = + static_cast(swap_chain_images.size()); + allocInfo.pSetLayouts = layouts.data(); + + descriptor_sets.resize(swap_chain_images.size()); + if (vkAllocateDescriptorSets(device, &allocInfo, descriptor_sets.data()) + != VK_SUCCESS) + { + throw std::runtime_error("failed to allocate descriptor sets!"); + } + + for (size_t i = 0; i < swap_chain_images.size(); i++) + { + VkDescriptorImageInfo imageInfo[(size_t)InteropTexType::IOPT_COUNT] = { + 0 + }; + + VkDescriptorBufferInfo bufferInfo{}; + bufferInfo.buffer = uniform_buffers[i]; + bufferInfo.offset = 0; + bufferInfo.range = sizeof(UniformBufferObject); + + std::array descriptorWrites{}; + + for (cl_int target = 0; target < IOPT_COUNT; target++) + { + imageInfo[target].imageLayout = + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + imageInfo[target].imageView = texture_images[target].image_views[i]; + imageInfo[target].sampler = texture_sampler[target]; + + descriptorWrites[target].sType = + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorWrites[target].dstSet = descriptor_sets[i]; + descriptorWrites[target].dstBinding = target; + descriptorWrites[target].dstArrayElement = 0; + descriptorWrites[target].descriptorType = + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptorWrites[target].descriptorCount = 1; + descriptorWrites[target].pImageInfo = &imageInfo[target]; + } + + descriptorWrites[IOPT_COUNT].sType = + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorWrites[IOPT_COUNT].dstSet = descriptor_sets[i]; + descriptorWrites[IOPT_COUNT].dstBinding = IOPT_COUNT; + descriptorWrites[IOPT_COUNT].dstArrayElement = 0; + descriptorWrites[IOPT_COUNT].descriptorType = + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptorWrites[IOPT_COUNT].descriptorCount = 1; + descriptorWrites[IOPT_COUNT].pBufferInfo = &bufferInfo; + + vkUpdateDescriptorSets(device, + static_cast(descriptorWrites.size()), + descriptorWrites.data(), 0, nullptr); + } +} + +void OceanApplication::create_buffer(VkDeviceSize size, + VkBufferUsageFlags usage, + VkMemoryPropertyFlags properties, + VkBuffer& buffer, + VkDeviceMemory& bufferMemory) +{ + VkBufferCreateInfo bufferInfo{}; + bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + bufferInfo.size = size; + bufferInfo.usage = usage; + bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + + if (vkCreateBuffer(device, &bufferInfo, nullptr, &buffer) != VK_SUCCESS) + { + throw std::runtime_error("failed to create buffer!"); + } + + VkMemoryRequirements memRequirements; + vkGetBufferMemoryRequirements(device, buffer, &memRequirements); + + VkMemoryAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocInfo.allocationSize = memRequirements.size; + allocInfo.memoryTypeIndex = + find_memory_type(memRequirements.memoryTypeBits, properties); + + if (vkAllocateMemory(device, &allocInfo, nullptr, &bufferMemory) + != VK_SUCCESS) + { + throw std::runtime_error("failed to allocate buffer memory!"); + } + + vkBindBufferMemory(device, buffer, bufferMemory, 0); +} + +void OceanApplication::copy_buffer(VkBuffer srcBuffer, VkBuffer dstBuffer, + VkDeviceSize size) +{ + VkCommandBufferAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandPool = command_pool; + allocInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer; + vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer); + + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + + vkBeginCommandBuffer(commandBuffer, &beginInfo); + + VkBufferCopy copyRegion{}; + copyRegion.srcOffset = 0; // Optional + copyRegion.dstOffset = 0; // Optional + copyRegion.size = size; + vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©Region); + + vkEndCommandBuffer(commandBuffer); + + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + + vkQueueSubmit(graphics_queue, 1, &submitInfo, VK_NULL_HANDLE); + vkQueueWaitIdle(graphics_queue); + + vkFreeCommandBuffers(device, command_pool, 1, &commandBuffer); +} + +uint32_t OceanApplication::find_memory_type(uint32_t typeFilter, + VkMemoryPropertyFlags properties) +{ + VkPhysicalDeviceMemoryProperties memProperties; + vkGetPhysicalDeviceMemoryProperties(physical_device, &memProperties); + + for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) + { + if ((typeFilter & (1 << i)) + && (memProperties.memoryTypes[i].propertyFlags & properties) + == properties) + { + return i; + } + } + + throw std::runtime_error("failed to find suitable memory type!"); +} + +VkCommandBuffer OceanApplication::begin_single_time_commands() +{ + VkCommandBufferAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandPool = command_pool; + allocInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer; + vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer); + + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + + vkBeginCommandBuffer(commandBuffer, &beginInfo); + + return commandBuffer; +} + +void OceanApplication::end_single_time_commands(VkCommandBuffer commandBuffer) +{ + vkEndCommandBuffer(commandBuffer); + + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + + vkQueueSubmit(graphics_queue, 1, &submitInfo, VK_NULL_HANDLE); + vkQueueWaitIdle(graphics_queue); + + vkFreeCommandBuffers(device, command_pool, 1, &commandBuffer); +} + +void OceanApplication::create_command_buffers() +{ + command_buffers.resize(swap_chain_framebuffers.size()); + + VkCommandBufferAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.commandPool = command_pool; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandBufferCount = (uint32_t)command_buffers.size(); + + if (vkAllocateCommandBuffers(device, &allocInfo, command_buffers.data()) + != VK_SUCCESS) + { + throw std::runtime_error("failed to allocate command buffers!"); + } + + for (size_t i = 0; i < command_buffers.size(); i++) + { + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + + if (vkBeginCommandBuffer(command_buffers[i], &beginInfo) != VK_SUCCESS) + { + throw std::runtime_error( + "failed to begin recording command buffer!"); + } + + VkRenderPassBeginInfo renderPassInfo{}; + renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + renderPassInfo.renderPass = render_pass; + renderPassInfo.framebuffer = swap_chain_framebuffers[i]; + renderPassInfo.renderArea.offset = { 0, 0 }; + renderPassInfo.renderArea.extent = swap_chain_extent; + + std::array clearValues{}; + clearValues[0].color = { { 0.0f, 0.0f, 0.0f, 1.0f } }; + clearValues[1].depthStencil = { 1.0f, 0 }; + + renderPassInfo.clearValueCount = + static_cast(clearValues.size()); + renderPassInfo.pClearValues = clearValues.data(); + + vkCmdBeginRenderPass(command_buffers[i], &renderPassInfo, + VK_SUBPASS_CONTENTS_INLINE); + + vkCmdBindPipeline(command_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, + wireframe_mode ? wireframe_pipeline + : graphics_pipeline); + + VkDeviceSize offsets[] = { 0 }; + vkCmdBindVertexBuffers(command_buffers[i], 0, 1, &vertex_buffers[i], + offsets); + + vkCmdBindDescriptorSets( + command_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, + pipeline_layout, 0, 1, &descriptor_sets[i], 0, nullptr); + + for (auto& ind_buffer : index_buffers) + { + vkCmdBindIndexBuffer(command_buffers[i], ind_buffer.buffers[i], 0, + VK_INDEX_TYPE_UINT32); + vkCmdDrawIndexed(command_buffers[i], + static_cast(ocean_grid_indices.size()), + 1, 0, 0, 0); + } + + vkCmdEndRenderPass(command_buffers[i]); + + if (vkEndCommandBuffer(command_buffers[i]) != VK_SUCCESS) + { + throw std::runtime_error("failed to record command buffer!"); + } + } +} + +void OceanApplication::create_sync_objects() +{ + image_available_semaphores.resize(MAX_FRAMES_IN_FLIGHT); + render_finished_semaphores.resize(MAX_FRAMES_IN_FLIGHT); + in_flight_fences.resize(MAX_FRAMES_IN_FLIGHT); + images_in_flight.resize(swap_chain_images.size(), VK_NULL_HANDLE); + + VkExportSemaphoreCreateInfo exportSemaphoreCreateInfo{}; + exportSemaphoreCreateInfo.sType = + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO; + + VkSemaphoreCreateInfo semaphoreInfo{}; + semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + + VkFenceCreateInfo fenceInfo{}; + fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; + + for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) + { + if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, + &image_available_semaphores[i]) + != VK_SUCCESS + || vkCreateSemaphore(device, &semaphoreInfo, nullptr, + &render_finished_semaphores[i]) + != VK_SUCCESS + || vkCreateFence(device, &fenceInfo, nullptr, &in_flight_fences[i]) + != VK_SUCCESS) + { + throw std::runtime_error( + "failed to create synchronization objects for a frame!"); + } + } +} + +void OceanApplication::update_uniforms(uint32_t currentImage) +{ + UniformBufferObject ubo = {}; + ubo.choppiness = choppiness; + ubo.alt_scale = alt_scale; + + // update camera related uniform + glm::mat4 view_matrix = + glm::lookAt(camera.eye, camera.eye + camera.dir, camera.up); + + float fov = glm::radians(60.0); + float aspect = (float)app_opts.window_width / app_opts.window_height; + glm::mat4 proj_matrix = glm::perspective( + fov, aspect, 1.f, 2.f * ocean_grid_size * mesh_spacing); + proj_matrix[1][1] *= -1; + + ubo.view_mat = view_matrix; + ubo.proj_mat = proj_matrix; + + transition_uniform_layout(uniform_buffers[currentImage], + VK_ACCESS_SHADER_READ_BIT, + VK_ACCESS_TRANSFER_WRITE_BIT); + + VkCommandBuffer commandBuffer = begin_single_time_commands(); + vkCmdUpdateBuffer(commandBuffer, uniform_buffers[currentImage], 0, + sizeof(UniformBufferObject), &ubo); + end_single_time_commands(commandBuffer); + + transition_uniform_layout(uniform_buffers[currentImage], + VK_ACCESS_TRANSFER_WRITE_BIT, + VK_ACCESS_SHADER_READ_BIT); +} + +void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) +{ + cl_int2 patch = + cl_int2{ (int)(ocean_grid_size * mesh_spacing), (int)ocean_tex_size }; + + cl::NDRange lws; // NullRange by default. + if (group_size > 0) + { + lws = cl::NDRange{ group_size, group_size }; + } + + if (twiddle_factors_init) + { + try + { + size_t log_2_N = (size_t)(log(ocean_tex_size) / log(2.f)); + + /// Prepare vector of values to extract results + std::vector v(ocean_tex_size); + for (int i = 0; i < ocean_tex_size; i++) + { + int x = reverse_bits(i, log_2_N); + v[i] = x; + } + + /// Initialize device-side storage + cl::Buffer bit_reversed_inds_mem{ + context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, + sizeof(cl_int) * v.size(), v.data() + }; + + twiddle_kernel.setArg(0, cl_int(ocean_tex_size)); + twiddle_kernel.setArg(1, bit_reversed_inds_mem); + twiddle_kernel.setArg(2, *twiddle_factors_mem); + + command_queue.enqueueNDRangeKernel( + twiddle_kernel, cl::NullRange, + cl::NDRange{ log_2_N, ocean_tex_size }, cl::NDRange{ 1, 16 }); + twiddle_factors_init = false; + } catch (const cl::Error& e) + { + printf("twiddle indices: OpenCL %s kernel error: %s\n", e.what(), + IGetErrorString(e.err())); + exit(1); + } + } + + // change of some ocean's parameters requires to rebuild initial spectrum + // image + if (changed) + { + try + { + float wind_angle_rad = glm::radians(wind_angle); + cl_float4 params = + cl_float4{ wind_magnitude * glm::cos(wind_angle_rad), + wind_magnitude * glm::sin(wind_angle_rad), amplitude, + supress_factor }; + init_spectrum_kernel.setArg(0, patch); + init_spectrum_kernel.setArg(1, params); + init_spectrum_kernel.setArg(2, *noise_mem); + init_spectrum_kernel.setArg(3, *h0k_mem); + + command_queue.enqueueNDRangeKernel( + init_spectrum_kernel, cl::NullRange, + cl::NDRange{ ocean_tex_size, ocean_tex_size }, lws); + changed = false; + } catch (const cl::Error& e) + { + printf("initial spectrum: OpenCL %s kernel error: %s\n", e.what(), + IGetErrorString(e.err())); + exit(1); + } + } + + // ping-pong phase spectrum kernel launch + try + { + time_spectrum_kernel.setArg(0, elapsed); + time_spectrum_kernel.setArg(1, patch); + time_spectrum_kernel.setArg(2, *h0k_mem); + time_spectrum_kernel.setArg(3, *dxyz_coef_mem[0]); + time_spectrum_kernel.setArg(4, *dxyz_coef_mem[1]); + time_spectrum_kernel.setArg(5, *dxyz_coef_mem[2]); + + command_queue.enqueueNDRangeKernel( + time_spectrum_kernel, cl::NullRange, + cl::NDRange{ ocean_tex_size, ocean_tex_size }, lws); + } catch (const cl::Error& e) + { + printf("updateSpectrum: OpenCL %s kernel error: %s\n", e.what(), + IGetErrorString(e.err())); + exit(1); + } + + + // perform 1D FFT horizontal and vertical iterations + size_t log_2_N = (size_t)(log(ocean_tex_size) / log(2.f)); + fft_kernel.setArg(1, patch); + fft_kernel.setArg(2, *twiddle_factors_mem); + for (cl_int i = 0; i < 3; i++) + { + const cl::Image* displ_swap[] = { dxyz_coef_mem[i].get(), + hkt_pong_mem.get() }; + cl_int2 mode = (cl_int2){ 0, 0 }; + + bool ifft_pingpong = false; + for (int p = 0; p < log_2_N; p++) + { + if (ifft_pingpong) + { + fft_kernel.setArg(3, *displ_swap[1]); + fft_kernel.setArg(4, *displ_swap[0]); + } + else + { + fft_kernel.setArg(3, *displ_swap[0]); + fft_kernel.setArg(4, *displ_swap[1]); + } + + mode.s[1] = p; + fft_kernel.setArg(0, mode); + + command_queue.enqueueNDRangeKernel( + fft_kernel, cl::NullRange, + cl::NDRange{ ocean_tex_size, ocean_tex_size }, lws); + + + ifft_pingpong = !ifft_pingpong; + } + + // Cols + mode.s[0] = 1; + for (int p = 0; p < log_2_N; p++) + { + if (ifft_pingpong) + { + fft_kernel.setArg(3, *displ_swap[1]); + fft_kernel.setArg(4, *displ_swap[0]); + } + else + { + fft_kernel.setArg(3, *displ_swap[0]); + fft_kernel.setArg(4, *displ_swap[1]); + } + + mode.s[1] = p; + fft_kernel.setArg(0, mode); + + command_queue.enqueueNDRangeKernel( + fft_kernel, cl::NullRange, + cl::NDRange{ ocean_tex_size, ocean_tex_size }, lws); + + ifft_pingpong = !ifft_pingpong; + } + + if (log_2_N % 2) + { + // swap images if pingpong hold on temporary buffer + std::array orig = { 0, 0, 0 }, + region = { ocean_tex_size, ocean_tex_size, + 1 }; + command_queue.enqueueCopyImage(*displ_swap[0], *displ_swap[1], orig, + orig, region); + } + } + + if (app_opts.useExternalMemory) + { + for (size_t target = 0; target < IOPT_COUNT; target++) + { + command_queue.enqueueAcquireExternalMemObjects( + { *ocl_image_mems[target][currentImage] }); + } + } + + // inversion + { + inversion_kernel.setArg(0, patch); + inversion_kernel.setArg(1, *dxyz_coef_mem[0]); + inversion_kernel.setArg(2, *dxyz_coef_mem[1]); + inversion_kernel.setArg(3, *dxyz_coef_mem[2]); + inversion_kernel.setArg( + 4, *ocl_image_mems[IOPT_DISPLACEMENT][currentImage]); + + command_queue.enqueueNDRangeKernel( + inversion_kernel, cl::NullRange, + cl::NDRange{ ocean_tex_size, ocean_tex_size }, lws); + } + + // normals computation + { + cl_float2 factors = cl_float2{ choppiness, alt_scale }; + + normals_kernel.setArg(0, patch); + normals_kernel.setArg(1, factors); + normals_kernel.setArg(2, *noise_mem); + normals_kernel.setArg(3, + *ocl_image_mems[IOPT_DISPLACEMENT][currentImage]); + normals_kernel.setArg(4, + *ocl_image_mems[IOPT_NORMAL_MAP][currentImage]); + + command_queue.enqueueNDRangeKernel( + normals_kernel, cl::NullRange, + cl::NDRange{ ocean_tex_size, ocean_tex_size }, lws); + } +} + +void OceanApplication::update_ocean(uint32_t currentImage) +{ + update_uniforms(currentImage); + + auto end = std::chrono::system_clock::now(); + + // time factor of ocean animation + static float elapsed = 0.f; + + if (animate) + { + std::chrono::duration delta = end - start; + elapsed = delta.count(); + + update_spectrum(currentImage, elapsed); + + if (app_opts.useExternalMemory) + { + for (size_t target = 0; target < IOPT_COUNT; target++) + { + command_queue.enqueueReleaseExternalMemObjects( + { *ocl_image_mems[target][currentImage] }); + } + + command_queue.finish(); + } + else + { + for (size_t target = 0; target < IOPT_COUNT; target++) + { + size_t rowPitch = 0; + void* pixels = command_queue.enqueueMapImage( + *ocl_image_mems[target][currentImage], CL_TRUE, CL_MAP_READ, + { 0, 0, 0 }, { ocean_tex_size, ocean_tex_size, 1 }, + &rowPitch, nullptr); + + VkDeviceSize imageSize = + ocean_tex_size * ocean_tex_size * 4 * sizeof(float); + + void* data; + vkMapMemory(device, staging_tex_buffer_memory, 0, imageSize, 0, + &data); + memcpy(data, pixels, static_cast(imageSize)); + vkUnmapMemory(device, staging_tex_buffer_memory); + + command_queue.enqueueUnmapMemObject( + *ocl_image_mems[target][currentImage], pixels); + command_queue.flush(); + + transition_image_layout( + texture_images[target].images[currentImage], + VK_FORMAT_R32G32B32A32_SFLOAT, VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + copy_buffer_to_image( + staging_tex_buffer, + texture_images[target].images[currentImage], + static_cast(ocean_tex_size), + static_cast(ocean_tex_size)); + transition_image_layout( + texture_images[target].images[currentImage], + VK_FORMAT_R32G32B32A32_SFLOAT, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + } + } + } + else + { + // hold the animation at the same time point + std::chrono::duration duration(elapsed); + start = + end - std::chrono::duration_cast(duration); + + if (app_opts.useExternalMemory) + { + command_queue.finish(); + } + } +} + +void OceanApplication::draw_frame() +{ + vkWaitForFences(device, 1, &in_flight_fences[current_frame], VK_TRUE, + UINT64_MAX); + + uint32_t imageIndex; + vkAcquireNextImageKHR(device, swap_chain, UINT64_MAX, + image_available_semaphores[current_frame], + VK_NULL_HANDLE, &imageIndex); + + update_ocean(imageIndex); + + if (images_in_flight[imageIndex] != VK_NULL_HANDLE) + { + vkWaitForFences(device, 1, &images_in_flight[imageIndex], VK_TRUE, + UINT64_MAX); + } + images_in_flight[imageIndex] = in_flight_fences[current_frame]; + + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + + std::vector waitSemaphores; + std::vector waitStages; + waitSemaphores.push_back(image_available_semaphores[current_frame]); + waitStages.push_back(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT); + submitInfo.waitSemaphoreCount = + static_cast(waitSemaphores.size()); + submitInfo.pWaitSemaphores = waitSemaphores.data(); + submitInfo.pWaitDstStageMask = waitStages.data(); + + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &command_buffers[imageIndex]; + + submitInfo.signalSemaphoreCount = 1; + submitInfo.pSignalSemaphores = &render_finished_semaphores[current_frame]; + + vkResetFences(device, 1, &in_flight_fences[current_frame]); + + if (vkQueueSubmit(graphics_queue, 1, &submitInfo, + in_flight_fences[current_frame]) + != VK_SUCCESS) + { + throw std::runtime_error("failed to submit draw command buffer!"); + } + + VkPresentInfoKHR presentInfo{}; + presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; + + presentInfo.waitSemaphoreCount = 1; + presentInfo.pWaitSemaphores = &render_finished_semaphores[current_frame]; + + VkSwapchainKHR swapChains[] = { swap_chain }; + presentInfo.swapchainCount = 1; + presentInfo.pSwapchains = swapChains; + + presentInfo.pImageIndices = &imageIndex; + + vkQueuePresentKHR(present_queue, &presentInfo); + + current_frame = (current_frame + 1) % MAX_FRAMES_IN_FLIGHT; +} + +void OceanApplication::check_openCL_ext_mem_support(cl::Device& device) +{ + if (cl::util::supports_extension(device, "cl_khr_external_memory")) + { + printf("Device supports cl_khr_external_memory.\n"); + printf("Supported external memory handle types:\n"); + + std::vector types = + device.getInfo(); + for (auto type : types) + { +#define CASE_TO_STRING(_e) \ + case _e: printf("\t%s\n", #_e); break; + switch ( + static_cast::type>( + type)) + { + CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR); + CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR); + CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR); + CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_D3D11_TEXTURE_KHR); + CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_D3D11_TEXTURE_KMT_KHR); + CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_D3D12_HEAP_KHR); + CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_D3D12_RESOURCE_KHR); + CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_DMA_BUF_KHR); + default: + printf("Unknown cl_external_memory_handle_type_khr %04X\n", + (unsigned int)type); + } +#undef CASE_TO_STRING + } + + +#ifdef _WIN32 + if (std::find(types.begin(), types.end(), + CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR) + != types.end()) + { + externalMemType = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR; + } + else + { + printf("Couldn't find a compatible external memory type " + "(sample supports OPAQUE_WIN32).\n"); + useExternalMemory = false; + } +#elif defined(__linux__) + if (std::find( + types.begin(), types.end(), + cl::ExternalMemoryType(CL_EXTERNAL_MEMORY_HANDLE_DMA_BUF_KHR)) + != types.end()) + { + external_mem_type = CL_EXTERNAL_MEMORY_HANDLE_DMA_BUF_KHR; + } + else if (std::find(types.begin(), types.end(), + cl::ExternalMemoryType( + CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR)) + != types.end()) + { + external_mem_type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR; + } + else + { + printf("Couldn't find a compatible external memory type " + "(sample supports DMA_BUF or OPAQUE_FD).\n"); + app_opts.useExternalMemory = false; + } +#endif + } + else + { + printf("Device does not support cl_khr_external_memory.\n"); + app_opts.useExternalMemory = false; + } +} + +VkShaderModule +OceanApplication::create_shader_module(const std::vector& code) +{ + VkShaderModuleCreateInfo createInfo{}; + createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + createInfo.codeSize = code.size(); + createInfo.pCode = reinterpret_cast(code.data()); + + VkShaderModule shaderModule; + if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) + != VK_SUCCESS) + { + throw std::runtime_error("failed to create shader module!"); + } + + return shaderModule; +} + +VkSurfaceFormatKHR OceanApplication::choose_swap_surf_format( + const std::vector& availableFormats) +{ + for (const auto& availableFormat : availableFormats) + { + if (availableFormat.format == VK_FORMAT_B8G8R8A8_UNORM) + { + return availableFormat; + } + } + + return availableFormats[0]; +} + +VkPresentModeKHR OceanApplication::choose_swap_present_mode( + const std::vector& availablePresentModes) +{ + for (const auto& availablePresentMode : availablePresentModes) + { + if (!app_opts.immediate) + { + if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) + { + return availablePresentMode; + } + } + else + { + if (availablePresentMode == VK_PRESENT_MODE_IMMEDIATE_KHR) + { + return availablePresentMode; + } + } + } + + return VK_PRESENT_MODE_FIFO_KHR; +} + +VkExtent2D OceanApplication::choose_swap_extent( + const VkSurfaceCapabilitiesKHR& capabilities) +{ + if (capabilities.currentExtent.width != UINT32_MAX) + { + return capabilities.currentExtent; + } + else + { + int width, height; + glfwGetFramebufferSize(window, &width, &height); + + VkExtent2D actualExtent = { static_cast(width), + static_cast(height) }; + + actualExtent.width = std::max( + capabilities.minImageExtent.width, + std::min(actualExtent.width, capabilities.maxImageExtent.width)); + actualExtent.height = std::max( + capabilities.minImageExtent.height, + std::min(actualExtent.height, capabilities.maxImageExtent.height)); + + return actualExtent; + } +} + +SwapChainSupportDetails +OceanApplication::query_swap_chain_support(VkPhysicalDevice device) +{ + SwapChainSupportDetails details; + + vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, + &details.capabilities); + + uint32_t formatCount; + vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, + nullptr); + + if (formatCount != 0) + { + details.formats.resize(formatCount); + vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, + details.formats.data()); + } + + uint32_t presentModeCount; + vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, + &presentModeCount, nullptr); + + if (presentModeCount != 0) + { + details.presentModes.resize(presentModeCount); + vkGetPhysicalDeviceSurfacePresentModesKHR( + device, surface, &presentModeCount, details.presentModes.data()); + } + + return details; +} + +bool OceanApplication::is_device_suitable(VkPhysicalDevice device) +{ + QueueFamilyIndices indices = find_queue_families(device); + + bool extensionsSupported = check_device_extension_support(device); + + bool swapChainAdequate = false; + if (extensionsSupported) + { + SwapChainSupportDetails swapChainSupport = + query_swap_chain_support(device); + swapChainAdequate = !swapChainSupport.formats.empty() + && !swapChainSupport.presentModes.empty(); + } + + return indices.isComplete() && extensionsSupported && swapChainAdequate; +} + +bool OceanApplication::check_device_extension_support(VkPhysicalDevice device) +{ + VkPhysicalDeviceProperties pProperties; + vkGetPhysicalDeviceProperties(device, &pProperties); + + if (std::string(pProperties.deviceName).find("Intel") != std::string::npos) + return false; + + uint32_t extensionCount; + vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, + nullptr); + + std::vector availableExtensions(extensionCount); + vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, + availableExtensions.data()); + + auto extensions = get_required_dev_exts(); + std::set requiredExtensions(extensions.begin(), + extensions.end()); + + for (const auto& extension : availableExtensions) + { + requiredExtensions.erase(extension.extensionName); + } + + return requiredExtensions.empty(); +} + +QueueFamilyIndices +OceanApplication::find_queue_families(VkPhysicalDevice device) +{ + QueueFamilyIndices indices; + + uint32_t queueFamilyCount = 0; + vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, + nullptr); + + std::vector queueFamilies(queueFamilyCount); + vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, + queueFamilies.data()); + + int i = 0; + for (const auto& queueFamily : queueFamilies) + { + if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) + { + indices.graphicsFamily = i; + } + + VkBool32 presentSupport = false; + vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, + &presentSupport); + + if (presentSupport) + { + indices.presentFamily = i; + } + + if (indices.isComplete()) + { + break; + } + + i++; + } + + return indices; +} + +std::vector OceanApplication::get_required_exts() +{ + uint32_t glfwExtensionCount = 0; + const char** glfwExtensions; + glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); + + std::vector extensions(glfwExtensions, + glfwExtensions + glfwExtensionCount); + + if (app_opts.useExternalMemory) + { + extensions.push_back( + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + } + if (app_opts.useExternalMemory) + { + extensions.push_back( + VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME); + } + if (enableValidationLayers) + { + extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); + } + + return extensions; +} + +std::vector OceanApplication::get_required_dev_exts() +{ + std::vector extensions(deviceExtensions); + + if (app_opts.useExternalMemory) + { + extensions.push_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); +#ifdef _WIN32 + extensions.push_back(VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME); +#elif defined(__linux__) + extensions.push_back(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME); +#endif + } + + return extensions; +} + +bool OceanApplication::check_validation_layer_support() +{ + uint32_t layerCount; + vkEnumerateInstanceLayerProperties(&layerCount, nullptr); + + std::vector availableLayers(layerCount); + vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data()); + + for (const char* layerName : validationLayers) + { + bool layerFound = false; + + for (const auto& layerProperties : availableLayers) + { + if (strcmp(layerName, layerProperties.layerName) == 0) + { + layerFound = true; + break; + } + } + + if (!layerFound) + { + return false; + } + } + + return true; +} + +std::vector OceanApplication::read_file(const std::string& filename) +{ + std::ifstream file(filename, std::ios::ate | std::ios::binary); + + if (!file.is_open()) + { + throw std::runtime_error("failed to open file!"); + } + + size_t fileSize = (size_t)file.tellg(); + if (filename.find(".spv") == std::string::npos) fileSize += 1; + std::vector buffer(fileSize, '\0'); + + file.seekg(0); + file.read(buffer.data(), fileSize); + file.close(); + return buffer; +} + +VKAPI_ATTR VkBool32 VKAPI_CALL OceanApplication::debug_callback( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) +{ + fprintf(stderr, "validation layer: %s\n", pCallbackData->pMessage); + + return VK_FALSE; +} diff --git a/samples/vulkan/ocean/ocean.frag b/samples/vulkan/ocean/ocean.frag new file mode 100755 index 00000000..bbee8e98 --- /dev/null +++ b/samples/vulkan/ocean/ocean.frag @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#version 450 + +layout(location = 0) in vec2 frag_tex_coord; +layout(location = 1) in vec4 ec_pos; + +layout(location = 0) out vec4 out_color; + +layout(binding = 1) uniform sampler2D u_normal_map; +layout(binding = 2) uniform ViewData { + uniform mat4 view_mat; + uniform mat4 proj_mat; + uniform vec3 sun_dir; + uniform float choppiness; + uniform float alt_scale; +} view; + +const vec3 env_specular = vec3(0.8); +const float specular_power = 32.0; +const float specular_scale = 0.75; + +const float fresnel_approx_pow_factor = 2.0; +const float dyna_range = 0.8f; + +const vec3 ocean_bright = vec3(0.5, 1.6, 2.15); +const vec3 ocean_dark = vec3(0.03, 0.06, 0.135); +const float exposure = 0.4; + +vec3 hdr(vec3 color, float exposure) +{ + return 1.0 - exp(-color * exposure); +} + +mat3 get_linear_part( mat4 m ) +{ + mat3 result; + + result[0][0] = m[0][0]; + result[0][1] = m[0][1]; + result[0][2] = m[0][2]; + + result[1][0] = m[1][0]; + result[1][1] = m[1][1]; + result[1][2] = m[1][2]; + + result[2][0] = m[2][0]; + result[2][1] = m[2][1]; + result[2][2] = m[2][2]; + + return result; +} + +void main() +{ + // normal map computed in opencl kernel + vec4 ndata = texture(u_normal_map, frag_tex_coord); + + // foam, some calculation parameters have been adapted to the initial view + ivec2 ts = textureSize(u_normal_map, 0); + float off_scl_x = 4.0 / ts.x; + float off_scl_y = 4.0 / ts.y; + vec3 n0 = texture(u_normal_map, frag_tex_coord + vec2(off_scl_x, off_scl_y)).xyz; + vec3 n1 = texture(u_normal_map, frag_tex_coord + vec2(-off_scl_x, off_scl_y)).xyz; + vec3 n2 = texture(u_normal_map, frag_tex_coord - vec2(off_scl_x, off_scl_y)).xyz; + vec3 n3 = texture(u_normal_map, frag_tex_coord - vec2(-off_scl_x, off_scl_y)).xyz; + + float f0 = clamp(abs(dot(n0, n2) * (-0.5) + 0.5), 0.0, 1.0); + float f1 = clamp(abs(dot(n1, n3) * (-0.5) + 0.5), 0.0, 1.0); + + f0 = pow(f0 * 8.0, 2.0); + f1 = pow(f1 * 8.0, 2.0); + + float foam_fac = ndata.w * clamp(max(f0, f1), 0.0, 1.0); + + // preparation of view space lighting computation + mat3 norm_mat = get_linear_part(view.view_mat); + vec3 normal = norm_mat * ndata.xyz; + vec3 light_dir = normalize(norm_mat * view.sun_dir); + vec3 view_dir = normalize(ec_pos.xyz); + + // diffuse + specular + vec3 specular = vec3(0.0); + float n_dot_vp = max(0.0, dot(normal, light_dir)); + float n_dot_e = dot(normal, -view_dir); + float diffuse = clamp(dot(normal, light_dir), 0.0, 1.0); + + if (n_dot_vp > 0.0) + { + vec3 N = normal; + vec3 E = -view_dir; + vec3 R = normalize(reflect(-light_dir, N)); + + // modulate specular scale value based on fragment direction + float dirScale = mix ( pow ( abs(n_dot_e), 8.0 ), + 1.0 - pow ( abs(1.0 - n_dot_e), 4.0 ), n_dot_e); + specular = env_specular * vec3 ( pow(max(dot(R, E), 0.0), specular_power) * + specular_scale * dirScale ); + } + + // refraction factors and final color assembly + float fresnel = clamp(pow( 1.0 + n_dot_e, -fresnel_approx_pow_factor ) * dyna_range, 0.0, 1.0); + vec3 bright = fresnel * ocean_bright; + vec3 water = (1.0 - fresnel) * ocean_dark * ocean_bright * diffuse; + vec3 color = bright + water + specular + vec3(foam_fac); + out_color = vec4(hdr(color, exposure), 1.0); +} diff --git a/samples/vulkan/ocean/ocean.frag.spv b/samples/vulkan/ocean/ocean.frag.spv new file mode 100755 index 0000000000000000000000000000000000000000..3cede6b80a2e2ce3d350221223fb0c4d4e6ee02b GIT binary patch literal 7448 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 + +class OceanApplication { + +public: + void run(); + void keyboard(int key, int scancode, int action, int mods); + void mouse_event(int button, int action, int mods); + void mouse_pos(double pX, double pY); + void mouse_roll(double offset_x, double offset_y); + +public: + cl::sdk::options::SingleDevice dev_opts; + CliOptions app_opts; + +private: + GLFWwindow* window; + Camera camera; + + // ocean texture size - assume uniform x/y + size_t ocean_tex_size = 512; + + // used to specify local work size + size_t group_size = 16; + + // mesh patch size - assume uniform x/y + size_t ocean_grid_size = 256; + + // mesh patch spacing + float mesh_spacing = 2.f; + + bool animate = true; + + // ocean parameters changed - rebuild initial spectrum resources + bool changed = true; + bool twiddle_factors_init = true; + + // ocean in-factors + float wind_magnitude = 300.f; + float wind_angle = 45.f; + float choppiness = 30.f; + float alt_scale = 20.f; + + float amplitude = 80.f; + float supress_factor = 0.1f; + + // env factors + int sun_elevation = 0; + int sun_azimuth = 90; + bool wireframe_mode = false; + + std::chrono::system_clock::time_point start = + std::chrono::system_clock::now(); + + VkInstance instance; + VkDebugUtilsMessengerEXT debug_messenger; + VkSurfaceKHR surface; + + VkPhysicalDevice physical_device = VK_NULL_HANDLE; + VkDevice device; + + VkQueue graphics_queue; + VkQueue present_queue; + + VkSwapchainKHR swap_chain; + std::vector swap_chain_images; + VkFormat swap_chain_image_format; + VkExtent2D swap_chain_extent; + std::vector swap_chain_image_views; + std::vector swap_chain_framebuffers; + + VkImage depth_image; + VkDeviceMemory depth_image_memory; + VkImageView depth_image_view; + + VkRenderPass render_pass; + VkDescriptorSetLayout descriptor_set_layout; + VkPipelineLayout pipeline_layout; + VkPipeline graphics_pipeline; + VkPipeline wireframe_pipeline; + + VkCommandPool command_pool; + + VkBuffer staging_tex_buffer; + VkDeviceMemory staging_tex_buffer_memory; + + // Only displacement and normal map images must be shared between OCL and + // Vulkan + enum InteropTexType + { + IOPT_DISPLACEMENT = 0, + IOPT_NORMAL_MAP, + IOPT_COUNT + }; + + struct TextureOCL + { + std::vector images; + std::vector image_memories; + std::vector image_views; + }; + + // vulkan-opencl interop resources + std::array texture_images; + + // Ocean grid vertices and related buffers + std::vector ocean_grid_vertices; + std::vector vertex_buffers; + std::vector vertex_buffer_memories; + + std::vector ocean_grid_indices; + // separate index buffer for [ocean_grid_size] triangle strips + struct IndexBuffer + { + std::vector buffers; + std::vector buffer_memories; + }; + std::vector index_buffers; + + std::array texture_sampler; + + VkDescriptorPool descriptor_pool; + std::vector descriptor_sets; + + std::vector command_buffers; + + std::vector image_available_semaphores; + std::vector render_finished_semaphores; + std::vector in_flight_fences; + std::vector images_in_flight; + size_t current_frame = 0; + +#ifdef _WIN32 + PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = NULL; +#elif defined(__linux__) + PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = NULL; +#endif + + std::vector uniform_buffers; + std::vector uniform_buffers_memory; + + // more OpenCL resources + cl_external_memory_handle_type_khr external_mem_type = 0; + + cl::Context context; + cl::CommandQueue command_queue; + + // generates twiddle factors kernel + cl::Kernel twiddle_kernel; + + // initial spectrum kernel + cl::Kernel init_spectrum_kernel; + + // Fourier components image kernel + cl::Kernel time_spectrum_kernel; + + // FFT kernel + cl::Kernel fft_kernel; + + // inversion kernel + cl::Kernel inversion_kernel; + + // building normals kernel + cl::Kernel normals_kernel; + + // FFT intermediate computation storages without vulkan iteroperability + std::unique_ptr dxyz_coef_mem[3]; + std::unique_ptr hkt_pong_mem; + std::unique_ptr twiddle_factors_mem; + std::unique_ptr h0k_mem; + std::unique_ptr noise_mem; + + size_t ocl_max_img2d_width; + cl_ulong ocl_max_alloc_size, ocl_mem_size; + + // main opencl-vulkan iteroperability resources + // final computation result with displacements and normal map, + // needs to follow swap-chain scheme + std::array>, IOPT_COUNT> + ocl_image_mems; + + clEnqueueAcquireExternalMemObjectsKHR_fn + clEnqueueAcquireExternalMemObjectsKHR = NULL; + clEnqueueReleaseExternalMemObjectsKHR_fn + clEnqueueReleaseExternalMemObjectsKHR = NULL; + + void init_window(); + void init_openCL(); + void init_openCL_mems(); + void init_vulkan(); + void main_loop(); + void cleanup(); + void create_instance(); + + void populate_dbg_msger_create_info( + VkDebugUtilsMessengerCreateInfoEXT& createInfo); + void setup_dbg_msger(); + + void create_surface(); + void pick_physical_device(); + void create_logical_device(); + void create_swap_chain(); + void create_swap_chain_image_views(); + void create_render_pass(); + void create_uniform_buffer(); + void create_descriptor_det_layout(); + void create_graphics_pipeline(); + void create_framebuffers(); + void create_command_pool(); + void create_vertex_buffers(); + void create_index_buffers(); + void create_texture_images(); + void create_texture_image_views(); + void create_texture_sampler(); + VkImageView create_image_view(VkImage image, VkFormat format, + VkImageAspectFlags aspectFlags); + + void create_shareable_image(uint32_t width, uint32_t height, + VkFormat format, VkImageTiling tiling, + VkImageUsageFlags usage, + VkMemoryPropertyFlags properties, + VkImage& image, VkDeviceMemory& imageMemory, + VkImageType type = VK_IMAGE_TYPE_2D); + + void create_image(uint32_t width, uint32_t height, VkFormat format, + VkImageTiling tiling, VkImageUsageFlags usage, + VkMemoryPropertyFlags properties, VkImage& image, + VkDeviceMemory& imageMemory); + VkFormat find_supported_format(const std::vector& candidates, + VkImageTiling tiling, + VkFormatFeatureFlags features); + + VkFormat find_depth_format(); + + bool has_stencil_component(VkFormat format); + void create_depth_resources(); + + void transition_image_layout(VkImage image, VkFormat format, + VkImageLayout oldLayout, + VkImageLayout newLayout, uint32_t layers = 1); + + void copy_buffer_to_image(VkBuffer buffer, VkImage image, uint32_t width, + uint32_t height); + + void transition_uniform_layout(VkBuffer buffer, VkAccessFlagBits src, + VkAccessFlagBits dst); + + void create_descriptor_pool(); + + void create_descriptor_sets(); + void create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, + VkMemoryPropertyFlags properties, VkBuffer& buffer, + VkDeviceMemory& bufferMemory); + + void copy_buffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size); + uint32_t find_memory_type(uint32_t typeFilter, + VkMemoryPropertyFlags properties); + + VkCommandBuffer begin_single_time_commands(); + + void end_single_time_commands(VkCommandBuffer commandBuffer); + void create_command_buffers(); + + void create_sync_objects(); + void update_uniforms(uint32_t currentImage); + + void update_spectrum(uint32_t currentImage, float elapsed); + void update_ocean(uint32_t currentImage); + + void draw_frame(); + + void check_openCL_ext_mem_support(cl::Device& device); + + VkShaderModule create_shader_module(const std::vector& code); + + VkSurfaceFormatKHR choose_swap_surf_format( + const std::vector& availableFormats); + + VkPresentModeKHR choose_swap_present_mode( + const std::vector& availablePresentModes); + + VkExtent2D choose_swap_extent(const VkSurfaceCapabilitiesKHR& capabilities); + + SwapChainSupportDetails query_swap_chain_support(VkPhysicalDevice device); + + bool is_device_suitable(VkPhysicalDevice device); + + bool check_device_extension_support(VkPhysicalDevice device); + + QueueFamilyIndices find_queue_families(VkPhysicalDevice device); + + std::vector get_required_exts(); + + std::vector get_required_dev_exts(); + + bool check_validation_layer_support(); + + std::vector read_file(const std::string& filename); + + static VKAPI_ATTR VkBool32 VKAPI_CALL + debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); +}; + +#endif // OCEAN_HPP diff --git a/samples/vulkan/ocean/ocean.png b/samples/vulkan/ocean/ocean.png new file mode 100644 index 0000000000000000000000000000000000000000..f112470bcceaa49b3904690ccae7e3b8bd0a7daf GIT binary patch literal 720027 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̟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�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

P2sN17)9T?km(# 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 ?=kq)NCcFiPF997*ws!3W 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

P*Ysr`4_dowPOLr; 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 z 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
q3b1 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 J>3k( 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 z z5A;GIBj(r)ds|14u@-nLkJazQa=X88`MDqT6$l0Mp{dlm4yDfr2g4#qvqStEE5?m_ zhybl({2k}5BINiN5IC}dq_DpFtVPxS9AJ~Miw1~|z^{tcsvw<~rz>V%GDjndJ z_R+?R*Ykq1Sj$k{P_pCK63J zL@;6ak)!i4G;>wc#Zm5m;5U&lQgZiokJkH{*7+y2?4M6Z+De=nJ1O5!cLrWFEwrAK z!#s3zbX)^SQ-#`8ojoUf-JF0bM^F~V<`h1sRv=n@_$$Qz#nTTR&j>|a3oW*sa9n3|f>A1U*gj*F*rsf4m=DLz@7}cCj+|}EuVMbD z!kAxwhcFo^N$^jgw%Tbsmt6)luyTtX>%@!A)bzP#1@qrv!{v&bd`D|xqQ+Yd`qI^I za)c87QqkYs#A^4Z2l)0}mpj4rJ1jk~*^WO!OBwSj5;Oh^?CfL{ifFUC+hDI`(&s)n zG$_QfgpKld6K39K-b-(!pGjBeM^z7W@`8V)`x~ds zpNpd}sFylhOw~H+QJynE-e23LwY-$c+km;5Tt43{F_q6N#@p#*?QM=tm64n+4Mpx0 zd%Q6tII@1SCN?=ut(fSA6oY@?av`;0&n_^N%6KrI1OZrrMW;_>pL_Y>$ww zID-tG)XtEL&*!Arl(Fo&oezH~o(b4$xDg9vzKiD$MDPqMH|Pj$)@8n%cuhRED?0*> z+A5e_6E)eg;hp6UZRC~_@v2MBEUbUcF8!x2N$A?c)v;h9R?l9!9^Zsct&B!w%0ARp2Y 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 IWVfLI07$T=82|tP literal 0 HcmV?d00001 diff --git a/samples/vulkan/ocean/ocean_util.hpp b/samples/vulkan/ocean/ocean_util.hpp new file mode 100755 index 00000000..d144dde9 --- /dev/null +++ b/samples/vulkan/ocean/ocean_util.hpp @@ -0,0 +1,272 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OCEAN_UTIL_HPP +#define OCEAN_UTIL_HPP + +#include +#define GLFW_INCLUDE_VULKAN +#include +#include + +#define CL_HPP_TARGET_OPENCL_VERSION 300 + +const float DRAG_SPEED_FAC = 0.2f; +const float ROLL_SPEED_FAC = 8.f; +const int MAX_FRAMES_IN_FLIGHT = 2; + +static const char* IGetErrorString(int clErrorCode) +{ + switch (clErrorCode) + { + case CL_SUCCESS: return "CL_SUCCESS"; + case CL_DEVICE_NOT_FOUND: return "CL_DEVICE_NOT_FOUND"; + case CL_DEVICE_NOT_AVAILABLE: return "CL_DEVICE_NOT_AVAILABLE"; + case CL_COMPILER_NOT_AVAILABLE: return "CL_COMPILER_NOT_AVAILABLE"; + case CL_MEM_OBJECT_ALLOCATION_FAILURE: + return "CL_MEM_OBJECT_ALLOCATION_FAILURE"; + case CL_OUT_OF_RESOURCES: return "CL_OUT_OF_RESOURCES"; + case CL_OUT_OF_HOST_MEMORY: return "CL_OUT_OF_HOST_MEMORY"; + case CL_PROFILING_INFO_NOT_AVAILABLE: + return "CL_PROFILING_INFO_NOT_AVAILABLE"; + case CL_MEM_COPY_OVERLAP: return "CL_MEM_COPY_OVERLAP"; + case CL_IMAGE_FORMAT_MISMATCH: return "CL_IMAGE_FORMAT_MISMATCH"; + case CL_IMAGE_FORMAT_NOT_SUPPORTED: + return "CL_IMAGE_FORMAT_NOT_SUPPORTED"; + case CL_BUILD_PROGRAM_FAILURE: return "CL_BUILD_PROGRAM_FAILURE"; + case CL_MAP_FAILURE: return "CL_MAP_FAILURE"; + case CL_MISALIGNED_SUB_BUFFER_OFFSET: + return "CL_MISALIGNED_SUB_BUFFER_OFFSET"; + case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: + return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST"; + case CL_COMPILE_PROGRAM_FAILURE: return "CL_COMPILE_PROGRAM_FAILURE"; + case CL_LINKER_NOT_AVAILABLE: return "CL_LINKER_NOT_AVAILABLE"; + case CL_LINK_PROGRAM_FAILURE: return "CL_LINK_PROGRAM_FAILURE"; + case CL_DEVICE_PARTITION_FAILED: return "CL_DEVICE_PARTITION_FAILED"; + case CL_KERNEL_ARG_INFO_NOT_AVAILABLE: + return "CL_KERNEL_ARG_INFO_NOT_AVAILABLE"; + case CL_INVALID_VALUE: return "CL_INVALID_VALUE"; + case CL_INVALID_DEVICE_TYPE: return "CL_INVALID_DEVICE_TYPE"; + case CL_INVALID_DEVICE: return "CL_INVALID_DEVICE"; + case CL_INVALID_CONTEXT: return "CL_INVALID_CONTEXT"; + case CL_INVALID_QUEUE_PROPERTIES: return "CL_INVALID_QUEUE_PROPERTIES"; + case CL_INVALID_COMMAND_QUEUE: return "CL_INVALID_COMMAND_QUEUE"; + case CL_INVALID_HOST_PTR: return "CL_INVALID_HOST_PTR"; + case CL_INVALID_MEM_OBJECT: return "CL_INVALID_MEM_OBJECT"; + case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: + return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"; + case CL_INVALID_IMAGE_SIZE: return "CL_INVALID_IMAGE_SIZE"; + case CL_INVALID_SAMPLER: return "CL_INVALID_SAMPLER"; + case CL_INVALID_BINARY: return "CL_INVALID_BINARY"; + case CL_INVALID_BUILD_OPTIONS: return "CL_INVALID_BUILD_OPTIONS"; + case CL_INVALID_PLATFORM: return "CL_INVALID_PLATFORM"; + case CL_INVALID_PROGRAM: return "CL_INVALID_PROGRAM"; + case CL_INVALID_PROGRAM_EXECUTABLE: + return "CL_INVALID_PROGRAM_EXECUTABLE"; + case CL_INVALID_KERNEL_NAME: return "CL_INVALID_KERNEL_NAME"; + case CL_INVALID_KERNEL_DEFINITION: + return "CL_INVALID_KERNEL_DEFINITION"; + case CL_INVALID_KERNEL: return "CL_INVALID_KERNEL"; + case CL_INVALID_ARG_INDEX: return "CL_INVALID_ARG_INDEX"; + case CL_INVALID_ARG_VALUE: return "CL_INVALID_ARG_VALUE"; + case CL_INVALID_ARG_SIZE: return "CL_INVALID_ARG_SIZE"; + case CL_INVALID_KERNEL_ARGS: return "CL_INVALID_KERNEL_ARGS"; + case CL_INVALID_WORK_DIMENSION: return "CL_INVALID_WORK_DIMENSION"; + case CL_INVALID_WORK_GROUP_SIZE: return "CL_INVALID_WORK_GROUP_SIZE"; + case CL_INVALID_WORK_ITEM_SIZE: return "CL_INVALID_WORK_ITEM_SIZE"; + case CL_INVALID_GLOBAL_OFFSET: return "CL_INVALID_GLOBAL_OFFSET"; + case CL_INVALID_EVENT_WAIT_LIST: return "CL_INVALID_EVENT_WAIT_LIST"; + case CL_INVALID_EVENT: return "CL_INVALID_EVENT"; + case CL_INVALID_OPERATION: return "CL_INVALID_OPERATION"; + case CL_INVALID_GL_OBJECT: return "CL_INVALID_GL_OBJECT"; + case CL_INVALID_BUFFER_SIZE: return "CL_INVALID_BUFFER_SIZE"; + case CL_INVALID_MIP_LEVEL: return "CL_INVALID_MIP_LEVEL"; + case CL_INVALID_GLOBAL_WORK_SIZE: return "CL_INVALID_GLOBAL_WORK_SIZE"; + case CL_INVALID_PROPERTY: return "CL_INVALID_PROPERTY"; + case CL_INVALID_IMAGE_DESCRIPTOR: return "CL_INVALID_IMAGE_DESCRIPTOR"; + case CL_INVALID_COMPILER_OPTIONS: return "CL_INVALID_COMPILER_OPTIONS"; + case CL_INVALID_LINKER_OPTIONS: return "CL_INVALID_LINKER_OPTIONS"; + case CL_INVALID_DEVICE_PARTITION_COUNT: + return "CL_INVALID_DEVICE_PARTITION_COUNT"; + case CL_INVALID_PIPE_SIZE: return "CL_INVALID_PIPE_SIZE"; + case CL_INVALID_DEVICE_QUEUE: return "CL_INVALID_DEVICE_QUEUE"; + case CL_INVALID_SPEC_ID: return "CL_INVALID_SPEC_ID"; + case CL_MAX_SIZE_RESTRICTION_EXCEEDED: + return "CL_MAX_SIZE_RESTRICTION_EXCEEDED"; + default: return "(unknown)"; + } +} + +#define print_error(errCode, msg) \ + printf("ERROR: %s! (%s from %s:%d)\n", msg, IGetErrorString(errCode), \ + __FILE__, __LINE__); + +#define test_error(errCode, msg) \ + { \ + auto errCodeResult = errCode; \ + if (errCodeResult != CL_SUCCESS) \ + { \ + print_error(errCodeResult, msg); \ + return errCode; \ + } \ + } + +static uint32_t reverse_bits(uint32_t n, uint32_t log_2_N) +{ + uint32_t r = 0; + for (int j = 0; j < log_2_N; j++) + { + r = (r << 1) + (n & 1); + n >>= 1; + } + return r; +} + +const std::vector validationLayers = { + "VK_LAYER_KHRONOS_validation", + //"VK_LAYER_LUNARG_api_dump", // useful for debugging but adds a LOT of + // output! +}; + +const std::vector deviceExtensions = { + VK_KHR_SWAPCHAIN_EXTENSION_NAME, +}; + +#ifdef NDEBUG +const bool enableValidationLayers = false; +#else +const bool enableValidationLayers = true; +#endif + +static VkResult CreateDebugUtilsMessengerEXT( + VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pDebugMessenger) +{ + auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr( + instance, "vkCreateDebugUtilsMessengerEXT"); + if (func != nullptr) + { + return func(instance, pCreateInfo, pAllocator, pDebugMessenger); + } + else + { + return VK_ERROR_EXTENSION_NOT_PRESENT; + } +} + +static void +DestroyDebugUtilsMessengerEXT(VkInstance instance, + VkDebugUtilsMessengerEXT debugMessenger, + const VkAllocationCallbacks* pAllocator) +{ + auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr( + instance, "vkDestroyDebugUtilsMessengerEXT"); + if (func != nullptr) + { + func(instance, debugMessenger, pAllocator); + } +} + +struct QueueFamilyIndices +{ + uint32_t graphicsFamily; + uint32_t presentFamily; + + QueueFamilyIndices(): graphicsFamily(~0), presentFamily(~0) {} + + bool isComplete() { return graphicsFamily != ~0 && presentFamily != ~0; } +}; + +struct SwapChainSupportDetails +{ + VkSurfaceCapabilitiesKHR capabilities; + std::vector formats; + std::vector presentModes; +}; + +struct UniformBufferObject +{ + alignas(4) glm::mat4 view_mat; + alignas(4) glm::mat4 proj_mat; + alignas(4) glm::vec3 sun_dir = glm::normalize(glm::vec3(0.f, 1.f, 1.f)); + alignas(4) std::float_t choppiness = 1.f; + alignas(4) std::float_t alt_scale = 1.f; +}; + +struct Vertex +{ + + glm::vec3 pos; + glm::vec2 tc; + + static VkVertexInputBindingDescription getBindingDescription() + { + VkVertexInputBindingDescription bindingDescription{}; + + bindingDescription.binding = 0; + bindingDescription.stride = sizeof(Vertex); + bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + return bindingDescription; + } + + static std::array + getAttributeDescriptions() + { + std::array + attributeDescriptions{}; + + attributeDescriptions[0].binding = 0; + attributeDescriptions[0].location = 0; + attributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT; + attributeDescriptions[0].offset = offsetof(Vertex, pos); + + attributeDescriptions[1].binding = 0; + attributeDescriptions[1].location = 1; + attributeDescriptions[1].format = VK_FORMAT_R32G32_SFLOAT; + attributeDescriptions[1].offset = offsetof(Vertex, tc); + + return attributeDescriptions; + } +}; + +struct Camera +{ + glm::vec3 eye = glm::vec3(0.0f, 0.0f, 20.0f); + glm::vec3 dir = glm::vec3(-0.57359f, 0.73945f, -0.35241f); + glm::vec3 up = glm::vec3(-0.2159f, 0.27846f, 0.93584f); + glm::vec3 rvec = glm::vec3(1.0f, 0.0f, 0.0f); + glm::vec2 begin = glm::vec2(-1.0f, -1.0f); + float yaw = 37.8f; + float pitch = 69.3649f; + bool drag = false; +}; + +struct CliOptions +{ + size_t window_width = 1024; + size_t window_height = 1024; + + bool immediate = false; + + bool linearImages = false; + bool deviceLocalImages = true; + + bool useExternalMemory = true; +}; + +#endif // OCEAN_UTIL_HPP diff --git a/samples/vulkan/ocean/time_spectrum.cl b/samples/vulkan/ocean/time_spectrum.cl new file mode 100644 index 00000000..d35036af --- /dev/null +++ b/samples/vulkan/ocean/time_spectrum.cl @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +constant float PI = 3.14159265359; +constant float G = 9.81; +constant sampler_t sampler = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST | CLK_NORMALIZED_COORDS_FALSE; + +typedef float2 complex; + +complex mul(complex c0, complex c1) +{ + return (complex)(c0.x * c1.x - c0.y * c1.y, c0.x * c1.y + c0.y * c1.x); +} + +complex add(complex c0, complex c1) +{ + return (complex)(c0.x + c1.x, c0.y + c1.y); +} + +complex conj(complex c) +{ + return (complex)(c.x, -c.y); +} + +kernel void spectrum( float dt, int2 patch_info, + read_only image2d_t src, write_only image2d_t dst_x, + write_only image2d_t dst_y, write_only image2d_t dst_z ) +{ + int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); + int res = patch_info.y; + float2 wave_vec = (float2)(uv.x - res / 2.f, uv.y - res / 2.f); + float2 k = (2.f * PI * wave_vec) / patch_info.x; + float k_mag = length(k); + + float w = sqrt(G * k_mag); + + float4 h0k = read_imagef(src, sampler, uv); + complex fourier_amp = (complex)(h0k.x, h0k.y); + complex fourier_amp_conj = conj((complex)(h0k.z, h0k.w)); + + float cos_wt = cos(w*dt); + float sin_wt = sin(w*dt); + + // euler formula + complex exp_iwt = (complex)(cos_wt, sin_wt); + complex exp_iwt_inv = (complex)(cos_wt, -sin_wt); + + // dy + complex h_k_t_dy = add(mul(fourier_amp, exp_iwt), (mul(fourier_amp_conj, exp_iwt_inv))); + + // dx + complex dx = (complex)(0.0,-k.x/k_mag); + complex h_k_t_dx = mul(dx, h_k_t_dy); + + // dz + complex dz = (complex)(0.0,-k.y/k_mag); + complex h_k_t_dz = mul(dz, h_k_t_dy); + + // amplitude + write_imagef(dst_y, uv, (float4)(h_k_t_dy.x, h_k_t_dy.y, 0, 1)); + + // choppiness + write_imagef(dst_x, uv, (float4)(h_k_t_dx.x, h_k_t_dx.y, 0, 1)); + write_imagef(dst_z, uv, (float4)(h_k_t_dz.x, h_k_t_dz.y, 0, 1)); +} diff --git a/samples/vulkan/ocean/twiddle.cl b/samples/vulkan/ocean/twiddle.cl new file mode 100644 index 00000000..4052eed4 --- /dev/null +++ b/samples/vulkan/ocean/twiddle.cl @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2024 Mobica Limited, Marcin Hajder + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +constant float PI = 3.14159265359; + +typedef float2 complex; + +kernel void generate( int resolution, global int * bit_reversed, write_only image2d_t dst ) +{ + int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); + float k = fmod(uv.y * ((float)(resolution) / pow(2.f, (float)(uv.x+1))), resolution); + complex twiddle = (complex)( cos(2.0*PI*k/(float)(resolution)), sin(2.0*PI*k/(float)(resolution))); + + int butterflyspan = (int)(pow(2.f, (float)(uv.x))); + int butterflywing; + + if (fmod(uv.y, pow(2.f, (float)(uv.x + 1))) < pow(2.f, (float)(uv.x))) + butterflywing = 1; + else + butterflywing = 0; + + // first stage, bit reversed indices + if (uv.x == 0) { + // top butterfly wing + if (butterflywing == 1) + write_imagef(dst, uv, (float4)(twiddle.x, twiddle.y, bit_reversed[(int)(uv.y)], bit_reversed[(int)(uv.y + 1)])); + // bot butterfly wing + else + write_imagef(dst, uv, (float4)(twiddle.x, twiddle.y, bit_reversed[(int)(uv.y - 1)], bit_reversed[(int)(uv.y)])); + } + // second to log2(resolution) stage + else { + // top butterfly wing + if (butterflywing == 1) + write_imagef(dst, uv, (float4)(twiddle.x, twiddle.y, uv.y, uv.y + butterflyspan)); + // bot butterfly wing + else + write_imagef(dst, uv, (float4)(twiddle.x, twiddle.y, uv.y - butterflyspan, uv.y)); + } +} From fe9c96ddb15b23aceffb6b4feb9e6286aaad4738 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Sat, 3 Aug 2024 10:06:43 +0200 Subject: [PATCH 02/18] Corrections related to code review --- samples/vulkan/ocean/fft_kernel.cl | 8 ++------ samples/vulkan/ocean/inversion.cl | 6 +++--- samples/vulkan/ocean/normals.cl | 18 +++++++++--------- samples/vulkan/ocean/ocean.cpp | 20 -------------------- samples/vulkan/ocean/ocean.hpp | 5 ----- 5 files changed, 14 insertions(+), 43 deletions(-) diff --git a/samples/vulkan/ocean/fft_kernel.cl b/samples/vulkan/ocean/fft_kernel.cl index 2976e2f2..e7c120fe 100644 --- a/samples/vulkan/ocean/fft_kernel.cl +++ b/samples/vulkan/ocean/fft_kernel.cl @@ -39,15 +39,11 @@ __kernel void fft_1D( int2 mode, int2 patch_info, int2 data_coords = (int2)(mode.y, uv.x * (1-mode.x) + uv.y * mode.x); float4 data = read_imagef(twiddle, sampler, data_coords); - - work_group_barrier(CLK_IMAGE_MEM_FENCE); - - int2 pp_coords0 = (int2)(data.z, uv.y) * (1-mode.x) + (int2)(uv.x, data.z) * mode.x; - float2 p = read_imagef(src, sampler, pp_coords0).rg; + float2 p = read_imagef(src, sampler, pp_coords0).xy; int2 pp_coords1 = (int2)(data.w, uv.y) * (1-mode.x) + (int2)(uv.x, data.w) * mode.x; - float2 q = read_imagef(src, sampler, pp_coords1).rg; + float2 q = read_imagef(src, sampler, pp_coords1).xy; float2 w = (float2)(data.x, data.y); diff --git a/samples/vulkan/ocean/inversion.cl b/samples/vulkan/ocean/inversion.cl index a8c3e196..ceec43b7 100644 --- a/samples/vulkan/ocean/inversion.cl +++ b/samples/vulkan/ocean/inversion.cl @@ -22,9 +22,9 @@ kernel void inversion( int2 patch_info, read_only image2d_t src0, int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); int res2 = patch_info.y * patch_info.y; - float x = read_imagef(src0, sampler, uv).r; - float y = read_imagef(src1, sampler, uv).r; - float z = read_imagef(src2, sampler, uv).r; + float x = read_imagef(src0, sampler, uv).x; + float y = read_imagef(src1, sampler, uv).x; + float z = read_imagef(src2, sampler, uv).x; write_imagef(dst, uv, (float4)(x/res2, y/res2, z/res2, 1)); } diff --git a/samples/vulkan/ocean/normals.cl b/samples/vulkan/ocean/normals.cl index 66af5f6d..f2398b44 100644 --- a/samples/vulkan/ocean/normals.cl +++ b/samples/vulkan/ocean/normals.cl @@ -28,15 +28,15 @@ kernel void normals( int2 patch_info, float2 scale_fac, read_only image2d_t nois float texel = 1.f / patch_info.y; - float dz_c = read_imagef(src, sampler, fuv).g; - float dz_cr = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y)).g; - float dz_ct = read_imagef(src, sampler, (float2)(fuv.x, fuv.y + texel)).g; - float dz_cl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y)).g; - float dz_cb = read_imagef(src, sampler, (float2)(fuv.x, fuv.y - texel)).g; - float dz_tr = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y + texel)).g; - float dz_br = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y - texel)).g; - float dz_tl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y + texel)).g; - float dz_bl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y - texel)).g; + float dz_c = read_imagef(src, sampler, fuv).y; + float dz_cr = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y)).y; + float dz_ct = read_imagef(src, sampler, (float2)(fuv.x, fuv.y + texel)).y; + float dz_cl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y)).y; + float dz_cb = read_imagef(src, sampler, (float2)(fuv.x, fuv.y - texel)).y; + float dz_tr = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y + texel)).y; + float dz_br = read_imagef(src, sampler, (float2)(fuv.x + texel, fuv.y - texel)).y; + float dz_tl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y + texel)).y; + float dz_bl = read_imagef(src, sampler, (float2)(fuv.x - texel, fuv.y - texel)).y; float3 normal = (float3)(0.f, 0.f, 1.f / normal_scale_fac); normal.y = dz_c + 2.f * dz_cb + dz_br - dz_tl - 2.f * dz_ct - dz_tr; diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 4cf954f3..b2f39052 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -86,26 +86,6 @@ void OceanApplication::init_openCL() check_openCL_ext_mem_support(devices[dev_opts.triplet.dev_index]); - if (app_opts.useExternalMemory) - { - clEnqueueAcquireExternalMemObjectsKHR = - (clEnqueueAcquireExternalMemObjectsKHR_fn) - clGetExtensionFunctionAddressForPlatform( - platforms[dev_opts.triplet.plat_index](), - "clEnqueueAcquireExternalMemObjectsKHR"); - clEnqueueReleaseExternalMemObjectsKHR = - (clEnqueueReleaseExternalMemObjectsKHR_fn) - clGetExtensionFunctionAddressForPlatform( - platforms[dev_opts.triplet.plat_index](), - "clEnqueueReleaseExternalMemObjectsKHR"); - if (clEnqueueAcquireExternalMemObjectsKHR == NULL - || clEnqueueReleaseExternalMemObjectsKHR == NULL) - { - throw std::runtime_error("couldn't get function pointers for " - "cl_khr_external_memory"); - } - } - int error = CL_SUCCESS; error |= clGetDeviceInfo( devices[dev_opts.triplet.dev_index](), CL_DEVICE_IMAGE2D_MAX_WIDTH, diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 7a150ae3..f267e7c8 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -199,11 +199,6 @@ class OceanApplication { std::array>, IOPT_COUNT> ocl_image_mems; - clEnqueueAcquireExternalMemObjectsKHR_fn - clEnqueueAcquireExternalMemObjectsKHR = NULL; - clEnqueueReleaseExternalMemObjectsKHR_fn - clEnqueueReleaseExternalMemObjectsKHR = NULL; - void init_window(); void init_openCL(); void init_openCL_mems(); From 6e46faffaf7bbd1bf22d49a775f6ae265bcc4653 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Sun, 4 Aug 2024 16:54:54 +0200 Subject: [PATCH 03/18] Initial corrections related to windows build --- CMakeLists.txt | 5 ++ cmake/Dependencies.cmake | 7 +++ cmake/Dependencies/glfw/glfw.cmake | 38 ++++++++++++++ samples/vulkan/CMakeLists.txt | 14 +----- samples/vulkan/ocean/normals.cl | 3 +- samples/vulkan/ocean/ocean.cpp | 78 ++++++++++++++--------------- samples/vulkan/ocean/ocean.hpp | 1 + samples/vulkan/ocean/ocean_util.hpp | 14 ++++-- 8 files changed, 102 insertions(+), 58 deletions(-) create mode 100644 cmake/Dependencies/glfw/glfw.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index cdaa68bf..568b334a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -28,6 +28,11 @@ cmake_dependent_option(OPENCL_SDK_BUILD_SAMPLES "Build sample code" ON OPENCL_SD cmake_dependent_option(OPENCL_SDK_BUILD_OPENGL_SAMPLES "Build OpenCL-OpenGL interop sample code" ON OPENCL_SDK_BUILD_SAMPLES OFF) cmake_dependent_option(OPENCL_SDK_TEST_SAMPLES "Add CTest to samples (where applicable)" ON OPENCL_SDK_BUILD_SAMPLES OFF) +find_package(Vulkan) +if(VULKAN_FOUND) + cmake_dependent_option(OPENCL_SDK_BUILD_VULKAN_SAMPLES "Build OpenCL-Vulkan interop sample code" ON OPENCL_SDK_BUILD_SAMPLES OFF) +endif() + include(CTest) if (NOT CMAKE_BUILD_TYPE) diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index f9176312..a6bcd4e1 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -17,4 +17,11 @@ if(OPENCL_SDK_BUILD_SAMPLES) include(${DEP}) endforeach() endif(OPENCL_SDK_BUILD_OPENGL_SAMPLES) + + if(OPENCL_SDK_BUILD_VULKAN_SAMPLES) + foreach(DEP IN ITEMS X11 glfw glm GLEW Freetype) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Dependencies/${DEP}") + include(${DEP}) + endforeach() + endif(OPENCL_SDK_BUILD_VULKAN_SAMPLES) endif(OPENCL_SDK_BUILD_SAMPLES) \ No newline at end of file diff --git a/cmake/Dependencies/glfw/glfw.cmake b/cmake/Dependencies/glfw/glfw.cmake new file mode 100644 index 00000000..8ac51855 --- /dev/null +++ b/cmake/Dependencies/glfw/glfw.cmake @@ -0,0 +1,38 @@ +if(NOT DEPENDENCIES_FORCE_DOWNLOAD AND NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/_deps/glfw-external-src") + find_package(glfw3 CONFIG) + # To avoid every test depening on GLFW define their deps using + # + # add_sample( + # LIBS + # $<$:glfw> + # INCLUDES + # $<$>:"${GLFW_INCLUDE_DIRS}"> + # ) + # + # we create the INTERFACE target in case it didn't exist. + if(glfw3_FOUND AND NOT TARGET glfw) + add_library(glfw INTERFACE) + target_include_directories(glfw INTERFACE "${GLFW_INCLUDE_DIRS}") + endif() +endif() + +if(NOT (glfw3_FOUND OR TARGET glfw)) + if(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/_deps/glfw-external-src") + if(DEPENDENCIES_FORCE_DOWNLOAD) + message(STATUS "DEPENDENCIES_FORCE_DOWNLOAD is ON. Fetching glfw.") + else() + message(STATUS "Fetching glfw.") + endif() + message(STATUS "Adding glfw subproject: ${CMAKE_CURRENT_BINARY_DIR}/_deps/glfw-external-src") + endif() + cmake_minimum_required(VERSION 3.11) + include(FetchContent) + set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "Build the GLFW example programs.") + set(GLFW_BUILD_TESTS OFF CACHE BOOL "Build the GLFW test programs.") + FetchContent_Declare( + glfw-external + GIT_REPOSITORY https://github.com/glfw/glfw + GIT_TAG 3.3.6 # 7d5a16ce714f0b5f4efa3262de22e4d948851525 + ) + FetchContent_MakeAvailable(glfw-external) +endif() \ No newline at end of file diff --git a/samples/vulkan/CMakeLists.txt b/samples/vulkan/CMakeLists.txt index e8855ce3..d015f2b2 100755 --- a/samples/vulkan/CMakeLists.txt +++ b/samples/vulkan/CMakeLists.txt @@ -12,19 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -find_package(Vulkan) -find_package(glfw3 HINTS "../../external") -set(BUILD_VULKAN_SAMPLES TRUE) -if(NOT VULKAN_FOUND) - message(STATUS "Skipping Vulkan Samples - Vulkan is not found.") - set(BUILD_VULKAN_SAMPLES FALSE) -endif() -if(NOT glfw3_FOUND) - message(STATUS "Skipping Vulkan Samples - GLFW is not found.") - set(BUILD_VULKAN_SAMPLES FALSE) -endif() - -if(BUILD_VULKAN_SAMPLES) +if(OPENCL_SDK_BUILD_VULKAN_SAMPLES) add_subdirectory( ocean ) endif() diff --git a/samples/vulkan/ocean/normals.cl b/samples/vulkan/ocean/normals.cl index f2398b44..be1d7a4a 100644 --- a/samples/vulkan/ocean/normals.cl +++ b/samples/vulkan/ocean/normals.cl @@ -43,6 +43,7 @@ kernel void normals( int2 patch_info, float2 scale_fac, read_only image2d_t nois normal.x = dz_c + 2.f * dz_cl + dz_tl - dz_br - 2.f * dz_cr - dz_tr; float4 n = read_imagef(noise, sampler, fuv*(float2)(4.0)); + float* pn = &n; - write_imagef(dst, uv, (float4)(normalize(normal), n[(uv.x+uv.y)%4])); + write_imagef(dst, uv, (float4)(normalize(normal), pn[(uv.x+uv.y)%4])); } diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index b2f39052..0937a0fb 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -24,10 +24,6 @@ #error cl_khr_external_memory not found, please update your OpenCL headers! #endif -#ifdef _WIN32 -#define VK_USE_PLATFORM_WIN32_KHR -#endif - #include #include #include @@ -171,20 +167,19 @@ void OceanApplication::init_openCL_mems() context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RGBA, CL_FLOAT), ocean_tex_size, ocean_tex_size); - int log_2_N = log((float)ocean_tex_size) / log(2.f); + int log_2_N = (int)(log((float)ocean_tex_size) / log(2.f)); twiddle_factors_mem = std::make_unique( context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RGBA, CL_FLOAT), log_2_N, ocean_tex_size); - for (size_t target = 0; target < IOPT_COUNT; target++) { ocl_image_mems[target].resize(swap_chain_images.size()); for (size_t i = 0; i < swap_chain_images.size(); i++) { - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { #ifdef _WIN32 HANDLE handle = NULL; @@ -192,14 +187,14 @@ void OceanApplication::init_openCL_mems() getWin32HandleInfo.sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; getWin32HandleInfo.memory = - textureImages[target].imageMemories[i]; + texture_images[target].image_memories[i]; getWin32HandleInfo.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT; vkGetMemoryWin32HandleKHR(device, &getWin32HandleInfo, &handle); const cl_mem_properties props[] = { - externalMemType, + external_mem_type, (cl_mem_properties)handle, 0, }; @@ -515,7 +510,7 @@ void OceanApplication::create_instance() appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); appInfo.pEngineName = "No Engine"; appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { appInfo.apiVersion = VK_API_VERSION_1_1; } @@ -556,7 +551,7 @@ void OceanApplication::create_instance() } #ifdef _WIN32 - if (app_opps.useExternalMemory) + if (app_opts.use_external_memory) { vkGetMemoryWin32HandleKHR = (PFN_vkGetMemoryWin32HandleKHR)vkGetInstanceProcAddr( @@ -568,7 +563,7 @@ void OceanApplication::create_instance() } } #elif defined(__linux__) - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { vkGetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR"); @@ -1112,14 +1107,14 @@ void OceanApplication::create_command_pool() void OceanApplication::create_vertex_buffers() { - int iCXY = (ocean_grid_size + 1) * (ocean_grid_size + 1); + size_t iCXY = (ocean_grid_size + 1) * (ocean_grid_size + 1); ocean_grid_vertices.resize(iCXY); - cl_float dfY = -0.5 * (ocean_grid_size * mesh_spacing), - dfBaseX = -0.5 * (ocean_grid_size * mesh_spacing); + cl_float dfY = -0.5f * (ocean_grid_size * mesh_spacing), + dfBaseX = -0.5f * (ocean_grid_size * mesh_spacing); cl_float tx = 0.f, ty = 0.f, dtx = 1.f / ocean_grid_size, dty = 1.f / ocean_grid_size; - for (int iBase = 0, iY = 0; iY <= ocean_grid_size; + for (size_t iBase = 0, iY = 0; iY <= ocean_grid_size; iY++, iBase += ocean_grid_size + 1) { tx = 0.f; @@ -1187,14 +1182,14 @@ void OceanApplication::create_index_buffers() stagingBuffer, stagingBufferMemory); // Each tri strip draws one row of NX quads - for (int iBaseTo, iBaseFrom = 0, iY = 0; iY < ocean_grid_size; + for (size_t iBaseTo, iBaseFrom = 0, iY = 0; iY < ocean_grid_size; iY++, iBaseFrom = iBaseTo) { iBaseTo = iBaseFrom + ocean_grid_size + 1; - for (int iX = 0; iX <= ocean_grid_size; iX++) + for (size_t iX = 0; iX <= ocean_grid_size; iX++) { - ocean_grid_indices[iX * 2 + 0] = iBaseFrom + iX; - ocean_grid_indices[iX * 2 + 1] = iBaseTo + iX; + ocean_grid_indices[iX * 2 + 0] = (int)(iBaseFrom + iX); + ocean_grid_indices[iX * 2 + 1] = (int)(iBaseTo + iX); } index_buffers[iY].buffers.resize(swap_chain_images.size()); @@ -1229,7 +1224,7 @@ void OceanApplication::create_texture_images() VkImageTiling tiling = app_opts.linearImages ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL; VkMemoryPropertyFlags properties = - app_opts.deviceLocalImages ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : 0; + app_opts.device_local_images ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : 0; uint32_t texWidth = static_cast(ocean_tex_size); uint32_t texHeight = static_cast(ocean_tex_size); @@ -1253,7 +1248,7 @@ void OceanApplication::create_texture_images() VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, properties, texture_images[target].images[i], texture_images[target].image_memories[i]); - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { transition_image_layout( texture_images[target].images[i], @@ -1351,7 +1346,7 @@ void OceanApplication::create_shareable_image( VkImageCreateInfo imageInfo{}; imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { imageInfo.pNext = &externalMemCreateInfo; } @@ -1383,7 +1378,7 @@ void OceanApplication::create_shareable_image( VkMemoryAllocateInfo allocInfo{}; allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { allocInfo.pNext = &exportMemoryAllocInfo; } @@ -1957,7 +1952,7 @@ void OceanApplication::update_uniforms(uint32_t currentImage) glm::mat4 view_matrix = glm::lookAt(camera.eye, camera.eye + camera.dir, camera.up); - float fov = glm::radians(60.0); + float fov = (float)glm::radians(60.0); float aspect = (float)app_opts.window_width / app_opts.window_height; glm::mat4 proj_matrix = glm::perspective( fov, aspect, 1.f, 2.f * ocean_grid_size * mesh_spacing); @@ -1995,7 +1990,7 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) { try { - size_t log_2_N = (size_t)(log(ocean_tex_size) / log(2.f)); + int log_2_N = (int)(log(ocean_tex_size) / log(2.f)); /// Prepare vector of values to extract results std::vector v(ocean_tex_size); @@ -2017,7 +2012,7 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) command_queue.enqueueNDRangeKernel( twiddle_kernel, cl::NullRange, - cl::NDRange{ log_2_N, ocean_tex_size }, cl::NDRange{ 1, 16 }); + cl::NDRange{ (cl::size_type)log_2_N, ocean_tex_size }, cl::NDRange{ 1, 16 }); twiddle_factors_init = false; } catch (const cl::Error& e) { @@ -2084,7 +2079,7 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) { const cl::Image* displ_swap[] = { dxyz_coef_mem[i].get(), hkt_pong_mem.get() }; - cl_int2 mode = (cl_int2){ 0, 0 }; + cl_int2 mode = cl_int2{ { 0, 0 } }; bool ifft_pingpong = false; for (int p = 0; p < log_2_N; p++) @@ -2147,7 +2142,7 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) } } - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { for (size_t target = 0; target < IOPT_COUNT; target++) { @@ -2204,7 +2199,7 @@ void OceanApplication::update_ocean(uint32_t currentImage) update_spectrum(currentImage, elapsed); - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { for (size_t target = 0; target < IOPT_COUNT; target++) { @@ -2261,7 +2256,7 @@ void OceanApplication::update_ocean(uint32_t currentImage) start = end - std::chrono::duration_cast(duration); - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { command_queue.finish(); } @@ -2365,17 +2360,20 @@ void OceanApplication::check_openCL_ext_mem_support(cl::Device& device) #ifdef _WIN32 - if (std::find(types.begin(), types.end(), - CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR) + if (std::find_if(types.begin(), types.end(), + [](cl::ExternalMemoryType &emt) { + return static_cast>(emt) + == CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR; + }) != types.end()) { - externalMemType = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR; + external_mem_type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR; } else { printf("Couldn't find a compatible external memory type " "(sample supports OPAQUE_WIN32).\n"); - useExternalMemory = false; + app_opts.use_external_memory = false; } #elif defined(__linux__) if (std::find( @@ -2396,14 +2394,14 @@ void OceanApplication::check_openCL_ext_mem_support(cl::Device& device) { printf("Couldn't find a compatible external memory type " "(sample supports DMA_BUF or OPAQUE_FD).\n"); - app_opts.useExternalMemory = false; + app_opts.use_external_memory = false; } #endif } else { printf("Device does not support cl_khr_external_memory.\n"); - app_opts.useExternalMemory = false; + app_opts.use_external_memory = false; } } @@ -2618,12 +2616,12 @@ std::vector OceanApplication::get_required_exts() std::vector extensions(glfwExtensions, glfwExtensions + glfwExtensionCount); - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { extensions.push_back( VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); } - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { extensions.push_back( VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME); @@ -2640,7 +2638,7 @@ std::vector OceanApplication::get_required_dev_exts() { std::vector extensions(deviceExtensions); - if (app_opts.useExternalMemory) + if (app_opts.use_external_memory) { extensions.push_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); #ifdef _WIN32 diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index f267e7c8..70878577 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -151,6 +151,7 @@ class OceanApplication { size_t current_frame = 0; #ifdef _WIN32 + using PFN_vkGetMemoryWin32HandleKHR = VkResult(VKAPI_PTR *)(VkDevice, const VkMemoryGetWin32HandleInfoKHR *, HANDLE *); PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = NULL; #elif defined(__linux__) PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = NULL; diff --git a/samples/vulkan/ocean/ocean_util.hpp b/samples/vulkan/ocean/ocean_util.hpp index d144dde9..78a9e619 100755 --- a/samples/vulkan/ocean/ocean_util.hpp +++ b/samples/vulkan/ocean/ocean_util.hpp @@ -17,6 +17,13 @@ #ifndef OCEAN_UTIL_HPP #define OCEAN_UTIL_HPP +#ifdef _WIN32 +#include +#include +#include +#define VK_USE_PLATFORM_WIN32_KHR +#endif + #include #define GLFW_INCLUDE_VULKAN #include @@ -127,7 +134,7 @@ static const char* IGetErrorString(int clErrorCode) static uint32_t reverse_bits(uint32_t n, uint32_t log_2_N) { uint32_t r = 0; - for (int j = 0; j < log_2_N; j++) + for (uint32_t j = 0; j < log_2_N; j++) { r = (r << 1) + (n & 1); n >>= 1; @@ -264,9 +271,8 @@ struct CliOptions bool immediate = false; bool linearImages = false; - bool deviceLocalImages = true; - - bool useExternalMemory = true; + bool device_local_images = true; + bool use_external_memory = true; }; #endif // OCEAN_UTIL_HPP From c4ac729268c0a23b5911983fccf12d60b0cd3abf Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Mon, 5 Aug 2024 19:21:59 +0200 Subject: [PATCH 04/18] More corrections related to gltf configuration, general cleanup --- cmake/Dependencies.cmake | 23 +++++++++++++++-------- cmake/Dependencies/glfw/glfw.cmake | 10 +++++++++- samples/vulkan/ocean/main.cpp | 11 ++++++++--- samples/vulkan/ocean/ocean.cpp | 12 ++++++------ samples/vulkan/ocean/ocean_util.hpp | 1 + 5 files changed, 39 insertions(+), 18 deletions(-) diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index a6bcd4e1..91baeeee 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -16,12 +16,19 @@ if(OPENCL_SDK_BUILD_SAMPLES) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Dependencies/${DEP}") include(${DEP}) endforeach() - endif(OPENCL_SDK_BUILD_OPENGL_SAMPLES) + if(OPENCL_SDK_BUILD_VULKAN_SAMPLES) + foreach(DEP IN ITEMS X11 glfw) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Dependencies/${DEP}") + include(${DEP}) + endforeach() + endif(OPENCL_SDK_BUILD_VULKAN_SAMPLES) + else() + if(OPENCL_SDK_BUILD_VULKAN_SAMPLES) + foreach(DEP IN ITEMS X11 glm glfw) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Dependencies/${DEP}") + include(${DEP}) + endforeach() + endif(OPENCL_SDK_BUILD_VULKAN_SAMPLES) +endif(OPENCL_SDK_BUILD_OPENGL_SAMPLES) - if(OPENCL_SDK_BUILD_VULKAN_SAMPLES) - foreach(DEP IN ITEMS X11 glfw glm GLEW Freetype) - list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Dependencies/${DEP}") - include(${DEP}) - endforeach() - endif(OPENCL_SDK_BUILD_VULKAN_SAMPLES) -endif(OPENCL_SDK_BUILD_SAMPLES) \ No newline at end of file +endif(OPENCL_SDK_BUILD_SAMPLES) diff --git a/cmake/Dependencies/glfw/glfw.cmake b/cmake/Dependencies/glfw/glfw.cmake index 8ac51855..5849a4d1 100644 --- a/cmake/Dependencies/glfw/glfw.cmake +++ b/cmake/Dependencies/glfw/glfw.cmake @@ -35,4 +35,12 @@ if(NOT (glfw3_FOUND OR TARGET glfw)) GIT_TAG 3.3.6 # 7d5a16ce714f0b5f4efa3262de22e4d948851525 ) FetchContent_MakeAvailable(glfw-external) -endif() \ No newline at end of file + set_target_properties(glfw + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}" + ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}" + LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}" + INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}" + FOLDER "Dependencies" + ) +endif() diff --git a/samples/vulkan/ocean/main.cpp b/samples/vulkan/ocean/main.cpp index fbf62254..6b735a1a 100755 --- a/samples/vulkan/ocean/main.cpp +++ b/samples/vulkan/ocean/main.cpp @@ -71,6 +71,9 @@ template <> auto cl::sdk::parse() std::make_shared>("", "window_height", "Window height", false, 1024, "positive integral"), + std::make_shared>( + "", "vulkan_device", "Vulkan physical device", false, -1, + "integral number"), std::make_shared>( "", "immediate", "Prefer VK_PRESENT_MODE_IMMEDIATE_KHR (no vsync)", false, false, "boolean"), @@ -88,15 +91,17 @@ template <> CliOptions cl::sdk::comprehend( std::shared_ptr> window_width, std::shared_ptr> window_height, + std::shared_ptr> vulkan_device, std::shared_ptr> immediate, std::shared_ptr> linearImages, std::shared_ptr> deviceLocalImages, std::shared_ptr> useExternalMemory) { return CliOptions{ - window_width->getValue(), window_height->getValue(), - immediate->getValue(), linearImages->getValue(), - deviceLocalImages->getValue(), useExternalMemory->getValue() + window_width->getValue(), window_height->getValue(), + vulkan_device->getValue(), immediate->getValue(), + linearImages->getValue(), deviceLocalImages->getValue(), + useExternalMemory->getValue() }; } diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 0937a0fb..521594bd 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -626,11 +626,14 @@ void OceanApplication::pick_physical_device() std::vector devices(deviceCount); vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data()); - for (const auto& device : devices) + for (auto i = 0; i < devices.size(); i++) { - if (is_device_suitable(device)) + if (app_opts.vulkan_device >= 0 && app_opts.vulkan_device != i) + continue; + + if (is_device_suitable(devices[i])) { - physical_device = device; + physical_device = devices[i]; break; } } @@ -2543,9 +2546,6 @@ bool OceanApplication::check_device_extension_support(VkPhysicalDevice device) VkPhysicalDeviceProperties pProperties; vkGetPhysicalDeviceProperties(device, &pProperties); - if (std::string(pProperties.deviceName).find("Intel") != std::string::npos) - return false; - uint32_t extensionCount; vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr); diff --git a/samples/vulkan/ocean/ocean_util.hpp b/samples/vulkan/ocean/ocean_util.hpp index 78a9e619..72608ed3 100755 --- a/samples/vulkan/ocean/ocean_util.hpp +++ b/samples/vulkan/ocean/ocean_util.hpp @@ -267,6 +267,7 @@ struct CliOptions { size_t window_width = 1024; size_t window_height = 1024; + std::int32_t vulkan_device = -1; bool immediate = false; From f6d6ae2f0330001b1504fa38593d6f0d741cf6f3 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Tue, 6 Aug 2024 15:01:59 +0200 Subject: [PATCH 05/18] Several corrections: -added support of FPS in title bar of main window -corrected reading shaders/kernels with cl::util::read_exe_relative_text_file -complemented readme --- samples/vulkan/ocean/README.md | 15 +++++- samples/vulkan/ocean/ocean.cpp | 95 ++++++++++++++++++++++------------ samples/vulkan/ocean/ocean.hpp | 16 ++++-- 3 files changed, 86 insertions(+), 40 deletions(-) diff --git a/samples/vulkan/ocean/README.md b/samples/vulkan/ocean/README.md index e8246724..a92c1295 100755 --- a/samples/vulkan/ocean/README.md +++ b/samples/vulkan/ocean/README.md @@ -20,6 +20,16 @@ The application performs an initial setup during which: -A GLFW window, camera, and related keyboard event callbacks are created. -Both shared and private resources for OpenCL and Vulkan are set up. +Available CLI options are as follows: + + --window_width, specifies initial window width + --window_height, specifies initial window window_height + --vulkan_device, requests number of vulkan physical device + --immediate, requests preference of VK_PRESENT_MODE_IMMEDIATE_KHR (no vsync) + --linear, requests use of linearly tiled images + --deviceLocalImages, requests use of device local images + --useExternalMemory, requests use of cl_khr_external_memory + After the setup, the simulation starts with initial ocean parameters that can be modified with keyboard events in real-time: - a/z - Increase/decrease wind magnitude. @@ -28,7 +38,9 @@ After the setup, the simulation starts with initial ocean parameters that can be - f/v - Increase/decrease wave choppiness. - g/b - Increase/decrease additional altitude scale. -Additionally, the simulation and rendering can be paused with the Space key. Rendering can toggle between wireframe and filled modes using the 'w' key. While the simulation is in progress, each frame of the application performs the following general steps: +Additionally, the simulation and rendering can be paused with the Space key. Rendering can toggle between wireframe and filled modes using the 'w' key. Application tracks its performance in the title bar of the window, it could be toggled by pressing 'e' key. + +While the simulation is in progress, each frame of the application performs the following general steps: -Necessary Vulkan/OpenCL semaphores are signaled/waited. -Uniform buffers are updated to handle camera and ocean parameters. @@ -44,6 +56,7 @@ Multiple kernels follow the general steps (with multiple optimizations) describe ```c++ cl::util::supports_extension(cl::Device, cl::string) +cl::util::read_exe_relative_text_file(const char*, cl_int* const) cl::Context(cl::Device) cl::CommandQueue(cl::Context, cl::Device) cl::Platform::get(vector) diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 521594bd..e3c0df1a 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -57,9 +57,9 @@ void OceanApplication::init_window() glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); - window = glfwCreateWindow( - (int)app_opts.window_width, (int)app_opts.window_height, - "Ocean surface simulation with OpenCL and Vulkan", nullptr, nullptr); + window = glfwCreateWindow((int)app_opts.window_width, + (int)app_opts.window_height, app_name.c_str(), + nullptr, nullptr); glfwSetWindowUserPointer(window, this); } @@ -103,7 +103,8 @@ void OceanApplication::init_openCL() const char* name) { try { - std::string kernel_code = read_file(src_file).data(); + std::string kernel_code = + cl::util::read_exe_relative_text_file(src_file); cl::Program program{ context, kernel_code }; program.build(); kernel = cl::Kernel{ program, name }; @@ -112,7 +113,7 @@ void OceanApplication::init_openCL() auto bl = e.getBuildLog(); std::cout << "Build OpenCL " << name << " kernel error: " << std::endl; - for (auto elem : bl) std::cout << elem.second << std::endl; + for (auto& elem : bl) std::cout << elem.second << std::endl; exit(1); } }; @@ -331,6 +332,11 @@ void OceanApplication::keyboard(int key, int scancode, int action, int mods) wireframe_mode = !wireframe_mode; create_command_buffers(); break; + + case GLFW_KEY_E: + show_fps = !show_fps; + if (!show_fps) glfwSetWindowTitle(window, app_name.c_str()); + break; } } } @@ -912,8 +918,10 @@ void OceanApplication::create_descriptor_det_layout() void OceanApplication::create_graphics_pipeline() { - auto vertShaderCode = read_file("ocean.vert.spv"); - auto fragShaderCode = read_file("ocean.frag.spv"); + auto vertShaderCode = + cl::util::read_exe_relative_text_file("ocean.vert.spv"); + auto fragShaderCode = + cl::util::read_exe_relative_text_file("ocean.frag.spv"); VkShaderModule vertShaderModule = create_shader_module(vertShaderCode); VkShaderModule fragShaderModule = create_shader_module(fragShaderCode); @@ -2015,7 +2023,8 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) command_queue.enqueueNDRangeKernel( twiddle_kernel, cl::NullRange, - cl::NDRange{ (cl::size_type)log_2_N, ocean_tex_size }, cl::NDRange{ 1, 16 }); + cl::NDRange{ (cl::size_type)log_2_N, ocean_tex_size }, + cl::NDRange{ 1, 16 }); twiddle_factors_init = false; } catch (const cl::Error& e) { @@ -2186,8 +2195,43 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) } } +void OceanApplication::show_fps_window_title() +{ + if (show_fps) + { + auto fps_now = std::chrono::system_clock::now(); + + std::chrono::duration elapsed = fps_now - fps_last_time; + float delta = elapsed.count(); + + const float elapsed_tres = 1.f; + + delta_frames++; + if (window && delta >= 1.f) + { + double fps = double(delta_frames) / delta; + + std::stringstream ss; + ss << app_name << ", [FPS:" << std::fixed << std::setprecision(2) + << fps << "]"; + + glfwSetWindowTitle(window, ss.str().c_str()); + + delta_frames = 0; + fps_last_time = fps_now; + } + } + else + { + fps_last_time = std::chrono::system_clock::now(); + delta_frames = 0; + } +} + void OceanApplication::update_ocean(uint32_t currentImage) { + show_fps_window_title(); + update_uniforms(currentImage); auto end = std::chrono::system_clock::now(); @@ -2363,11 +2407,14 @@ void OceanApplication::check_openCL_ext_mem_support(cl::Device& device) #ifdef _WIN32 - if (std::find_if(types.begin(), types.end(), - [](cl::ExternalMemoryType &emt) { - return static_cast>(emt) + if (std::find_if( + types.begin(), types.end(), + [](cl::ExternalMemoryType& emt) { + return static_cast< + std::underlying_type_t>( + emt) == CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR; - }) + }) != types.end()) { external_mem_type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR; @@ -2408,13 +2455,12 @@ void OceanApplication::check_openCL_ext_mem_support(cl::Device& device) } } -VkShaderModule -OceanApplication::create_shader_module(const std::vector& code) +VkShaderModule OceanApplication::create_shader_module(const std::string& code) { VkShaderModuleCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; createInfo.codeSize = code.size(); - createInfo.pCode = reinterpret_cast(code.data()); + createInfo.pCode = reinterpret_cast(code.c_str()); VkShaderModule shaderModule; if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) @@ -2681,25 +2727,6 @@ bool OceanApplication::check_validation_layer_support() return true; } -std::vector OceanApplication::read_file(const std::string& filename) -{ - std::ifstream file(filename, std::ios::ate | std::ios::binary); - - if (!file.is_open()) - { - throw std::runtime_error("failed to open file!"); - } - - size_t fileSize = (size_t)file.tellg(); - if (filename.find(".spv") == std::string::npos) fileSize += 1; - std::vector buffer(fileSize, '\0'); - - file.seekg(0); - file.read(buffer.data(), fileSize); - file.close(); - return buffer; -} - VKAPI_ATTR VkBool32 VKAPI_CALL OceanApplication::debug_callback( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 70878577..37dd1b45 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -34,8 +34,9 @@ class OceanApplication { CliOptions app_opts; private: - GLFWwindow* window; + GLFWwindow* window = nullptr; Camera camera; + std::string app_name = "Ocean Surface Simulation"; // ocean texture size - assume uniform x/y size_t ocean_tex_size = 512; @@ -50,6 +51,7 @@ class OceanApplication { float mesh_spacing = 2.f; bool animate = true; + bool show_fps = true; // ocean parameters changed - rebuild initial spectrum resources bool changed = true; @@ -72,6 +74,10 @@ class OceanApplication { std::chrono::system_clock::time_point start = std::chrono::system_clock::now(); + std::chrono::system_clock::time_point fps_last_time = + std::chrono::system_clock::now(); + int delta_frames = 0; + VkInstance instance; VkDebugUtilsMessengerEXT debug_messenger; VkSurfaceKHR surface; @@ -151,7 +157,8 @@ class OceanApplication { size_t current_frame = 0; #ifdef _WIN32 - using PFN_vkGetMemoryWin32HandleKHR = VkResult(VKAPI_PTR *)(VkDevice, const VkMemoryGetWin32HandleInfoKHR *, HANDLE *); + using PFN_vkGetMemoryWin32HandleKHR = VkResult(VKAPI_PTR*)( + VkDevice, const VkMemoryGetWin32HandleInfoKHR*, HANDLE*); PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = NULL; #elif defined(__linux__) PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = NULL; @@ -280,6 +287,7 @@ class OceanApplication { void create_sync_objects(); void update_uniforms(uint32_t currentImage); + void show_fps_window_title(); void update_spectrum(uint32_t currentImage, float elapsed); void update_ocean(uint32_t currentImage); @@ -287,7 +295,7 @@ class OceanApplication { void check_openCL_ext_mem_support(cl::Device& device); - VkShaderModule create_shader_module(const std::vector& code); + VkShaderModule create_shader_module(const std::string& code); VkSurfaceFormatKHR choose_swap_surf_format( const std::vector& availableFormats); @@ -311,8 +319,6 @@ class OceanApplication { bool check_validation_layer_support(); - std::vector read_file(const std::string& filename); - static VKAPI_ATTR VkBool32 VKAPI_CALL debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, From fa77eb92a01306bee09c5e17556e28bc759cf0af Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Thu, 8 Aug 2024 09:25:26 +0200 Subject: [PATCH 06/18] Corrected bug --- samples/vulkan/ocean/ocean.cpp | 11 +++++------ samples/vulkan/ocean/ocean.hpp | 2 +- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index e3c0df1a..ea06aa2b 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -918,10 +918,8 @@ void OceanApplication::create_descriptor_det_layout() void OceanApplication::create_graphics_pipeline() { - auto vertShaderCode = - cl::util::read_exe_relative_text_file("ocean.vert.spv"); - auto fragShaderCode = - cl::util::read_exe_relative_text_file("ocean.frag.spv"); + auto vertShaderCode = cl::util::read_binary_file("ocean.vert.spv"); + auto fragShaderCode = cl::util::read_binary_file("ocean.frag.spv"); VkShaderModule vertShaderModule = create_shader_module(vertShaderCode); VkShaderModule fragShaderModule = create_shader_module(fragShaderCode); @@ -2455,12 +2453,13 @@ void OceanApplication::check_openCL_ext_mem_support(cl::Device& device) } } -VkShaderModule OceanApplication::create_shader_module(const std::string& code) +VkShaderModule +OceanApplication::create_shader_module(const std::vector& code) { VkShaderModuleCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; createInfo.codeSize = code.size(); - createInfo.pCode = reinterpret_cast(code.c_str()); + createInfo.pCode = reinterpret_cast(code.data()); VkShaderModule shaderModule; if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 37dd1b45..06ff56aa 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -295,7 +295,7 @@ class OceanApplication { void check_openCL_ext_mem_support(cl::Device& device); - VkShaderModule create_shader_module(const std::string& code); + VkShaderModule create_shader_module(const std::vector& code); VkSurfaceFormatKHR choose_swap_surf_format( const std::vector& availableFormats); From 230a112acf609a0129864398ae98be8427d266db Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Thu, 8 Aug 2024 19:42:45 +0200 Subject: [PATCH 07/18] Correction for previous commit --- lib/include/CL/Utils/File.hpp | 3 +++ lib/src/Utils/File.cpp | 24 ++++++++++++++++++++++++ samples/vulkan/ocean/README.md | 1 + samples/vulkan/ocean/ocean.cpp | 6 ++++-- 4 files changed, 32 insertions(+), 2 deletions(-) diff --git a/lib/include/CL/Utils/File.hpp b/lib/include/CL/Utils/File.hpp index b34b0bb7..d5dcf382 100644 --- a/lib/include/CL/Utils/File.hpp +++ b/lib/include/CL/Utils/File.hpp @@ -32,5 +32,8 @@ namespace util { std::string UTILSCPP_EXPORT read_exe_relative_text_file( const char* const filename, cl_int* const error = nullptr); + + std::vector UTILSCPP_EXPORT read_exe_relative_binary_file( + const char* const filename, cl_int* const error = nullptr); } } diff --git a/lib/src/Utils/File.cpp b/lib/src/Utils/File.cpp index 77c00c9f..ff4177ec 100644 --- a/lib/src/Utils/File.cpp +++ b/lib/src/Utils/File.cpp @@ -170,3 +170,27 @@ std::string cl::util::read_exe_relative_text_file(const char* const filename, } return result; } + +std::vector +cl::util::read_exe_relative_binary_file(const char* const filename, + cl_int* const error) +{ + std::vector result; + cl_int err = CL_SUCCESS; + std::string exe_folder = executable_folder(&err); + if (err != CL_SUCCESS) + { + detail::errHandler(CL_UTIL_FILE_OPERATION_ERROR, error, + "Failed to query exe folder!"); + return result; + } + result = read_binary_file((exe_folder + "/" + filename).c_str(), &err); + if (err != CL_SUCCESS) + { + result.clear(); + detail::errHandler(CL_UTIL_FILE_OPERATION_ERROR, error, + "Unable to read file!"); + return result; + } + return result; +} diff --git a/samples/vulkan/ocean/README.md b/samples/vulkan/ocean/README.md index a92c1295..35d84804 100755 --- a/samples/vulkan/ocean/README.md +++ b/samples/vulkan/ocean/README.md @@ -57,6 +57,7 @@ Multiple kernels follow the general steps (with multiple optimizations) describe ```c++ cl::util::supports_extension(cl::Device, cl::string) cl::util::read_exe_relative_text_file(const char*, cl_int* const) +cl::util::read_exe_relative_binary_file(const char*, cl_int* const) cl::Context(cl::Device) cl::CommandQueue(cl::Context, cl::Device) cl::Platform::get(vector) diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index ea06aa2b..1fdc7c8e 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -918,8 +918,10 @@ void OceanApplication::create_descriptor_det_layout() void OceanApplication::create_graphics_pipeline() { - auto vertShaderCode = cl::util::read_binary_file("ocean.vert.spv"); - auto fragShaderCode = cl::util::read_binary_file("ocean.frag.spv"); + auto vertShaderCode = + cl::util::read_exe_relative_binary_file("ocean.vert.spv"); + auto fragShaderCode = + cl::util::read_exe_relative_binary_file("ocean.frag.spv"); VkShaderModule vertShaderModule = create_shader_module(vertShaderCode); VkShaderModule fragShaderModule = create_shader_module(fragShaderCode); From 9de8894c8127f012f679c55b7333c30833b6c6f8 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Sun, 15 Sep 2024 22:17:53 +0200 Subject: [PATCH 08/18] cosmetic corrections of visual parameters --- samples/vulkan/ocean/ocean.frag | 8 ++++---- samples/vulkan/ocean/ocean.frag.spv | Bin 7448 -> 7464 bytes samples/vulkan/ocean/ocean.hpp | 2 +- samples/vulkan/ocean/ocean.vert | 6 +++--- samples/vulkan/ocean/ocean.vert.spv | Bin 2524 -> 2524 bytes 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/samples/vulkan/ocean/ocean.frag b/samples/vulkan/ocean/ocean.frag index bbee8e98..4ee59fc8 100755 --- a/samples/vulkan/ocean/ocean.frag +++ b/samples/vulkan/ocean/ocean.frag @@ -82,8 +82,8 @@ void main() float f0 = clamp(abs(dot(n0, n2) * (-0.5) + 0.5), 0.0, 1.0); float f1 = clamp(abs(dot(n1, n3) * (-0.5) + 0.5), 0.0, 1.0); - f0 = pow(f0 * 8.0, 2.0); - f1 = pow(f1 * 8.0, 2.0); + f0 = pow(f0 * 5.0, 2.0); + f1 = pow(f1 * 5.0, 2.0); float foam_fac = ndata.w * clamp(max(f0, f1), 0.0, 1.0); @@ -116,6 +116,6 @@ void main() float fresnel = clamp(pow( 1.0 + n_dot_e, -fresnel_approx_pow_factor ) * dyna_range, 0.0, 1.0); vec3 bright = fresnel * ocean_bright; vec3 water = (1.0 - fresnel) * ocean_dark * ocean_bright * diffuse; - vec3 color = bright + water + specular + vec3(foam_fac); - out_color = vec4(hdr(color, exposure), 1.0); + vec3 color = bright + water + specular; + out_color = vec4(hdr(color, exposure) + vec3(foam_fac), 1.0); } diff --git a/samples/vulkan/ocean/ocean.frag.spv b/samples/vulkan/ocean/ocean.frag.spv index 3cede6b80a2e2ce3d350221223fb0c4d4e6ee02b..eb331eca04dcd9e67eae551570390e2e945ec421 100755 GIT binary patch delta 1567 zcmYk6OHWf#6ot>dZD|Xwh>8e`plCrrR2+#G(8QSo80o;ops9}pL@UJMjWJF&24mEb zLlQ@(e?X1HGGgM?#Kbr-K6&|GUpc$>raO17wb$KepI09Z%@1W`VOP?*z%{s(JA6NT zI>c}Z>g!Fqdxi~sElhxYvgRMwlu#9F$fmHzYBqLk*7&%pUe6f%Od4;W1Oqiz3 z6BoyaKBno=WI`C-0&h~|yE=&+XAI1)?6ox)y0^ls{%wP$DLUBYa`y2-gc;`q=Rgv*6y{(Zt|XaIfCoiX;9E^a*EG7Z167%cu3aunS%W1lD}J_k>B7ZXi}(id>yxvEqE-2J@pCg%GgaPTIq{jf z*)#vOr1eX?GFhCQj>qK7&l7z?kSo7SPKTi#nLm|!Sz1+cv2tuIZ;htH?7ITZV?f0; zivLmQchtGIpx^kI^K``Rne$fh#Y&}?Un~CTVS3!xStmYkRx*qvec)!{J1>?GJ8z5l z+=%ln;#WtSM}4ApamL^y*R6v4^h~I{R>h&1(;+mUXOH+|rQDx>5=_v2HjlSSPr6^v z>3%(@`}LeoJ5OtTzTDH&)m-{0sElc5?)f=)bY~a&x$q$dPWM`7X{;! z3i25(g8o(E^Wr(J@OhSnnMa;dZLx0>SS+L6F~N$02?iAu$sjzV>d<>V$x|qM`k{DR z$A1dHQQV6Q|0RqE-3$CJ9B6&Z31GNim;4(gt6jm!&AJs&7N{!nROg)vg(=EC32}Vr z$F&`bObVlW;7w_LYmms5#=!0>H7&H)!mCz&`eG^h=+uq4peAwJiSD~=7S=yHR`OhZ zFRn$HJg-m5+ntf1zpkDc2D-td6vWjd?**(8M!U@pJ<+aGJ8wBy=4U!Kk(iA=x%41VT(iiXN3+Lsdl E0Kp53Q2+n{ diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 06ff56aa..0efd6905 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -60,7 +60,7 @@ class OceanApplication { // ocean in-factors float wind_magnitude = 300.f; float wind_angle = 45.f; - float choppiness = 30.f; + float choppiness = 10.f; float alt_scale = 20.f; float amplitude = 80.f; diff --git a/samples/vulkan/ocean/ocean.vert b/samples/vulkan/ocean/ocean.vert index a5d7bdfe..ee1e2175 100755 --- a/samples/vulkan/ocean/ocean.vert +++ b/samples/vulkan/ocean/ocean.vert @@ -32,9 +32,9 @@ layout(std140, set = 0, binding = 2) uniform ViewData { void main() { - vec3 displ = texture(u_displacement_map, in_tex_coords).rgb; - displ.xz *= view.choppiness; - displ.y *= view.alt_scale; + vec3 displ = texture(u_displacement_map, in_tex_coords).rbg; + displ.xy *= view.choppiness; + displ.z *= view.alt_scale; vec3 ocean_vert = in_position + displ; ec_pos = view.view_mat * vec4(ocean_vert, 1.0); gl_Position = view.proj_mat * ec_pos; diff --git a/samples/vulkan/ocean/ocean.vert.spv b/samples/vulkan/ocean/ocean.vert.spv index 239201b498fc4d3fef035f81b81b842aaf492dac..a5ac0598d3acf892bdae3cae7ea75c50566de7e8 100755 GIT binary patch delta 42 ycmca3d`Eag4l5($f?%me`W?g~2q delta 42 ycmca3d`Eag4l5(m Date: Wed, 6 Nov 2024 11:06:03 +0100 Subject: [PATCH 09/18] removed obsolete define checks --- samples/vulkan/ocean/ocean.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 1fdc7c8e..52f68159 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -2393,10 +2393,6 @@ void OceanApplication::check_openCL_ext_mem_support(cl::Device& device) CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR); CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR); CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR); - CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_D3D11_TEXTURE_KHR); - CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_D3D11_TEXTURE_KMT_KHR); - CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_D3D12_HEAP_KHR); - CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_D3D12_RESOURCE_KHR); CASE_TO_STRING(CL_EXTERNAL_MEMORY_HANDLE_DMA_BUF_KHR); default: printf("Unknown cl_external_memory_handle_type_khr %04X\n", From 1903f0ddba66f6553ff3b99f15dbcd2bcc2f023a Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Fri, 6 Dec 2024 15:11:54 +0100 Subject: [PATCH 10/18] Added number of optimization and cosmetic fixes --- samples/vulkan/ocean/init_spectrum.cl | 2 +- samples/vulkan/ocean/ocean.cpp | 90 ++++++++++++--------------- samples/vulkan/ocean/ocean.hpp | 4 +- samples/vulkan/ocean/time_spectrum.cl | 2 +- 4 files changed, 44 insertions(+), 54 deletions(-) diff --git a/samples/vulkan/ocean/init_spectrum.cl b/samples/vulkan/ocean/init_spectrum.cl index 8e6e47e2..1d1b99cb 100644 --- a/samples/vulkan/ocean/init_spectrum.cl +++ b/samples/vulkan/ocean/init_spectrum.cl @@ -41,7 +41,7 @@ kernel void init_spectrum( int2 patch_info, float4 params, read_only image2d_t n int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); int res = patch_info.y; - float2 fuv = (float2)(get_global_id(0), get_global_id(1)) - (float)(res)/2.f; + float2 fuv = convert_float2(uv) - (float2)((float)(res-1)/2.f); float2 k = (2.f * PI * fuv) / patch_info.x; float k_mag = length(k); diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 52f68159..be3bc9cf 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -168,7 +168,7 @@ void OceanApplication::init_openCL_mems() context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RGBA, CL_FLOAT), ocean_tex_size, ocean_tex_size); - int log_2_N = (int)(log((float)ocean_tex_size) / log(2.f)); + size_t log_2_N = (size_t)((log((float)ocean_tex_size) / log(2.f)) - 1); twiddle_factors_mem = std::make_unique( context, CL_MEM_READ_WRITE, cl::ImageFormat(CL_RGBA, CL_FLOAT), @@ -449,20 +449,14 @@ void OceanApplication::cleanup() } // cleanup indices buffers - for (auto& ind_buffer : index_buffers) + for (auto buffer : index_buffer.buffers) { - for (auto buffer : ind_buffer.buffers) - { - vkDestroyBuffer(device, buffer, nullptr); - } + vkDestroyBuffer(device, buffer, nullptr); } - for (auto& ind_buffer : index_buffers) + for (auto& bufferMemory : index_buffer.buffer_memories) { - for (auto& bufferMemory : ind_buffer.buffer_memories) - { - vkFreeMemory(device, bufferMemory, nullptr); - } + vkFreeMemory(device, bufferMemory, nullptr); } for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) @@ -960,7 +954,7 @@ void OceanApplication::create_graphics_pipeline() inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - inputAssembly.primitiveRestartEnable = VK_FALSE; + inputAssembly.primitiveRestartEnable = VK_TRUE; VkViewport viewport{}; viewport.x = 0.0f; @@ -1178,9 +1172,8 @@ void OceanApplication::create_vertex_buffers() void OceanApplication::create_index_buffers() { - index_buffers.resize(ocean_grid_size); - // Add Tri Strip primitve sets - ocean_grid_indices.resize((ocean_grid_size + 1) * 2); + size_t totalIndices = ((ocean_grid_size + 1) * 2 + 1) * ocean_grid_size; + ocean_grid_indices.resize(totalIndices); VkDeviceSize bufferSize = sizeof(ocean_grid_indices[0]) * ocean_grid_indices.size(); @@ -1192,40 +1185,39 @@ void OceanApplication::create_index_buffers() | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory); - // Each tri strip draws one row of NX quads - for (size_t iBaseTo, iBaseFrom = 0, iY = 0; iY < ocean_grid_size; - iY++, iBaseFrom = iBaseTo) + size_t indexCount = 0; + for (size_t iY = 0; iY < ocean_grid_size; iY++) { - iBaseTo = iBaseFrom + ocean_grid_size + 1; + size_t iBaseFrom = iY * (ocean_grid_size + 1); + size_t iBaseTo = iBaseFrom + ocean_grid_size + 1; + for (size_t iX = 0; iX <= ocean_grid_size; iX++) { - ocean_grid_indices[iX * 2 + 0] = (int)(iBaseFrom + iX); - ocean_grid_indices[iX * 2 + 1] = (int)(iBaseTo + iX); + ocean_grid_indices[indexCount++] = static_cast(iBaseFrom + iX); + ocean_grid_indices[indexCount++] = static_cast(iBaseTo + iX); } + ocean_grid_indices[indexCount++] = -1; + } - index_buffers[iY].buffers.resize(swap_chain_images.size()); - index_buffers[iY].buffer_memories.resize(swap_chain_images.size()); - - void* data; - vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data); - memcpy(data, ocean_grid_indices.data(), (size_t)bufferSize); - vkUnmapMemory(device, stagingBufferMemory); + void* data; + vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data); + memcpy(data, ocean_grid_indices.data(), (size_t)bufferSize); + vkUnmapMemory(device, stagingBufferMemory); - for (size_t i = 0; i < swap_chain_images.size(); i++) - { + index_buffer.buffers.resize(swap_chain_images.size()); + index_buffer.buffer_memories.resize(swap_chain_images.size()); - // create local memory buffer - create_buffer(bufferSize, - VK_BUFFER_USAGE_TRANSFER_DST_BIT - | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - index_buffers[iY].buffers[i], - index_buffers[iY].buffer_memories[i]); + for (size_t i = 0; i < swap_chain_images.size(); i++) + { + create_buffer(bufferSize, + VK_BUFFER_USAGE_TRANSFER_DST_BIT + | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + index_buffer.buffers[i], index_buffer.buffer_memories[i]); - copy_buffer(stagingBuffer, index_buffers[iY].buffers[i], - bufferSize); - } + copy_buffer(stagingBuffer, index_buffer.buffers[i], bufferSize); } + vkDestroyBuffer(device, stagingBuffer, nullptr); vkFreeMemory(device, stagingBufferMemory, nullptr); } @@ -1900,14 +1892,11 @@ void OceanApplication::create_command_buffers() command_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &descriptor_sets[i], 0, nullptr); - for (auto& ind_buffer : index_buffers) - { - vkCmdBindIndexBuffer(command_buffers[i], ind_buffer.buffers[i], 0, - VK_INDEX_TYPE_UINT32); - vkCmdDrawIndexed(command_buffers[i], - static_cast(ocean_grid_indices.size()), - 1, 0, 0, 0); - } + vkCmdBindIndexBuffer(command_buffers[i], index_buffer.buffers[i], 0, + VK_INDEX_TYPE_UINT32); + vkCmdDrawIndexed(command_buffers[i], + static_cast(ocean_grid_indices.size()), 1, 0, + 0, 0); vkCmdEndRenderPass(command_buffers[i]); @@ -2001,7 +1990,8 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) { try { - int log_2_N = (int)(log(ocean_tex_size) / log(2.f)); + size_t log_2_N = + (size_t)((log((float)ocean_tex_size) / log(2.f)) - 1); /// Prepare vector of values to extract results std::vector v(ocean_tex_size); @@ -2084,7 +2074,7 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) // perform 1D FFT horizontal and vertical iterations - size_t log_2_N = (size_t)(log(ocean_tex_size) / log(2.f)); + size_t log_2_N = (size_t)((log((float)ocean_tex_size) / log(2.f)) - 1); fft_kernel.setArg(1, patch); fft_kernel.setArg(2, *twiddle_factors_mem); for (cl_int i = 0; i < 3; i++) diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 0efd6905..71774f49 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -58,7 +58,7 @@ class OceanApplication { bool twiddle_factors_init = true; // ocean in-factors - float wind_magnitude = 300.f; + float wind_magnitude = 30.f; float wind_angle = 45.f; float choppiness = 10.f; float alt_scale = 20.f; @@ -141,7 +141,7 @@ class OceanApplication { std::vector buffers; std::vector buffer_memories; }; - std::vector index_buffers; + IndexBuffer index_buffer; std::array texture_sampler; diff --git a/samples/vulkan/ocean/time_spectrum.cl b/samples/vulkan/ocean/time_spectrum.cl index d35036af..ad02bf22 100644 --- a/samples/vulkan/ocean/time_spectrum.cl +++ b/samples/vulkan/ocean/time_spectrum.cl @@ -41,7 +41,7 @@ kernel void spectrum( float dt, int2 patch_info, { int2 uv = (int2)((int)get_global_id(0), (int)get_global_id(1)); int res = patch_info.y; - float2 wave_vec = (float2)(uv.x - res / 2.f, uv.y - res / 2.f); + float2 wave_vec = convert_float2(uv) - (float2)((float)(res-1)/2.f); float2 k = (2.f * PI * wave_vec) / patch_info.x; float k_mag = length(k); From 1f69d0511ec11798fa12eb4bff7c703ec0d29f3f Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Thu, 12 Dec 2024 17:40:44 +0100 Subject: [PATCH 11/18] More cosmetic improvements around options --- samples/vulkan/ocean/main.cpp | 26 +++++++++++--------------- samples/vulkan/ocean/ocean.cpp | 19 +++++++++---------- samples/vulkan/ocean/ocean.hpp | 1 + samples/vulkan/ocean/ocean_util.hpp | 9 +-------- 4 files changed, 22 insertions(+), 33 deletions(-) diff --git a/samples/vulkan/ocean/main.cpp b/samples/vulkan/ocean/main.cpp index 6b735a1a..9f4bc063 100755 --- a/samples/vulkan/ocean/main.cpp +++ b/samples/vulkan/ocean/main.cpp @@ -65,12 +65,6 @@ void OceanApplication::main_loop() template <> auto cl::sdk::parse() { return std::make_tuple( - std::make_shared>("", "window_width", - "Window width", false, 1024, - "positive integral"), - std::make_shared>("", "window_height", - "Window height", false, 1024, - "positive integral"), std::make_shared>( "", "vulkan_device", "Vulkan physical device", false, -1, "integral number"), @@ -84,24 +78,25 @@ template <> auto cl::sdk::parse() false, true, "boolean"), std::make_shared>("", "useExternalMemory", "Use cl_khr_external_memory", - false, true, "boolean")); + false, true, "boolean"), + std::make_shared>("", "validationLayersOn", + "Use vulkan validation layers", + false, false, "boolean")); } template <> CliOptions cl::sdk::comprehend( - std::shared_ptr> window_width, - std::shared_ptr> window_height, std::shared_ptr> vulkan_device, std::shared_ptr> immediate, std::shared_ptr> linearImages, std::shared_ptr> deviceLocalImages, - std::shared_ptr> useExternalMemory) + std::shared_ptr> useExternalMemory, + std::shared_ptr> validationLayersOn) { return CliOptions{ - window_width->getValue(), window_height->getValue(), - vulkan_device->getValue(), immediate->getValue(), - linearImages->getValue(), deviceLocalImages->getValue(), - useExternalMemory->getValue() + vulkan_device->getValue(), immediate->getValue(), + linearImages->getValue(), deviceLocalImages->getValue(), + useExternalMemory->getValue(), validationLayersOn->getValue() }; } @@ -109,10 +104,11 @@ int main(int argc, char** argv) { OceanApplication app; - auto opts = cl::sdk::parse_cli( argc, argv); + app.win_opts = std::get<0>(opts); app.dev_opts = std::get<1>(opts); app.app_opts = std::get<2>(opts); diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index be3bc9cf..d54cee15 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -57,9 +57,8 @@ void OceanApplication::init_window() glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); - window = glfwCreateWindow((int)app_opts.window_width, - (int)app_opts.window_height, app_name.c_str(), - nullptr, nullptr); + window = glfwCreateWindow((int)win_opts.width, (int)win_opts.height, + app_name.c_str(), nullptr, nullptr); glfwSetWindowUserPointer(window, this); } @@ -482,7 +481,7 @@ void OceanApplication::cleanup() vkDestroyDevice(device, nullptr); - if (enableValidationLayers) + if (app_opts.validationLayersOn) { DestroyDebugUtilsMessengerEXT(instance, debug_messenger, nullptr); } @@ -497,7 +496,7 @@ void OceanApplication::cleanup() void OceanApplication::create_instance() { - if (enableValidationLayers && !check_validation_layer_support()) + if (app_opts.validationLayersOn && !check_validation_layer_support()) { throw std::runtime_error( "validation layers requested, but not available!"); @@ -528,7 +527,7 @@ void OceanApplication::create_instance() createInfo.ppEnabledExtensionNames = extensions.data(); VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{}; - if (enableValidationLayers) + if (app_opts.validationLayersOn) { createInfo.enabledLayerCount = static_cast(validationLayers.size()); @@ -591,7 +590,7 @@ void OceanApplication::populate_dbg_msger_create_info( void OceanApplication::setup_dbg_msger() { - if (!enableValidationLayers) return; + if (!app_opts.validationLayersOn) return; VkDebugUtilsMessengerCreateInfoEXT createInfo; populate_dbg_msger_create_info(createInfo); @@ -684,7 +683,7 @@ void OceanApplication::create_logical_device() createInfo.enabledExtensionCount = static_cast(extensions.size()); createInfo.ppEnabledExtensionNames = extensions.data(); - if (enableValidationLayers) + if (app_opts.validationLayersOn) { createInfo.enabledLayerCount = static_cast(validationLayers.size()); @@ -1953,7 +1952,7 @@ void OceanApplication::update_uniforms(uint32_t currentImage) glm::lookAt(camera.eye, camera.eye + camera.dir, camera.up); float fov = (float)glm::radians(60.0); - float aspect = (float)app_opts.window_width / app_opts.window_height; + float aspect = (float)win_opts.width / win_opts.height; glm::mat4 proj_matrix = glm::perspective( fov, aspect, 1.f, 2.f * ocean_grid_size * mesh_spacing); proj_matrix[1][1] *= -1; @@ -2659,7 +2658,7 @@ std::vector OceanApplication::get_required_exts() extensions.push_back( VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME); } - if (enableValidationLayers) + if (app_opts.validationLayersOn) { extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); } diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 71774f49..0758bca5 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -31,6 +31,7 @@ class OceanApplication { public: cl::sdk::options::SingleDevice dev_opts; + cl::sdk::options::Window win_opts; CliOptions app_opts; private: diff --git a/samples/vulkan/ocean/ocean_util.hpp b/samples/vulkan/ocean/ocean_util.hpp index 72608ed3..f41037f9 100755 --- a/samples/vulkan/ocean/ocean_util.hpp +++ b/samples/vulkan/ocean/ocean_util.hpp @@ -152,12 +152,6 @@ const std::vector deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME, }; -#ifdef NDEBUG -const bool enableValidationLayers = false; -#else -const bool enableValidationLayers = true; -#endif - static VkResult CreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -265,8 +259,6 @@ struct Camera struct CliOptions { - size_t window_width = 1024; - size_t window_height = 1024; std::int32_t vulkan_device = -1; bool immediate = false; @@ -274,6 +266,7 @@ struct CliOptions bool linearImages = false; bool device_local_images = true; bool use_external_memory = true; + bool validationLayersOn = false; }; #endif // OCEAN_UTIL_HPP From 72c6045d3b9db1abc2fa181176d0d3f76d5a7bcc Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Tue, 7 Jan 2025 16:38:25 +0100 Subject: [PATCH 12/18] Replaced glfw dependency with SFML window -SFML version 2.6 required --- cmake/Dependencies.cmake | 12 +-- samples/vulkan/ocean/CMakeLists.txt | 2 +- samples/vulkan/ocean/main.cpp | 131 ++++++++++++++++++----- samples/vulkan/ocean/ocean.cpp | 154 ++++------------------------ samples/vulkan/ocean/ocean.hpp | 11 +- samples/vulkan/ocean/ocean_util.hpp | 7 +- 6 files changed, 142 insertions(+), 175 deletions(-) diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index 34e10c97..c4e1227c 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -51,19 +51,19 @@ if(OPENCL_SDK_BUILD_SAMPLES) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Dependencies/${DEP}") include(${DEP}) endforeach() - if(OPENCL_SDK_BUILD_VULKAN_SAMPLES) - foreach(DEP IN ITEMS X11 glfw) + if(OPENCL_SDK_BUILD_VULKAN_SAMPLES AND SFML_VERSION VERSION_GREATER_EQUAL 2.6) + foreach(DEP IN ITEMS X11 SFML) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Dependencies/${DEP}") include(${DEP}) endforeach() - endif(OPENCL_SDK_BUILD_VULKAN_SAMPLES) + endif() else() - if(OPENCL_SDK_BUILD_VULKAN_SAMPLES) - foreach(DEP IN ITEMS X11 glm glfw) + if(OPENCL_SDK_BUILD_VULKAN_SAMPLES AND SFML_VERSION VERSION_GREATER_EQUAL 2.6) + foreach(DEP IN ITEMS X11 glm SFML) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Dependencies/${DEP}") include(${DEP}) endforeach() - endif(OPENCL_SDK_BUILD_VULKAN_SAMPLES) + endif() endif(OPENCL_SDK_BUILD_OPENGL_SAMPLES) endif(OPENCL_SDK_BUILD_SAMPLES) diff --git a/samples/vulkan/ocean/CMakeLists.txt b/samples/vulkan/ocean/CMakeLists.txt index 20062295..01bc3ae9 100755 --- a/samples/vulkan/ocean/CMakeLists.txt +++ b/samples/vulkan/ocean/CMakeLists.txt @@ -20,4 +20,4 @@ add_sample( SHADERS ocean.vert.spv ocean.frag.spv KERNELS twiddle.cl time_spectrum.cl inversion.cl normals.cl fft_kernel.cl init_spectrum.cl INCLUDES ${Vulkan_INCLUDE_DIR} - LIBS ${Vulkan_LIBRARY} glfw glm::glm) + LIBS ${Vulkan_LIBRARY} glm::glm) diff --git a/samples/vulkan/ocean/main.cpp b/samples/vulkan/ocean/main.cpp index 9f4bc063..8f8325c0 100755 --- a/samples/vulkan/ocean/main.cpp +++ b/samples/vulkan/ocean/main.cpp @@ -15,48 +15,125 @@ */ #include "ocean.hpp" +#include -namespace { - -void glfw_keyboard(GLFWwindow* window, int key, int scancode, int action, - int mods) +void OceanApplication::event(const sf::Event& event) { - auto app = (OceanApplication*)glfwGetWindowUserPointer(window); - app->keyboard(key, scancode, action, mods); + switch (event.type) + { + case sf::Event::Closed: window->close(); break; + case sf::Event::Resized: + // not supported + break; + case sf::Event::KeyPressed: keyboard(event.key.code); break; + case sf::Event::MouseButtonPressed: + if (event.mouseButton.button == sf::Mouse::Button::Left) + { + camera.drag = true; + camera.begin = + glm::vec2(event.mouseButton.x, event.mouseButton.y); + } + break; + case sf::Event::MouseButtonReleased: + if (event.mouseButton.button == sf::Mouse::Button::Left) + camera.drag = false; + break; + case sf::Event::MouseMoved: + if (camera.drag) mouseDrag(event.mouseMove.x, event.mouseMove.y); + break; + case sf::Event::MouseWheelMoved: + camera.eye += + camera.dir * (float)event.mouseWheel.delta * ROLL_SPEED_FAC; + break; + default: break; + } } -void glfw_mouse_event(GLFWwindow* window, int button, int action, int mods) +void OceanApplication::mouseDrag(const int x, const int y) { - auto app = (OceanApplication*)glfwGetWindowUserPointer(window); - app->mouse_event(button, action, mods); -} + if (!camera.drag) return; -void glfw_mouse_pos(GLFWwindow* window, double pX, double pY) -{ - auto app = (OceanApplication*)glfwGetWindowUserPointer(window); - app->mouse_pos(pX, pY); + glm::vec2 off = camera.begin - glm::vec2(x, y); + camera.begin = glm::vec2(x, y); + + camera.yaw -= off.x * DRAG_SPEED_FAC; + camera.pitch += off.y * DRAG_SPEED_FAC; + + glm::quat yaw(glm::cos(glm::radians(camera.yaw / 2)), + glm::vec3(0, 0, 1) * glm::sin(glm::radians(camera.yaw / 2))); + glm::quat pitch(glm::cos(glm::radians(camera.pitch / 2)), + glm::vec3(1, 0, 0) + * glm::sin(glm::radians(camera.pitch / 2))); + glm::mat3 rot_mat(yaw * pitch); + glm::vec3 dir = rot_mat * glm::vec3(0, 0, -1); + + camera.dir = glm::normalize(dir); + camera.rvec = glm::normalize(glm::cross(camera.dir, glm::vec3(0, 0, 1))); + camera.up = glm::normalize(glm::cross(camera.rvec, camera.dir)); } -void glfw_mouse_roll(GLFWwindow* window, double oX, double oY) +void OceanApplication::keyboard(int key) { - auto app = (OceanApplication*)glfwGetWindowUserPointer(window); - app->mouse_roll(oX, oY); + switch (key) + { + case sf::Keyboard::Key::Escape: window->close(); break; + case sf::Keyboard::Key::Space: + animate = !animate; + printf("animation is %s\n", animate ? "ON" : "OFF"); + break; + + case sf::Keyboard::Key::A: + wind_magnitude += 1.f; + changed = true; + break; + case sf::Keyboard::Key::Z: + wind_magnitude -= 1.f; + changed = true; + break; + + case sf::Keyboard::Key::S: + wind_angle += 1.f; + changed = true; + break; + case sf::Keyboard::Key::X: + wind_angle -= 1.f; + changed = true; + break; + + case sf::Keyboard::Key::D: + amplitude += 0.5f; + changed = true; + break; + case sf::Keyboard::Key::C: + amplitude -= 0.5f; + changed = true; + break; + + case sf::Keyboard::Key::F: choppiness += 0.5f; break; + case sf::Keyboard::Key::V: choppiness -= 0.5f; break; + + case sf::Keyboard::Key::G: alt_scale += 0.5f; break; + case sf::Keyboard::Key::B: alt_scale -= 0.5f; break; + + case sf::Keyboard::Key::W: wireframe_mode = !wireframe_mode; break; + + case sf::Keyboard::Key::E: show_fps = !show_fps; break; + } } -} // anonymous namespace - - void OceanApplication::main_loop() { - glfwSetKeyCallback(window, glfw_keyboard); - glfwSetMouseButtonCallback(window, glfw_mouse_event); - glfwSetCursorPosCallback(window, glfw_mouse_pos); - glfwSetScrollCallback(window, glfw_mouse_roll); - - while (!glfwWindowShouldClose(window)) + while (window && window->isOpen()) { + // Process events + sf::Event e; + while (window->pollEvent(e)) + { + event(e); + } + + // Render the frame draw_frame(); - glfwPollEvents(); } vkDeviceWaitIdle(device); diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index d54cee15..188e5ca7 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -49,17 +49,10 @@ void OceanApplication::run() void OceanApplication::init_window() { - if (!glfwInit()) - { - throw std::runtime_error("failed to initialize glfw!"); - } - - glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); - glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); - - window = glfwCreateWindow((int)win_opts.width, (int)win_opts.height, - app_name.c_str(), nullptr, nullptr); - glfwSetWindowUserPointer(window, this); + window = new sf::Window{ sf::VideoMode({ (std::uint32_t)win_opts.width, + (std::uint32_t)win_opts.height }), + app_name.c_str(), + sf::Style::Titlebar | sf::Style::Close }; } void OceanApplication::init_openCL() @@ -280,113 +273,6 @@ void OceanApplication::init_vulkan() create_sync_objects(); } -void OceanApplication::keyboard(int key, int scancode, int action, int mods) -{ - if (action == GLFW_PRESS || action == GLFW_REPEAT) - { - switch (key) - { - case GLFW_KEY_ESCAPE: - glfwSetWindowShouldClose(window, GLFW_TRUE); - break; - case GLFW_KEY_SPACE: - animate = !animate; - printf("animation is %s\n", animate ? "ON" : "OFF"); - break; - - case GLFW_KEY_A: - wind_magnitude += 1.f; - changed = true; - break; - case GLFW_KEY_Z: - wind_magnitude -= 1.f; - changed = true; - break; - - case GLFW_KEY_S: - wind_angle += 1.f; - changed = true; - break; - case GLFW_KEY_X: - wind_angle -= 1.f; - changed = true; - break; - - case GLFW_KEY_D: - amplitude += 0.5f; - changed = true; - break; - case GLFW_KEY_C: - amplitude -= 0.5f; - changed = true; - break; - - case GLFW_KEY_F: choppiness += 0.5f; break; - case GLFW_KEY_V: choppiness -= 0.5f; break; - - case GLFW_KEY_G: alt_scale += 0.5f; break; - case GLFW_KEY_B: alt_scale -= 0.5f; break; - - case GLFW_KEY_W: - wireframe_mode = !wireframe_mode; - create_command_buffers(); - break; - - case GLFW_KEY_E: - show_fps = !show_fps; - if (!show_fps) glfwSetWindowTitle(window, app_name.c_str()); - break; - } - } -} - -void OceanApplication::mouse_event(int button, int action, int mods) -{ - double x, y; - glfwGetCursorPos(window, &x, &y); - switch (action) - { - case 0: - // Button Up - camera.drag = false; - break; - case 1: - // Button Down - camera.drag = true; - camera.begin = glm::vec2(x, y); - break; - default: break; - } -} - -void OceanApplication::mouse_pos(double pX, double pY) -{ - if (!camera.drag) return; - - glm::vec2 off = camera.begin - glm::vec2(pX, pY); - camera.begin = glm::vec2(pX, pY); - - camera.yaw -= off.x * DRAG_SPEED_FAC; - camera.pitch += off.y * DRAG_SPEED_FAC; - - glm::quat yaw(glm::cos(glm::radians(camera.yaw / 2)), - glm::vec3(0, 0, 1) * glm::sin(glm::radians(camera.yaw / 2))); - glm::quat pitch(glm::cos(glm::radians(camera.pitch / 2)), - glm::vec3(1, 0, 0) - * glm::sin(glm::radians(camera.pitch / 2))); - glm::mat3 rot_mat(yaw * pitch); - glm::vec3 dir = rot_mat * glm::vec3(0, 0, -1); - - camera.dir = glm::normalize(dir); - camera.rvec = glm::normalize(glm::cross(camera.dir, glm::vec3(0, 0, 1))); - camera.up = glm::normalize(glm::cross(camera.rvec, camera.dir)); -} - -void OceanApplication::mouse_roll(double offset_x, double offset_y) -{ - camera.eye += camera.dir * (float)offset_y * ROLL_SPEED_FAC; -} - void OceanApplication::cleanup() { vkDestroyImageView(device, depth_image_view, nullptr); @@ -489,9 +375,11 @@ void OceanApplication::cleanup() vkDestroySurfaceKHR(instance, surface, nullptr); vkDestroyInstance(instance, nullptr); - glfwDestroyWindow(window); - - glfwTerminate(); + if (window) + { + delete window; + window = nullptr; + } } void OceanApplication::create_instance() @@ -605,11 +493,8 @@ void OceanApplication::setup_dbg_msger() void OceanApplication::create_surface() { - if (glfwCreateWindowSurface(instance, window, nullptr, &surface) - != VK_SUCCESS) - { + if (!window->createVulkanSurface(instance, surface)) throw std::runtime_error("failed to create window surface!"); - } } void OceanApplication::pick_physical_device() @@ -2204,7 +2089,7 @@ void OceanApplication::show_fps_window_title() ss << app_name << ", [FPS:" << std::fixed << std::setprecision(2) << fps << "]"; - glfwSetWindowTitle(window, ss.str().c_str()); + window->setTitle(ss.str().c_str()); delta_frames = 0; fps_last_time = fps_now; @@ -2505,8 +2390,13 @@ VkExtent2D OceanApplication::choose_swap_extent( } else { - int width, height; - glfwGetFramebufferSize(window, &width, &height); + int width = win_opts.width, height = win_opts.width; + if (window) + { + auto wsize = window->getSize(); + width = wsize.x; + height = wsize.y; + } VkExtent2D actualExtent = { static_cast(width), static_cast(height) }; @@ -2641,12 +2531,8 @@ OceanApplication::find_queue_families(VkPhysicalDevice device) std::vector OceanApplication::get_required_exts() { - uint32_t glfwExtensionCount = 0; - const char** glfwExtensions; - glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); - - std::vector extensions(glfwExtensions, - glfwExtensions + glfwExtensionCount); + std::vector extensions = + sf::Vulkan::getGraphicsRequiredInstanceExtensions(); if (app_opts.use_external_memory) { diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 0758bca5..0ac387d1 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -24,10 +24,10 @@ class OceanApplication { public: void run(); - void keyboard(int key, int scancode, int action, int mods); - void mouse_event(int button, int action, int mods); - void mouse_pos(double pX, double pY); - void mouse_roll(double offset_x, double offset_y); + + void event(const sf::Event& e); // Function that handles render area resize + void keyboard(int key); + void mouseDrag(const int x, const int y); public: cl::sdk::options::SingleDevice dev_opts; @@ -35,7 +35,8 @@ class OceanApplication { CliOptions app_opts; private: - GLFWwindow* window = nullptr; + sf::WindowBase* window = nullptr; + Camera camera; std::string app_name = "Ocean Surface Simulation"; diff --git a/samples/vulkan/ocean/ocean_util.hpp b/samples/vulkan/ocean/ocean_util.hpp index f41037f9..7435cacf 100755 --- a/samples/vulkan/ocean/ocean_util.hpp +++ b/samples/vulkan/ocean/ocean_util.hpp @@ -25,10 +25,13 @@ #endif #include -#define GLFW_INCLUDE_VULKAN -#include #include +#include +#include + +#include + #define CL_HPP_TARGET_OPENCL_VERSION 300 const float DRAG_SPEED_FAC = 0.2f; From b6561e5b3360382f5c9e046f388f5b258d41bf30 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Tue, 28 Jan 2025 08:55:39 +0100 Subject: [PATCH 13/18] Few corrections: -extended VkDescriptorPoolSize with second image stage -removed obsolete layer settings for vkCreateDevice -misprint fixes --- samples/vulkan/ocean/ocean.cpp | 24 +++++++++--------------- samples/vulkan/ocean/ocean.hpp | 2 +- 2 files changed, 10 insertions(+), 16 deletions(-) diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 188e5ca7..9f754190 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -255,7 +255,7 @@ void OceanApplication::init_vulkan() create_swap_chain_image_views(); create_render_pass(); create_uniform_buffer(); - create_descriptor_det_layout(); + create_descriptor_set_layout(); create_graphics_pipeline(); create_command_pool(); @@ -567,17 +567,7 @@ void OceanApplication::create_logical_device() auto extensions = get_required_dev_exts(); createInfo.enabledExtensionCount = static_cast(extensions.size()); createInfo.ppEnabledExtensionNames = extensions.data(); - - if (app_opts.validationLayersOn) - { - createInfo.enabledLayerCount = - static_cast(validationLayers.size()); - createInfo.ppEnabledLayerNames = validationLayers.data(); - } - else - { - createInfo.enabledLayerCount = 0; - } + createInfo.enabledLayerCount = 0; if (vkCreateDevice(physical_device, &createInfo, nullptr, &device) != VK_SUCCESS) @@ -751,7 +741,7 @@ void OceanApplication::create_uniform_buffer() } } -void OceanApplication::create_descriptor_det_layout() +void OceanApplication::create_descriptor_set_layout() { VkDescriptorSetLayoutBinding sampler0LayoutBinding{}; sampler0LayoutBinding.binding = 0; @@ -1506,15 +1496,19 @@ void OceanApplication::transition_uniform_layout(VkBuffer buffer, void OceanApplication::create_descriptor_pool() { - std::array poolSizes{}; + std::array poolSizes{}; poolSizes[0].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; poolSizes[0].descriptorCount = static_cast(swap_chain_images.size()); - poolSizes[1].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; poolSizes[1].descriptorCount = static_cast(swap_chain_images.size()); + poolSizes[2].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + poolSizes[2].descriptorCount = + static_cast(swap_chain_images.size()); + VkDescriptorPoolCreateInfo poolInfo{}; poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; poolInfo.poolSizeCount = static_cast(poolSizes.size()); diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 0ac387d1..202148e6 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -228,7 +228,7 @@ class OceanApplication { void create_swap_chain_image_views(); void create_render_pass(); void create_uniform_buffer(); - void create_descriptor_det_layout(); + void create_descriptor_set_layout(); void create_graphics_pipeline(); void create_framebuffers(); void create_command_pool(); From 9ee06166df234facf50f30b86f31394ec0f22135 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Thu, 30 Jan 2025 19:18:51 +0100 Subject: [PATCH 14/18] Corrected adaptation for SFML library --- samples/vulkan/ocean/main.cpp | 13 ++++++------ samples/vulkan/ocean/ocean.cpp | 38 +++++++++++++--------------------- samples/vulkan/ocean/ocean.hpp | 7 ++++--- 3 files changed, 24 insertions(+), 34 deletions(-) diff --git a/samples/vulkan/ocean/main.cpp b/samples/vulkan/ocean/main.cpp index 8f8325c0..af04ee4f 100755 --- a/samples/vulkan/ocean/main.cpp +++ b/samples/vulkan/ocean/main.cpp @@ -21,7 +21,7 @@ void OceanApplication::event(const sf::Event& event) { switch (event.type) { - case sf::Event::Closed: window->close(); break; + case sf::Event::Closed: window.close(); break; case sf::Event::Resized: // not supported break; @@ -76,7 +76,7 @@ void OceanApplication::keyboard(int key) { switch (key) { - case sf::Keyboard::Key::Escape: window->close(); break; + case sf::Keyboard::Key::Escape: window.close(); break; case sf::Keyboard::Key::Space: animate = !animate; printf("animation is %s\n", animate ? "ON" : "OFF"); @@ -123,11 +123,11 @@ void OceanApplication::keyboard(int key) void OceanApplication::main_loop() { - while (window && window->isOpen()) + while (window.isOpen()) { // Process events sf::Event e; - while (window->pollEvent(e)) + while (window.pollEvent(e)) { event(e); } @@ -179,13 +179,12 @@ CliOptions cl::sdk::comprehend( int main(int argc, char** argv) { - OceanApplication app; - auto opts = cl::sdk::parse_cli( argc, argv); - app.win_opts = std::get<0>(opts); + OceanApplication app(std::get<0>(opts)); + app.dev_opts = std::get<1>(opts); app.app_opts = std::get<2>(opts); diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 9f754190..312be293 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -37,9 +37,15 @@ #include "ocean.hpp" +OceanApplication::OceanApplication(cl::sdk::options::Window& opts) + : win_opts(opts), app_name("Ocean Surface Simulation"), + window(sf::VideoMode({ (std::uint32_t)win_opts.width, + (std::uint32_t)win_opts.height }), + app_name.c_str(), sf::Style::Titlebar | sf::Style::Close) +{} + void OceanApplication::run() { - init_window(); init_openCL(); init_vulkan(); init_openCL_mems(); @@ -47,14 +53,6 @@ void OceanApplication::run() cleanup(); } -void OceanApplication::init_window() -{ - window = new sf::Window{ sf::VideoMode({ (std::uint32_t)win_opts.width, - (std::uint32_t)win_opts.height }), - app_name.c_str(), - sf::Style::Titlebar | sf::Style::Close }; -} - void OceanApplication::init_openCL() { std::vector platforms; @@ -374,12 +372,6 @@ void OceanApplication::cleanup() vkDestroySurfaceKHR(instance, surface, nullptr); vkDestroyInstance(instance, nullptr); - - if (window) - { - delete window; - window = nullptr; - } } void OceanApplication::create_instance() @@ -493,7 +485,7 @@ void OceanApplication::setup_dbg_msger() void OceanApplication::create_surface() { - if (!window->createVulkanSurface(instance, surface)) + if (!window.createVulkanSurface(instance, surface)) throw std::runtime_error("failed to create window surface!"); } @@ -2075,7 +2067,7 @@ void OceanApplication::show_fps_window_title() const float elapsed_tres = 1.f; delta_frames++; - if (window && delta >= 1.f) + if (delta >= 1.f) { double fps = double(delta_frames) / delta; @@ -2083,7 +2075,7 @@ void OceanApplication::show_fps_window_title() ss << app_name << ", [FPS:" << std::fixed << std::setprecision(2) << fps << "]"; - window->setTitle(ss.str().c_str()); + window.setTitle(ss.str().c_str()); delta_frames = 0; fps_last_time = fps_now; @@ -2385,12 +2377,10 @@ VkExtent2D OceanApplication::choose_swap_extent( else { int width = win_opts.width, height = win_opts.width; - if (window) - { - auto wsize = window->getSize(); - width = wsize.x; - height = wsize.y; - } + + auto wsize = window.getSize(); + width = wsize.x; + height = wsize.y; VkExtent2D actualExtent = { static_cast(width), static_cast(height) }; diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 202148e6..385a5fc4 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -23,6 +23,7 @@ class OceanApplication { public: + OceanApplication(cl::sdk::options::Window& opts); void run(); void event(const sf::Event& e); // Function that handles render area resize @@ -35,10 +36,11 @@ class OceanApplication { CliOptions app_opts; private: - sf::WindowBase* window = nullptr; + std::string app_name; + + sf::WindowBase window; Camera camera; - std::string app_name = "Ocean Surface Simulation"; // ocean texture size - assume uniform x/y size_t ocean_tex_size = 512; @@ -209,7 +211,6 @@ class OceanApplication { std::array>, IOPT_COUNT> ocl_image_mems; - void init_window(); void init_openCL(); void init_openCL_mems(); void init_vulkan(); From 01b86c3674a8ebffe5003e4f08464d4a2ab15e33 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Mon, 10 Mar 2025 19:59:57 +0100 Subject: [PATCH 15/18] Added several corrections: -fixed the problem related to order of cleanup -fixed the bug with VK_ERROR_LOST_DEVICE at the finish -optimize the way of updating uniform buffer --- samples/vulkan/ocean/main.cpp | 9 +++- samples/vulkan/ocean/ocean.cpp | 88 +++++++++------------------------- samples/vulkan/ocean/ocean.hpp | 11 +++-- 3 files changed, 38 insertions(+), 70 deletions(-) diff --git a/samples/vulkan/ocean/main.cpp b/samples/vulkan/ocean/main.cpp index af04ee4f..2b2b8a1f 100755 --- a/samples/vulkan/ocean/main.cpp +++ b/samples/vulkan/ocean/main.cpp @@ -125,15 +125,20 @@ void OceanApplication::main_loop() { while (window.isOpen()) { + // Render the frame + draw_frame(); + // Process events sf::Event e; while (window.pollEvent(e)) { event(e); } + } - // Render the frame - draw_frame(); + if (vkQueueWaitIdle(graphics_queue) != VK_SUCCESS) + { + throw std::runtime_error("vkQueueWaitIdle failed!"); } vkDeviceWaitIdle(device); diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 312be293..81337510 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -273,26 +273,27 @@ void OceanApplication::init_vulkan() void OceanApplication::cleanup() { - vkDestroyImageView(device, depth_image_view, nullptr); - vkDestroyImage(device, depth_image, nullptr); - vkFreeMemory(device, depth_image_memory, nullptr); - for (auto framebuffer : swap_chain_framebuffers) { vkDestroyFramebuffer(device, framebuffer, nullptr); } - vkDestroyPipeline(device, graphics_pipeline, nullptr); - vkDestroyPipeline(device, wireframe_pipeline, nullptr); - vkDestroyPipelineLayout(device, pipeline_layout, nullptr); - vkDestroyRenderPass(device, render_pass, nullptr); - for (auto imageView : swap_chain_image_views) { vkDestroyImageView(device, imageView, nullptr); } vkDestroySwapchainKHR(device, swap_chain, nullptr); + + vkDestroyPipeline(device, graphics_pipeline, nullptr); + vkDestroyPipeline(device, wireframe_pipeline, nullptr); + vkDestroyPipelineLayout(device, pipeline_layout, nullptr); + vkDestroyRenderPass(device, render_pass, nullptr); + + vkDestroyImageView(device, depth_image_view, nullptr); + vkDestroyImage(device, depth_image, nullptr); + vkFreeMemory(device, depth_image_memory, nullptr); + vkDestroyDescriptorPool(device, descriptor_pool, nullptr); vkDestroyBuffer(device, staging_tex_buffer, nullptr); @@ -718,18 +719,22 @@ void OceanApplication::create_render_pass() void OceanApplication::create_uniform_buffer() { - VkDeviceSize bufferSize = sizeof(UniformBufferObject); + VkDeviceSize buffer_size = sizeof(UniformBufferObject); uniform_buffers.resize(swap_chain_images.size()); uniform_buffers_memory.resize(swap_chain_images.size()); + _mapped_unif_data.resize(swap_chain_images.size()); + for (size_t i = 0; i < uniform_buffers.size(); i++) { - create_buffer(bufferSize, - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT - | VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, uniform_buffers[i], - uniform_buffers_memory[i]); + create_buffer(buffer_size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + uniform_buffers[i], uniform_buffers_memory[i]); + + vkMapMemory(device, uniform_buffers_memory[i], 0, buffer_size, 0, + &_mapped_unif_data[i].buffer_memory); } } @@ -1449,43 +1454,6 @@ void OceanApplication::copy_buffer_to_image(VkBuffer buffer, VkImage image, end_single_time_commands(commandBuffer); } -void OceanApplication::transition_uniform_layout(VkBuffer buffer, - VkAccessFlagBits src, - VkAccessFlagBits dst) -{ - VkCommandBuffer commandBuffer = begin_single_time_commands(); - - VkDeviceSize bufferSize = sizeof(UniformBufferObject); - VkBufferMemoryBarrier barrier{}; - barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; - barrier.pNext = nullptr; - barrier.srcAccessMask = src; // VK_ACCESS_HOST_WRITE_BIT; - barrier.dstAccessMask = dst; // VK_ACCESS_UNIFORM_READ_BIT; - barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.buffer = buffer; - barrier.offset = 0; - barrier.size = bufferSize; - - VkPipelineStageFlags sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT; - VkPipelineStageFlags destinationStage = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; - - if (src == VK_ACCESS_SHADER_READ_BIT) - { - sourceStage = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT /*| - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT*/ - /*| VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR*/; - destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT; - } - - vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0, 0, - nullptr, 1, &barrier, 0, nullptr); - - end_single_time_commands(commandBuffer); -} - void OceanApplication::create_descriptor_pool() { std::array poolSizes{}; @@ -1814,7 +1782,7 @@ void OceanApplication::create_sync_objects() void OceanApplication::update_uniforms(uint32_t currentImage) { - UniformBufferObject ubo = {}; + UniformBufferObject ubo = _mapped_unif_data[currentImage].data; ubo.choppiness = choppiness; ubo.alt_scale = alt_scale; @@ -1831,18 +1799,8 @@ void OceanApplication::update_uniforms(uint32_t currentImage) ubo.view_mat = view_matrix; ubo.proj_mat = proj_matrix; - transition_uniform_layout(uniform_buffers[currentImage], - VK_ACCESS_SHADER_READ_BIT, - VK_ACCESS_TRANSFER_WRITE_BIT); - - VkCommandBuffer commandBuffer = begin_single_time_commands(); - vkCmdUpdateBuffer(commandBuffer, uniform_buffers[currentImage], 0, - sizeof(UniformBufferObject), &ubo); - end_single_time_commands(commandBuffer); - - transition_uniform_layout(uniform_buffers[currentImage], - VK_ACCESS_TRANSFER_WRITE_BIT, - VK_ACCESS_SHADER_READ_BIT); + memcpy(_mapped_unif_data[currentImage].buffer_memory, &ubo, + sizeof(UniformBufferObject)); } void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 385a5fc4..1dc7d8ca 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -171,6 +171,14 @@ class OceanApplication { std::vector uniform_buffers; std::vector uniform_buffers_memory; + struct MappedUniformBufferData + { + UniformBufferObject data; + void* buffer_memory; + }; + + std::vector _mapped_unif_data; + // more OpenCL resources cl_external_memory_handle_type_khr external_mem_type = 0; @@ -268,9 +276,6 @@ class OceanApplication { void copy_buffer_to_image(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height); - void transition_uniform_layout(VkBuffer buffer, VkAccessFlagBits src, - VkAccessFlagBits dst); - void create_descriptor_pool(); void create_descriptor_sets(); From 7c558c284affbc5b51d538bc7a4447b425b04fb1 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Mon, 10 Mar 2025 21:17:36 +0100 Subject: [PATCH 16/18] code format fix --- samples/vulkan/ocean/ocean.frag | 79 ++++++++++++++++++--------------- samples/vulkan/ocean/ocean.vert | 16 ++++--- 2 files changed, 51 insertions(+), 44 deletions(-) diff --git a/samples/vulkan/ocean/ocean.frag b/samples/vulkan/ocean/ocean.frag index 4ee59fc8..42a67c2f 100755 --- a/samples/vulkan/ocean/ocean.frag +++ b/samples/vulkan/ocean/ocean.frag @@ -22,13 +22,15 @@ layout(location = 1) in vec4 ec_pos; layout(location = 0) out vec4 out_color; layout(binding = 1) uniform sampler2D u_normal_map; -layout(binding = 2) uniform ViewData { - uniform mat4 view_mat; - uniform mat4 proj_mat; - uniform vec3 sun_dir; - uniform float choppiness; - uniform float alt_scale; -} view; +layout(binding = 2) uniform ViewData +{ + uniform mat4 view_mat; + uniform mat4 proj_mat; + uniform vec3 sun_dir; + uniform float choppiness; + uniform float alt_scale; +} +view; const vec3 env_specular = vec3(0.8); const float specular_power = 32.0; @@ -41,28 +43,25 @@ const vec3 ocean_bright = vec3(0.5, 1.6, 2.15); const vec3 ocean_dark = vec3(0.03, 0.06, 0.135); const float exposure = 0.4; -vec3 hdr(vec3 color, float exposure) -{ - return 1.0 - exp(-color * exposure); -} +vec3 hdr(vec3 color, float exposure) { return 1.0 - exp(-color * exposure); } -mat3 get_linear_part( mat4 m ) +mat3 get_linear_part(mat4 m) { - mat3 result; + mat3 result; - result[0][0] = m[0][0]; - result[0][1] = m[0][1]; - result[0][2] = m[0][2]; + result[0][0] = m[0][0]; + result[0][1] = m[0][1]; + result[0][2] = m[0][2]; - result[1][0] = m[1][0]; - result[1][1] = m[1][1]; - result[1][2] = m[1][2]; + result[1][0] = m[1][0]; + result[1][1] = m[1][1]; + result[1][2] = m[1][2]; - result[2][0] = m[2][0]; - result[2][1] = m[2][1]; - result[2][2] = m[2][2]; + result[2][0] = m[2][0]; + result[2][1] = m[2][1]; + result[2][2] = m[2][2]; - return result; + return result; } void main() @@ -74,10 +73,14 @@ void main() ivec2 ts = textureSize(u_normal_map, 0); float off_scl_x = 4.0 / ts.x; float off_scl_y = 4.0 / ts.y; - vec3 n0 = texture(u_normal_map, frag_tex_coord + vec2(off_scl_x, off_scl_y)).xyz; - vec3 n1 = texture(u_normal_map, frag_tex_coord + vec2(-off_scl_x, off_scl_y)).xyz; - vec3 n2 = texture(u_normal_map, frag_tex_coord - vec2(off_scl_x, off_scl_y)).xyz; - vec3 n3 = texture(u_normal_map, frag_tex_coord - vec2(-off_scl_x, off_scl_y)).xyz; + vec3 n0 = + texture(u_normal_map, frag_tex_coord + vec2(off_scl_x, off_scl_y)).xyz; + vec3 n1 = + texture(u_normal_map, frag_tex_coord + vec2(-off_scl_x, off_scl_y)).xyz; + vec3 n2 = + texture(u_normal_map, frag_tex_coord - vec2(off_scl_x, off_scl_y)).xyz; + vec3 n3 = + texture(u_normal_map, frag_tex_coord - vec2(-off_scl_x, off_scl_y)).xyz; float f0 = clamp(abs(dot(n0, n2) * (-0.5) + 0.5), 0.0, 1.0); float f1 = clamp(abs(dot(n1, n3) * (-0.5) + 0.5), 0.0, 1.0); @@ -101,19 +104,21 @@ void main() if (n_dot_vp > 0.0) { - vec3 N = normal; - vec3 E = -view_dir; - vec3 R = normalize(reflect(-light_dir, N)); - - // modulate specular scale value based on fragment direction - float dirScale = mix ( pow ( abs(n_dot_e), 8.0 ), - 1.0 - pow ( abs(1.0 - n_dot_e), 4.0 ), n_dot_e); - specular = env_specular * vec3 ( pow(max(dot(R, E), 0.0), specular_power) * - specular_scale * dirScale ); + vec3 N = normal; + vec3 E = -view_dir; + vec3 R = normalize(reflect(-light_dir, N)); + + // modulate specular scale value based on fragment direction + float dirScale = mix(pow(abs(n_dot_e), 8.0), + 1.0 - pow(abs(1.0 - n_dot_e), 4.0), n_dot_e); + specular = env_specular + * vec3(pow(max(dot(R, E), 0.0), specular_power) * specular_scale + * dirScale); } // refraction factors and final color assembly - float fresnel = clamp(pow( 1.0 + n_dot_e, -fresnel_approx_pow_factor ) * dyna_range, 0.0, 1.0); + float fresnel = clamp( + pow(1.0 + n_dot_e, -fresnel_approx_pow_factor) * dyna_range, 0.0, 1.0); vec3 bright = fresnel * ocean_bright; vec3 water = (1.0 - fresnel) * ocean_dark * ocean_bright * diffuse; vec3 color = bright + water + specular; diff --git a/samples/vulkan/ocean/ocean.vert b/samples/vulkan/ocean/ocean.vert index ee1e2175..a4a04adf 100755 --- a/samples/vulkan/ocean/ocean.vert +++ b/samples/vulkan/ocean/ocean.vert @@ -22,13 +22,15 @@ layout(location = 0) in vec3 in_position; layout(location = 1) in vec2 in_tex_coords; layout(set = 0, binding = 0) uniform sampler2D u_displacement_map; -layout(std140, set = 0, binding = 2) uniform ViewData { - uniform mat4 view_mat; - uniform mat4 proj_mat; - uniform vec3 sun_dir; - uniform float choppiness; - uniform float alt_scale; -} view; +layout(std140, set = 0, binding = 2) uniform ViewData +{ + uniform mat4 view_mat; + uniform mat4 proj_mat; + uniform vec3 sun_dir; + uniform float choppiness; + uniform float alt_scale; +} +view; void main() { From 46bb8aa1fe9507ce154c59f9152e2882bac3389a Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Tue, 1 Apr 2025 09:20:39 +0200 Subject: [PATCH 17/18] minor fix for android CI/CD --- .github/workflows/presubmit.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/presubmit.yml b/.github/workflows/presubmit.yml index 7d7f6103..c749d0bf 100644 --- a/.github/workflows/presubmit.yml +++ b/.github/workflows/presubmit.yml @@ -836,6 +836,7 @@ jobs: -D ANDROID_ABI=${{matrix.ABI}} -D ANDROID_PLATFORM=${{matrix.API_LEVEL}} -D OPENCL_SDK_BUILD_OPENGL_SAMPLES=OFF + -D OPENCL_SDK_BUILD_VULKAN_SAMPLES=OFF -S $GITHUB_WORKSPACE -B $GITHUB_WORKSPACE/build From fe8b92c86a8ff0269c95dcbe26c2a2406d109302 Mon Sep 17 00:00:00 2001 From: Marcin Hajder Date: Tue, 29 Apr 2025 10:24:10 +0200 Subject: [PATCH 18/18] Added corrections related to changes in other PRs #124 & #131 --- CMakeLists.txt | 2 +- README.md | 2 +- samples/vulkan/ocean/CMakeLists.txt | 2 +- samples/vulkan/ocean/ocean.cpp | 20 +++---- samples/vulkan/ocean/ocean.hpp | 1 + samples/vulkan/ocean/ocean_util.hpp | 89 ----------------------------- 6 files changed, 12 insertions(+), 104 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f090daca..a8433256 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,7 +26,7 @@ include(CMakeDependentOption) option(OPENCL_SDK_BUILD_UTILITY_LIBRARIES "Build utility libraries" ON) cmake_dependent_option(OPENCL_SDK_BUILD_SAMPLES "Build sample code" ON OPENCL_SDK_BUILD_UTILITY_LIBRARIES OFF) cmake_dependent_option(OPENCL_SDK_BUILD_OPENGL_SAMPLES "Build OpenCL-OpenGL interop sample code" OFF OPENCL_SDK_BUILD_SAMPLES OFF) -cmake_dependent_option(OPENCL_SDK_BUILD_VULKAN_SAMPLES "Build OpenCL-Vulkan interop sample code" ON OPENCL_SDK_BUILD_SAMPLES OFF) +cmake_dependent_option(OPENCL_SDK_BUILD_VULKAN_SAMPLES "Build OpenCL-Vulkan interop sample code" OFF OPENCL_SDK_BUILD_SAMPLES OFF) cmake_dependent_option(OPENCL_SDK_TEST_SAMPLES "Add CTest to samples (where applicable)" ON OPENCL_SDK_BUILD_SAMPLES OFF) find_package(Vulkan) diff --git a/README.md b/README.md index 00d0df29..e5944141 100644 --- a/README.md +++ b/README.md @@ -61,7 +61,7 @@ If CMake is not provided by your build system or OS package manager, please cons -B ./OpenCL-SDK/build -S ./OpenCL-SDK cmake --build ./OpenCL-SDK/build --target install -Samples that make use of OpenGL interop are disabled by default to reduce +Samples that make use of OpenGL or Vulkan interop are disabled by default to reduce the number of dependencies for most users. They can be enabled using the `OPENCL_SDK_BUILD_OPENGL_SAMPLES` CMake option. diff --git a/samples/vulkan/ocean/CMakeLists.txt b/samples/vulkan/ocean/CMakeLists.txt index 01bc3ae9..dca78181 100755 --- a/samples/vulkan/ocean/CMakeLists.txt +++ b/samples/vulkan/ocean/CMakeLists.txt @@ -20,4 +20,4 @@ add_sample( SHADERS ocean.vert.spv ocean.frag.spv KERNELS twiddle.cl time_spectrum.cl inversion.cl normals.cl fft_kernel.cl init_spectrum.cl INCLUDES ${Vulkan_INCLUDE_DIR} - LIBS ${Vulkan_LIBRARY} glm::glm) + LIBS ${Vulkan_LIBRARY}) diff --git a/samples/vulkan/ocean/ocean.cpp b/samples/vulkan/ocean/ocean.cpp index 81337510..81015959 100755 --- a/samples/vulkan/ocean/ocean.cpp +++ b/samples/vulkan/ocean/ocean.cpp @@ -236,9 +236,8 @@ void OceanApplication::init_openCL_mems() } } catch (const cl::Error& e) { - printf("initOpenCLMems: OpenCL %s image error: %s\n", e.what(), - IGetErrorString(e.err())); - exit(1); + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + exit(e.err()); } } @@ -1846,9 +1845,8 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) twiddle_factors_init = false; } catch (const cl::Error& e) { - printf("twiddle indices: OpenCL %s kernel error: %s\n", e.what(), - IGetErrorString(e.err())); - exit(1); + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + exit(e.err()); } } @@ -1874,9 +1872,8 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) changed = false; } catch (const cl::Error& e) { - printf("initial spectrum: OpenCL %s kernel error: %s\n", e.what(), - IGetErrorString(e.err())); - exit(1); + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + exit(e.err()); } } @@ -1895,9 +1892,8 @@ void OceanApplication::update_spectrum(uint32_t currentImage, float elapsed) cl::NDRange{ ocean_tex_size, ocean_tex_size }, lws); } catch (const cl::Error& e) { - printf("updateSpectrum: OpenCL %s kernel error: %s\n", e.what(), - IGetErrorString(e.err())); - exit(1); + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + exit(e.err()); } diff --git a/samples/vulkan/ocean/ocean.hpp b/samples/vulkan/ocean/ocean.hpp index 1dc7d8ca..094f4ef5 100755 --- a/samples/vulkan/ocean/ocean.hpp +++ b/samples/vulkan/ocean/ocean.hpp @@ -19,6 +19,7 @@ #include "ocean_util.hpp" #include +#include class OceanApplication { diff --git a/samples/vulkan/ocean/ocean_util.hpp b/samples/vulkan/ocean/ocean_util.hpp index 7435cacf..55775451 100755 --- a/samples/vulkan/ocean/ocean_util.hpp +++ b/samples/vulkan/ocean/ocean_util.hpp @@ -27,9 +27,6 @@ #include #include -#include -#include - #include #define CL_HPP_TARGET_OPENCL_VERSION 300 @@ -38,92 +35,6 @@ const float DRAG_SPEED_FAC = 0.2f; const float ROLL_SPEED_FAC = 8.f; const int MAX_FRAMES_IN_FLIGHT = 2; -static const char* IGetErrorString(int clErrorCode) -{ - switch (clErrorCode) - { - case CL_SUCCESS: return "CL_SUCCESS"; - case CL_DEVICE_NOT_FOUND: return "CL_DEVICE_NOT_FOUND"; - case CL_DEVICE_NOT_AVAILABLE: return "CL_DEVICE_NOT_AVAILABLE"; - case CL_COMPILER_NOT_AVAILABLE: return "CL_COMPILER_NOT_AVAILABLE"; - case CL_MEM_OBJECT_ALLOCATION_FAILURE: - return "CL_MEM_OBJECT_ALLOCATION_FAILURE"; - case CL_OUT_OF_RESOURCES: return "CL_OUT_OF_RESOURCES"; - case CL_OUT_OF_HOST_MEMORY: return "CL_OUT_OF_HOST_MEMORY"; - case CL_PROFILING_INFO_NOT_AVAILABLE: - return "CL_PROFILING_INFO_NOT_AVAILABLE"; - case CL_MEM_COPY_OVERLAP: return "CL_MEM_COPY_OVERLAP"; - case CL_IMAGE_FORMAT_MISMATCH: return "CL_IMAGE_FORMAT_MISMATCH"; - case CL_IMAGE_FORMAT_NOT_SUPPORTED: - return "CL_IMAGE_FORMAT_NOT_SUPPORTED"; - case CL_BUILD_PROGRAM_FAILURE: return "CL_BUILD_PROGRAM_FAILURE"; - case CL_MAP_FAILURE: return "CL_MAP_FAILURE"; - case CL_MISALIGNED_SUB_BUFFER_OFFSET: - return "CL_MISALIGNED_SUB_BUFFER_OFFSET"; - case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: - return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST"; - case CL_COMPILE_PROGRAM_FAILURE: return "CL_COMPILE_PROGRAM_FAILURE"; - case CL_LINKER_NOT_AVAILABLE: return "CL_LINKER_NOT_AVAILABLE"; - case CL_LINK_PROGRAM_FAILURE: return "CL_LINK_PROGRAM_FAILURE"; - case CL_DEVICE_PARTITION_FAILED: return "CL_DEVICE_PARTITION_FAILED"; - case CL_KERNEL_ARG_INFO_NOT_AVAILABLE: - return "CL_KERNEL_ARG_INFO_NOT_AVAILABLE"; - case CL_INVALID_VALUE: return "CL_INVALID_VALUE"; - case CL_INVALID_DEVICE_TYPE: return "CL_INVALID_DEVICE_TYPE"; - case CL_INVALID_DEVICE: return "CL_INVALID_DEVICE"; - case CL_INVALID_CONTEXT: return "CL_INVALID_CONTEXT"; - case CL_INVALID_QUEUE_PROPERTIES: return "CL_INVALID_QUEUE_PROPERTIES"; - case CL_INVALID_COMMAND_QUEUE: return "CL_INVALID_COMMAND_QUEUE"; - case CL_INVALID_HOST_PTR: return "CL_INVALID_HOST_PTR"; - case CL_INVALID_MEM_OBJECT: return "CL_INVALID_MEM_OBJECT"; - case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: - return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"; - case CL_INVALID_IMAGE_SIZE: return "CL_INVALID_IMAGE_SIZE"; - case CL_INVALID_SAMPLER: return "CL_INVALID_SAMPLER"; - case CL_INVALID_BINARY: return "CL_INVALID_BINARY"; - case CL_INVALID_BUILD_OPTIONS: return "CL_INVALID_BUILD_OPTIONS"; - case CL_INVALID_PLATFORM: return "CL_INVALID_PLATFORM"; - case CL_INVALID_PROGRAM: return "CL_INVALID_PROGRAM"; - case CL_INVALID_PROGRAM_EXECUTABLE: - return "CL_INVALID_PROGRAM_EXECUTABLE"; - case CL_INVALID_KERNEL_NAME: return "CL_INVALID_KERNEL_NAME"; - case CL_INVALID_KERNEL_DEFINITION: - return "CL_INVALID_KERNEL_DEFINITION"; - case CL_INVALID_KERNEL: return "CL_INVALID_KERNEL"; - case CL_INVALID_ARG_INDEX: return "CL_INVALID_ARG_INDEX"; - case CL_INVALID_ARG_VALUE: return "CL_INVALID_ARG_VALUE"; - case CL_INVALID_ARG_SIZE: return "CL_INVALID_ARG_SIZE"; - case CL_INVALID_KERNEL_ARGS: return "CL_INVALID_KERNEL_ARGS"; - case CL_INVALID_WORK_DIMENSION: return "CL_INVALID_WORK_DIMENSION"; - case CL_INVALID_WORK_GROUP_SIZE: return "CL_INVALID_WORK_GROUP_SIZE"; - case CL_INVALID_WORK_ITEM_SIZE: return "CL_INVALID_WORK_ITEM_SIZE"; - case CL_INVALID_GLOBAL_OFFSET: return "CL_INVALID_GLOBAL_OFFSET"; - case CL_INVALID_EVENT_WAIT_LIST: return "CL_INVALID_EVENT_WAIT_LIST"; - case CL_INVALID_EVENT: return "CL_INVALID_EVENT"; - case CL_INVALID_OPERATION: return "CL_INVALID_OPERATION"; - case CL_INVALID_GL_OBJECT: return "CL_INVALID_GL_OBJECT"; - case CL_INVALID_BUFFER_SIZE: return "CL_INVALID_BUFFER_SIZE"; - case CL_INVALID_MIP_LEVEL: return "CL_INVALID_MIP_LEVEL"; - case CL_INVALID_GLOBAL_WORK_SIZE: return "CL_INVALID_GLOBAL_WORK_SIZE"; - case CL_INVALID_PROPERTY: return "CL_INVALID_PROPERTY"; - case CL_INVALID_IMAGE_DESCRIPTOR: return "CL_INVALID_IMAGE_DESCRIPTOR"; - case CL_INVALID_COMPILER_OPTIONS: return "CL_INVALID_COMPILER_OPTIONS"; - case CL_INVALID_LINKER_OPTIONS: return "CL_INVALID_LINKER_OPTIONS"; - case CL_INVALID_DEVICE_PARTITION_COUNT: - return "CL_INVALID_DEVICE_PARTITION_COUNT"; - case CL_INVALID_PIPE_SIZE: return "CL_INVALID_PIPE_SIZE"; - case CL_INVALID_DEVICE_QUEUE: return "CL_INVALID_DEVICE_QUEUE"; - case CL_INVALID_SPEC_ID: return "CL_INVALID_SPEC_ID"; - case CL_MAX_SIZE_RESTRICTION_EXCEEDED: - return "CL_MAX_SIZE_RESTRICTION_EXCEEDED"; - default: return "(unknown)"; - } -} - -#define print_error(errCode, msg) \ - printf("ERROR: %s! (%s from %s:%d)\n", msg, IGetErrorString(errCode), \ - __FILE__, __LINE__); - #define test_error(errCode, msg) \ { \ auto errCodeResult = errCode; \