Adding some basic initial files for CMake support. This is almost certainly broken and in need of more dependency updates but I was able to coerce it to build with CMake + make on Linux. It's a start. Change-Id: I515e7949834e9657fa81e4735deb203eec330555
diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..632e5ee --- /dev/null +++ b/AUTHORS
@@ -0,0 +1,6 @@ +# This is the list of Dawn samples authors for copyright purposes. +# +# This does not necessarily list everyone who has contributed code, since in +# some cases, their employer may be the copyright holder. To see the full list +# of contributors, see the revision history in source control. +Google LLC
diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..69066a7 --- /dev/null +++ b/CMakeLists.txt
@@ -0,0 +1,156 @@ +# Copyright 2022 The Dawn & Tint Authors +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +cmake_minimum_required(VERSION 3.10.2) + +# When upgrading to CMake 3.11 we can remove SAMPLES_PLACEHOLDER_FILE because source-less add_library +# becomes available. +# When upgrading to CMake 3.12 we should remove the CACHE "" FORCE stuff to +# override options in third_party dependencies. We can also add the HOMEPAGE_URL +# entry to the project `HOMEPAGE_URL "https://dawn.googlesource.com/samples"` + +project( + DawnSamples + DESCRIPTION "Samples for Dawn, a WebGPU implementation" + LANGUAGES C CXX +) +enable_testing() + +set_property(GLOBAL PROPERTY USE_FOLDERS ON) + +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}) +set(CMAKE_POSITION_INDEPENDENT_CODE ON) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_DEBUG_POSTFIX "") + +if ("${CMAKE_BUILD_TYPE}" STREQUAL "") + message(STATUS "No build type selected, default to Debug") + set(CMAKE_BUILD_TYPE "Debug") +endif() + +set(SAMPLES_SRC_DIR "${DawnSamples_SOURCE_DIR}/src") + +set(SAMPLES_PLACEHOLDER_FILE "${SAMPLES_SRC_DIR}/Placeholder.cpp") + +################################################################################ +# Configuration options +################################################################################ + +# option_if_not_defined(name description default) +# Behaves like: +# option(name description default) +# If a variable is not already defined with the given name, otherwise the +# function does nothing. +# Simplifies customization by projects that use Dawn as a dependency. +function (option_if_not_defined name description default) + if(NOT DEFINED ${name}) + option(${name} ${description} ${default}) + endif() +endfunction() + +# set_if_not_defined(name value description) +# Behaves like: +# set(${name} ${value} CACHE STRING ${description}) +# If a variable is not already defined with the given name, otherwise the +# function does nothing. +# Simplifies customization by projects that use Dawn as a dependency. +function (set_if_not_defined name value description) + if(NOT DEFINED ${name}) + set(${name} ${value} CACHE STRING ${description}) + endif() +endfunction() + +# Default values for the backend-enabling options +set(USE_WAYLAND OFF) +set(USE_X11 OFF) + +if(UNIX) + set(USE_X11 ON) +endif() + +# GLFW is not supported in UWP +set(SAMPLES_SUPPORTS_GLFW_FOR_WINDOWING OFF) + +if ((WIN32 AND NOT WINDOWS_STORE) OR (UNIX AND NOT ANDROID)) + set(SAMPLES_SUPPORTS_GLFW_FOR_WINDOWING ON) +endif() + +# Current examples are depend on GLFW +if (SAMPLES_SUPPORTS_GLFW_FOR_WINDOWING) + set(BUILD_SAMPLES ON) +endif() + +option_if_not_defined(SAMPLES_USE_GLFW "Enable compilation of the GLFW windowing utils" ${SAMPLES_SUPPORTS_GLFW_FOR_WINDOWING}) + +if (NOT SAMPLES_USE_GLFW) + message(SEND_ERROR "Dawn samples require GLFW") +endif() + +set_if_not_defined(SAMPLES_THIRD_PARTY_DIR "${DawnSamples_SOURCE_DIR}/third_party" "Directory in which to find third-party dependencies.") + +set_if_not_defined(SAMPLES_DIR "${SAMPLES_THIRD_PARTY_DIR}/dawn" "Directory in which to find Dawn") +set_if_not_defined(SAMPLES_GLFW_DIR "${SAMPLES_THIRD_PARTY_DIR}/glfw" "Directory in which to find GLFW") +set_if_not_defined(SAMPLES_DAWN_DIR "${SAMPLES_THIRD_PARTY_DIR}/dawn" "Directory in which to find Dawm") + +option_if_not_defined(DAWN_USE_WAYLAND "Enable support for Wayland surface" ${USE_WAYLAND}) +option_if_not_defined(DAWN_USE_X11 "Enable support for X11 surface" ${USE_X11}) +option_if_not_defined(DAWN_FETCH_DEPENDENCIES "Use fetch_dawn_dependencies.py as an alternative to using depot_tools" ON) + +message(STATUS "Samples build GLFW support: ${SAMPLES_USE_GLFW}") + +message(STATUS "Using python3") +find_package(PythonInterp 3 REQUIRED) + +################################################################################ +# common_compile_options - sets compiler and linker options common for dawn and +# tint on the given target +################################################################################ +function(common_compile_options TARGET) + if (COMPILER_IS_LIKE_GNU) + target_compile_options(${TARGET} PRIVATE + -fno-exceptions + -fno-rtti + + -Wno-deprecated-builtins + -Wno-unknown-warning-option + ) + + endif(COMPILER_IS_LIKE_GNU) + + if(MSVC) + target_compile_options(${TARGET} PUBLIC /utf-8) + endif() +endfunction() + +################################################################################ +# Run on all subdirectories +################################################################################ + +add_subdirectory(third_party) + +add_subdirectory(src/samples) +
diff --git a/CMakeSettings.json b/CMakeSettings.json new file mode 100644 index 0000000..3eb93c2 --- /dev/null +++ b/CMakeSettings.json
@@ -0,0 +1,100 @@ +{ + "configurations": [ + { + "name": "x64-Debug", + "generator": "Ninja", + "configurationType": "Debug", + "inheritEnvironments": ["msvc_x64_x64"], + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "", + "variables": [] + }, + { + "name": "x64-Release", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "", + "inheritEnvironments": ["msvc_x64_x64"], + "variables": [] + }, + { + "name": "x86-Debug", + "generator": "Ninja", + "configurationType": "Debug", + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "", + "inheritEnvironments": ["msvc_x86"], + "variables": [] + }, + { + "name": "x86-Release", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "", + "inheritEnvironments": ["msvc_x86"], + "variables": [] + }, + { + "name": "x64-Clang-Debug", + "generator": "Ninja", + "configurationType": "Debug", + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "", + "inheritEnvironments": ["clang_cl_x64_x64"], + "variables": [] + }, + { + "name": "x64-Clang-Release", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "", + "inheritEnvironments": ["clang_cl_x64_x64"], + "variables": [] + }, + { + "name": "x86-Clang-Debug", + "generator": "Ninja", + "configurationType": "Debug", + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "", + "inheritEnvironments": ["clang_cl_x86"], + "variables": [] + }, + { + "name": "x86-Clang-Release", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "", + "inheritEnvironments": ["clang_cl_x86"], + "variables": [] + } + ] +}
diff --git a/DEPS b/DEPS new file mode 100644 index 0000000..ede80fc --- /dev/null +++ b/DEPS
@@ -0,0 +1,19 @@ +use_relative_paths = True + +vars = { + 'chromium_git': 'https://chromium.googlesource.com', + 'dawn_git': 'https://dawn.googlesource.com', + + 'dawn_revision': '18ac67fc72dfff47efec97c2a8bcf654a13a9e37', + 'glfw_revision': '62e175ef9fae75335575964c845a302447c012c7', +} + +deps = { + 'third_party/dawn': { + 'url': '{dawn_git}/dawn.git@{dawn_revision}', + }, + + 'third_party/glfw': { + 'url': '{chromium_git}/external/github.com/glfw/glfw@{glfw_revision}', + }, +}
diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..5b716b6 --- /dev/null +++ b/LICENSE
@@ -0,0 +1,26 @@ +// Copyright 2017-2023 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/OWNERS b/OWNERS new file mode 100644 index 0000000..65efb86 --- /dev/null +++ b/OWNERS
@@ -0,0 +1,6 @@ +bajones@chromium.org +cwallez@chromium.org +enga@chromium.org +kainino@chromium.org +jiawei.shao@intel.com +lokokung@google.com
diff --git a/README.md b/README.md new file mode 100644 index 0000000..82c6504 --- /dev/null +++ b/README.md
@@ -0,0 +1,26 @@ +<div align="center"> + <img + title="Dawn's logo" + alt="Dawn's logo: a sun rising behind a stylized mountain inspired by the WebGPU logo." + src="docs/imgs/dawn_logo_notext.png" + width="50%"> + + [](https://matrix.to/#/#webgpu-dawn:matrix.org) +</div> + +# Dawn Samples + +### WORK IN PROGRESS + +Samples for the Dawn library + +Dawn is an open-source and cross-platform implementation of the [WebGPU](https://webgpu.dev) standard. +More precisely it implements [`webgpu.h`](https://github.com/webgpu-native/webgpu-headers/blob/main/webgpu.h) that is a one-to-one mapping with the WebGPU IDL. + +## License + +BSD 3-Clause License, please see [LICENSE](/LICENSE). + +## Disclaimer + +This is not an officially supported Google product.
diff --git a/docs/building.md b/docs/building.md new file mode 100644 index 0000000..d864512 --- /dev/null +++ b/docs/building.md
@@ -0,0 +1,48 @@ +# Building Dawn Samples + +## System requirements + + * Git + * CMake (3.10.2 or later) (if desired) + * Python, for fetching dependencies + +- Linux + - The `pkg-config` command: + ```sh + # Install pkg-config on Ubuntu + sudo apt-get install pkg-config + ``` + +- Mac + - [Xcode](https://developer.apple.com/xcode/) 12.2+. + - The macOS 11.0 SDK. Run `xcode-select` to check whether you have it. + ```sh + ls `xcode-select -p`/Platforms/MacOSX.platform/Developer/SDKs + ``` + +## Get the code and its dependencies + +Use `tools/fetch_dawn_dependencies.py` to clone the dependencies' repositories: + +```sh +# Clone the repo as "dawn" +git clone https://dawn.googlesource.com/samples dawn-samples && cd dawn-samples + +# Fetch dependencies (lose equivalent of gclient sync) +python tools/fetch_dawn_dependencies.py +``` + +Use `python tools/fetch_dawn_dependencies.py -h` to know more about the available options. Contrary +to `depot_tools`, this scripts does not figure out option-dependent requirements automatically. + +TODO: Dawn samples do not yet support using the Chromium build system. + +## Build Dawn Samples + +### Compiling using CMake + make +```sh +mkdir -p out/Debug +cd out/Debug +cmake ../.. +make # -j N for N-way parallel build +```
diff --git a/docs/imgs/README.md b/docs/imgs/README.md new file mode 100644 index 0000000..60f42f4 --- /dev/null +++ b/docs/imgs/README.md
@@ -0,0 +1 @@ +Dawn's logo and derivatives found in this folder are under the [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/) license.
diff --git a/docs/imgs/dawn_logo_notext.png b/docs/imgs/dawn_logo_notext.png new file mode 100644 index 0000000..f9732e5 --- /dev/null +++ b/docs/imgs/dawn_logo_notext.png Binary files differ
diff --git a/src/Placeholder.cpp b/src/Placeholder.cpp new file mode 100644 index 0000000..645bfc0 --- /dev/null +++ b/src/Placeholder.cpp
@@ -0,0 +1,31 @@ +// Copyright 2020 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// CMake requires that targets contain at least on file. This file is used when we want to create +// empty targets. + +int someSymbolToMakeXCodeHappy = 0;
diff --git a/src/samples/Animometer.cpp b/src/samples/Animometer.cpp new file mode 100644 index 0000000..6a992e9 --- /dev/null +++ b/src/samples/Animometer.cpp
@@ -0,0 +1,208 @@ +// Copyright 2017 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include <cstdio> +#include <cstdlib> +#include <vector> + +#include "dawn/samples/SampleUtils.h" + +#include "dawn/utils/ComboRenderPipelineDescriptor.h" +#include "dawn/utils/SystemUtils.h" +#include "dawn/utils/Timer.h" +#include "dawn/utils/WGPUHelpers.h" + +wgpu::Device device; +wgpu::Queue queue; +wgpu::SwapChain swapchain; +wgpu::RenderPipeline pipeline; +wgpu::BindGroup bindGroup; +wgpu::Buffer ubo; + +float RandomFloat(float min, float max) { + // NOLINTNEXTLINE(runtime/threadsafe_fn) + float zeroOne = rand() / static_cast<float>(RAND_MAX); + return zeroOne * (max - min) + min; +} + +constexpr size_t kNumTriangles = 10000; + +// Aligned as minUniformBufferOffsetAlignment +struct alignas(256) ShaderData { + float scale; + float time; + float offsetX; + float offsetY; + float scalar; + float scalarOffset; +}; + +static std::vector<ShaderData> shaderData; + +void init() { + device = CreateCppDawnDevice(); + + queue = device.GetQueue(); + swapchain = GetSwapChain(); + + wgpu::ShaderModule vsModule = dawn::utils::CreateShaderModule(device, R"( + struct Constants { + scale : f32, + time : f32, + offsetX : f32, + offsetY : f32, + scalar : f32, + scalarOffset : f32, + }; + @group(0) @binding(0) var<uniform> c : Constants; + + struct VertexOut { + @location(0) v_color : vec4f, + @builtin(position) Position : vec4f, + }; + + @vertex fn main(@builtin(vertex_index) VertexIndex : u32) -> VertexOut { + var positions : array<vec4f, 3> = array( + vec4f( 0.0, 0.1, 0.0, 1.0), + vec4f(-0.1, -0.1, 0.0, 1.0), + vec4f( 0.1, -0.1, 0.0, 1.0) + ); + + var colors : array<vec4f, 3> = array( + vec4f(1.0, 0.0, 0.0, 1.0), + vec4f(0.0, 1.0, 0.0, 1.0), + vec4f(0.0, 0.0, 1.0, 1.0) + ); + + var position : vec4f = positions[VertexIndex]; + var color : vec4f = colors[VertexIndex]; + + // TODO(dawn:572): Revisit once modf has been reworked in WGSL. + var fade : f32 = c.scalarOffset + c.time * c.scalar / 10.0; + fade = fade - floor(fade); + if (fade < 0.5) { + fade = fade * 2.0; + } else { + fade = (1.0 - fade) * 2.0; + } + + var xpos : f32 = position.x * c.scale; + var ypos : f32 = position.y * c.scale; + let angle : f32 = 3.14159 * 2.0 * fade; + let xrot : f32 = xpos * cos(angle) - ypos * sin(angle); + let yrot : f32 = xpos * sin(angle) + ypos * cos(angle); + xpos = xrot + c.offsetX; + ypos = yrot + c.offsetY; + + var output : VertexOut; + output.v_color = vec4f(fade, 1.0 - fade, 0.0, 1.0) + color; + output.Position = vec4f(xpos, ypos, 0.0, 1.0); + return output; + })"); + + wgpu::ShaderModule fsModule = dawn::utils::CreateShaderModule(device, R"( + @fragment fn main(@location(0) v_color : vec4f) -> @location(0) vec4f { + return v_color; + })"); + + wgpu::BindGroupLayout bgl = dawn::utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Vertex, wgpu::BufferBindingType::Uniform, true}}); + + dawn::utils::ComboRenderPipelineDescriptor descriptor; + descriptor.layout = dawn::utils::MakeBasicPipelineLayout(device, &bgl); + descriptor.vertex.module = vsModule; + descriptor.cFragment.module = fsModule; + descriptor.cTargets[0].format = GetPreferredSwapChainTextureFormat(); + + pipeline = device.CreateRenderPipeline(&descriptor); + + shaderData.resize(kNumTriangles); + for (auto& data : shaderData) { + data.scale = RandomFloat(0.2f, 0.4f); + data.time = 0.0; + data.offsetX = RandomFloat(-0.9f, 0.9f); + data.offsetY = RandomFloat(-0.9f, 0.9f); + data.scalar = RandomFloat(0.5f, 2.0f); + data.scalarOffset = RandomFloat(0.0f, 10.0f); + } + + wgpu::BufferDescriptor bufferDesc; + bufferDesc.size = kNumTriangles * sizeof(ShaderData); + bufferDesc.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Uniform; + ubo = device.CreateBuffer(&bufferDesc); + + bindGroup = dawn::utils::MakeBindGroup(device, bgl, {{0, ubo, 0, sizeof(ShaderData)}}); +} + +int frameCount = 0; +void frame() { + wgpu::TextureView backbufferView = swapchain.GetCurrentTextureView(); + + for (auto& data : shaderData) { + data.time = frameCount / 60.0f; + } + queue.WriteBuffer(ubo, 0, shaderData.data(), kNumTriangles * sizeof(ShaderData)); + + dawn::utils::ComboRenderPassDescriptor renderPass({backbufferView}); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + { + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + pass.SetPipeline(pipeline); + + for (size_t i = 0; i < kNumTriangles; i++) { + uint32_t offset = i * sizeof(ShaderData); + pass.SetBindGroup(0, bindGroup, 1, &offset); + pass.Draw(3); + } + + pass.End(); + } + + wgpu::CommandBuffer commands = encoder.Finish(); + queue.Submit(1, &commands); + swapchain.Present(); + DoFlush(); +} + +int main(int argc, const char* argv[]) { + if (!InitSample(argc, argv)) { + return 1; + } + init(); + + dawn::utils::Timer* timer = dawn::utils::CreateTimer(); + timer->Start(); + while (!ShouldQuit()) { + ProcessEvents(); + frameCount++; + frame(); + if (frameCount % 60 == 0) { + printf("FPS: %lf\n", 60.0 / timer->GetElapsedTime()); + timer->Start(); + } + } +}
diff --git a/src/samples/CHelloTriangle.cpp b/src/samples/CHelloTriangle.cpp new file mode 100644 index 0000000..67252ba --- /dev/null +++ b/src/samples/CHelloTriangle.cpp
@@ -0,0 +1,161 @@ +// Copyright 2017 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "dawn/samples/SampleUtils.h" + +#include "dawn/utils/SystemUtils.h" +#include "dawn/utils/WGPUHelpers.h" + +WGPUDevice device; +WGPUQueue queue; +WGPUSwapChain swapchain; +WGPURenderPipeline pipeline; + +WGPUTextureFormat swapChainFormat; + +void init() { + device = CreateCppDawnDevice().MoveToCHandle(); + queue = wgpuDeviceGetQueue(device); + swapchain = GetSwapChain().MoveToCHandle(); + swapChainFormat = static_cast<WGPUTextureFormat>(GetPreferredSwapChainTextureFormat()); + + const char* vs = R"( + @vertex fn main( + @builtin(vertex_index) VertexIndex : u32 + ) -> @builtin(position) vec4f { + var pos = array( + vec2f( 0.0, 0.5), + vec2f(-0.5, -0.5), + vec2f( 0.5, -0.5) + ); + return vec4f(pos[VertexIndex], 0.0, 1.0); + })"; + WGPUShaderModule vsModule = dawn::utils::CreateShaderModule(device, vs).MoveToCHandle(); + + const char* fs = R"( + @fragment fn main() -> @location(0) vec4f { + return vec4f(1.0, 0.0, 0.0, 1.0); + })"; + WGPUShaderModule fsModule = dawn::utils::CreateShaderModule(device, fs).MoveToCHandle(); + + { + WGPURenderPipelineDescriptor descriptor = {}; + + // Fragment state + WGPUBlendState blend = {}; + blend.color.operation = WGPUBlendOperation_Add; + blend.color.srcFactor = WGPUBlendFactor_One; + blend.color.dstFactor = WGPUBlendFactor_One; + blend.alpha.operation = WGPUBlendOperation_Add; + blend.alpha.srcFactor = WGPUBlendFactor_One; + blend.alpha.dstFactor = WGPUBlendFactor_One; + + WGPUColorTargetState colorTarget = {}; + colorTarget.format = swapChainFormat; + colorTarget.blend = &blend; + colorTarget.writeMask = WGPUColorWriteMask_All; + + WGPUFragmentState fragment = {}; + fragment.module = fsModule; + fragment.entryPoint = "main"; + fragment.targetCount = 1; + fragment.targets = &colorTarget; + descriptor.fragment = &fragment; + + // Other state + descriptor.layout = nullptr; + descriptor.depthStencil = nullptr; + + descriptor.vertex.module = vsModule; + descriptor.vertex.entryPoint = "main"; + descriptor.vertex.bufferCount = 0; + descriptor.vertex.buffers = nullptr; + + descriptor.multisample.count = 1; + descriptor.multisample.mask = 0xFFFFFFFF; + descriptor.multisample.alphaToCoverageEnabled = false; + + descriptor.primitive.frontFace = WGPUFrontFace_CCW; + descriptor.primitive.cullMode = WGPUCullMode_None; + descriptor.primitive.topology = WGPUPrimitiveTopology_TriangleList; + descriptor.primitive.stripIndexFormat = WGPUIndexFormat_Undefined; + + pipeline = wgpuDeviceCreateRenderPipeline(device, &descriptor); + } + + wgpuShaderModuleRelease(vsModule); + wgpuShaderModuleRelease(fsModule); +} + +void frame() { + WGPUTextureView backbufferView = wgpuSwapChainGetCurrentTextureView(swapchain); + WGPURenderPassDescriptor renderpassInfo = {}; + WGPURenderPassColorAttachment colorAttachment = {}; + { + colorAttachment.view = backbufferView; + colorAttachment.resolveTarget = nullptr; + colorAttachment.clearValue = {0.0f, 0.0f, 0.0f, 0.0f}; + colorAttachment.loadOp = WGPULoadOp_Clear; + colorAttachment.storeOp = WGPUStoreOp_Store; + renderpassInfo.colorAttachmentCount = 1; + renderpassInfo.colorAttachments = &colorAttachment; + renderpassInfo.depthStencilAttachment = nullptr; + } + WGPUCommandBuffer commands; + { + WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr); + + WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(encoder, &renderpassInfo); + wgpuRenderPassEncoderSetPipeline(pass, pipeline); + wgpuRenderPassEncoderDraw(pass, 3, 1, 0, 0); + wgpuRenderPassEncoderEnd(pass); + wgpuRenderPassEncoderRelease(pass); + + commands = wgpuCommandEncoderFinish(encoder, nullptr); + wgpuCommandEncoderRelease(encoder); + } + + wgpuQueueSubmit(queue, 1, &commands); + wgpuCommandBufferRelease(commands); + wgpuSwapChainPresent(swapchain); + wgpuTextureViewRelease(backbufferView); + + DoFlush(); +} + +int main(int argc, const char* argv[]) { + if (!InitSample(argc, argv)) { + return 1; + } + init(); + + while (!ShouldQuit()) { + ProcessEvents(); + frame(); + dawn::utils::USleep(16000); + } +}
diff --git a/src/samples/CMakeLists.txt b/src/samples/CMakeLists.txt new file mode 100644 index 0000000..4a1f3dd --- /dev/null +++ b/src/samples/CMakeLists.txt
@@ -0,0 +1,64 @@ +# Copyright 2020 The Dawn & Tint Authors +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +add_library(dawn_sample_utils STATIC ${SAMPLES_PLACEHOLDER_FILE}) +target_include_directories(dawn_sample_utils INTERFACE + "${SAMPLES_SRC_DIR}" +) + +common_compile_options(dawn_sample_utils) +target_sources(dawn_sample_utils PRIVATE + "SampleUtils.cpp" + "SampleUtils.h" +) +target_link_libraries(dawn_sample_utils PUBLIC + dawn_internal_config + dawncpp + dawn_proc + dawn_common + dawn_glfw + dawn_native + dawn_wire + dawn_utils + glfw +) + +add_executable(CppHelloTriangle "CppHelloTriangle.cpp") +common_compile_options(CppHelloTriangle) +target_link_libraries(CppHelloTriangle dawn_sample_utils) + +add_executable(CHelloTriangle "CHelloTriangle.cpp") +common_compile_options(CHelloTriangle) +target_link_libraries(CHelloTriangle dawn_sample_utils) + +add_executable(ComputeBoids "ComputeBoids.cpp") +common_compile_options(ComputeBoids) +target_link_libraries(ComputeBoids dawn_sample_utils) + +add_executable(Animometer "Animometer.cpp") +common_compile_options(Animometer) +target_link_libraries(Animometer dawn_sample_utils)
diff --git a/src/samples/ComputeBoids.cpp b/src/samples/ComputeBoids.cpp new file mode 100644 index 0000000..6062aff --- /dev/null +++ b/src/samples/ComputeBoids.cpp
@@ -0,0 +1,341 @@ +// Copyright 2017 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include <array> +#include <cstring> +#include <random> +#include <vector> + +#include "dawn/samples/SampleUtils.h" + +#include "dawn/utils/ComboRenderPipelineDescriptor.h" +#include "dawn/utils/SystemUtils.h" +#include "dawn/utils/WGPUHelpers.h" + +wgpu::Device device; +wgpu::Queue queue; +wgpu::SwapChain swapchain; +wgpu::TextureView depthStencilView; + +wgpu::Buffer modelBuffer; +std::array<wgpu::Buffer, 2> particleBuffers; + +wgpu::RenderPipeline renderPipeline; + +wgpu::Buffer updateParams; +wgpu::ComputePipeline updatePipeline; +std::array<wgpu::BindGroup, 2> updateBGs; + +size_t pingpong = 0; + +static const uint32_t kNumParticles = 1024; + +struct Particle { + std::array<float, 2> pos; + std::array<float, 2> vel; +}; + +struct SimParams { + float deltaT; + float rule1Distance; + float rule2Distance; + float rule3Distance; + float rule1Scale; + float rule2Scale; + float rule3Scale; + int particleCount; +}; + +void initBuffers() { + std::array<std::array<float, 2>, 3> model = {{ + {-0.01, -0.02}, + {0.01, -0.02}, + {0.00, 0.02}, + }}; + modelBuffer = + dawn::utils::CreateBufferFromData(device, &model, sizeof(model), wgpu::BufferUsage::Vertex); + + SimParams params = {0.04f, 0.1f, 0.025f, 0.025f, 0.02f, 0.05f, 0.005f, kNumParticles}; + updateParams = dawn::utils::CreateBufferFromData(device, ¶ms, sizeof(params), + wgpu::BufferUsage::Uniform); + + std::vector<Particle> initialParticles(kNumParticles); + { + std::mt19937 generator; + std::uniform_real_distribution<float> dist(-1.0f, 1.0f); + for (auto& p : initialParticles) { + p.pos = {dist(generator), dist(generator)}; + p.vel = {dist(generator) * 0.1f, dist(generator) * 0.1f}; + } + } + + for (size_t i = 0; i < 2; i++) { + wgpu::BufferDescriptor descriptor; + descriptor.size = sizeof(Particle) * kNumParticles; + descriptor.usage = + wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Vertex | wgpu::BufferUsage::Storage; + particleBuffers[i] = device.CreateBuffer(&descriptor); + + queue.WriteBuffer(particleBuffers[i], 0, + reinterpret_cast<uint8_t*>(initialParticles.data()), + sizeof(Particle) * kNumParticles); + } +} + +void initRender() { + wgpu::ShaderModule vsModule = dawn::utils::CreateShaderModule(device, R"( + struct VertexIn { + @location(0) a_particlePos : vec2f, + @location(1) a_particleVel : vec2f, + @location(2) a_pos : vec2f, + }; + + @vertex + fn main(input : VertexIn) -> @builtin(position) vec4f { + var angle : f32 = -atan2(input.a_particleVel.x, input.a_particleVel.y); + var pos : vec2f = vec2f( + (input.a_pos.x * cos(angle)) - (input.a_pos.y * sin(angle)), + (input.a_pos.x * sin(angle)) + (input.a_pos.y * cos(angle))); + return vec4f(pos + input.a_particlePos, 0.0, 1.0); + } + )"); + + wgpu::ShaderModule fsModule = dawn::utils::CreateShaderModule(device, R"( + @fragment + fn main() -> @location(0) vec4f { + return vec4f(1.0, 1.0, 1.0, 1.0); + } + )"); + + depthStencilView = CreateDefaultDepthStencilView(device); + + dawn::utils::ComboRenderPipelineDescriptor descriptor; + + descriptor.vertex.module = vsModule; + descriptor.vertex.bufferCount = 2; + descriptor.cBuffers[0].arrayStride = sizeof(Particle); + descriptor.cBuffers[0].stepMode = wgpu::VertexStepMode::Instance; + descriptor.cBuffers[0].attributeCount = 2; + descriptor.cAttributes[0].offset = offsetof(Particle, pos); + descriptor.cAttributes[0].format = wgpu::VertexFormat::Float32x2; + descriptor.cAttributes[1].shaderLocation = 1; + descriptor.cAttributes[1].offset = offsetof(Particle, vel); + descriptor.cAttributes[1].format = wgpu::VertexFormat::Float32x2; + descriptor.cBuffers[1].arrayStride = 2 * sizeof(float); + descriptor.cBuffers[1].attributeCount = 1; + descriptor.cBuffers[1].attributes = &descriptor.cAttributes[2]; + descriptor.cAttributes[2].shaderLocation = 2; + descriptor.cAttributes[2].format = wgpu::VertexFormat::Float32x2; + + descriptor.cFragment.module = fsModule; + descriptor.EnableDepthStencil(wgpu::TextureFormat::Depth24PlusStencil8); + descriptor.cTargets[0].format = GetPreferredSwapChainTextureFormat(); + + renderPipeline = device.CreateRenderPipeline(&descriptor); +} + +void initSim() { + wgpu::ShaderModule module = dawn::utils::CreateShaderModule(device, R"( + struct Particle { + pos : vec2f, + vel : vec2f, + }; + struct SimParams { + deltaT : f32, + rule1Distance : f32, + rule2Distance : f32, + rule3Distance : f32, + rule1Scale : f32, + rule2Scale : f32, + rule3Scale : f32, + particleCount : u32, + }; + struct Particles { + particles : array<Particle>, + }; + @binding(0) @group(0) var<uniform> params : SimParams; + @binding(1) @group(0) var<storage, read_write> particlesA : Particles; + @binding(2) @group(0) var<storage, read_write> particlesB : Particles; + + // https://github.com/austinEng/Project6-Vulkan-Flocking/blob/master/data/shaders/computeparticles/particle.comp + @compute @workgroup_size(64) + fn main(@builtin(global_invocation_id) GlobalInvocationID : vec3u) { + var index : u32 = GlobalInvocationID.x; + if (index >= params.particleCount) { + return; + } + var vPos : vec2f = particlesA.particles[index].pos; + var vVel : vec2f = particlesA.particles[index].vel; + var cMass : vec2f = vec2f(0.0, 0.0); + var cVel : vec2f = vec2f(0.0, 0.0); + var colVel : vec2f = vec2f(0.0, 0.0); + var cMassCount : u32 = 0u; + var cVelCount : u32 = 0u; + var pos : vec2f; + var vel : vec2f; + + for (var i : u32 = 0u; i < params.particleCount; i = i + 1u) { + if (i == index) { + continue; + } + + pos = particlesA.particles[i].pos.xy; + vel = particlesA.particles[i].vel.xy; + if (distance(pos, vPos) < params.rule1Distance) { + cMass = cMass + pos; + cMassCount = cMassCount + 1u; + } + if (distance(pos, vPos) < params.rule2Distance) { + colVel = colVel - (pos - vPos); + } + if (distance(pos, vPos) < params.rule3Distance) { + cVel = cVel + vel; + cVelCount = cVelCount + 1u; + } + } + + if (cMassCount > 0u) { + cMass = (cMass / vec2f(f32(cMassCount), f32(cMassCount))) - vPos; + } + + if (cVelCount > 0u) { + cVel = cVel / vec2f(f32(cVelCount), f32(cVelCount)); + } + vVel = vVel + (cMass * params.rule1Scale) + (colVel * params.rule2Scale) + + (cVel * params.rule3Scale); + + // clamp velocity for a more pleasing simulation + vVel = normalize(vVel) * clamp(length(vVel), 0.0, 0.1); + // kinematic update + vPos = vPos + (vVel * params.deltaT); + + // Wrap around boundary + if (vPos.x < -1.0) { + vPos.x = 1.0; + } + if (vPos.x > 1.0) { + vPos.x = -1.0; + } + if (vPos.y < -1.0) { + vPos.y = 1.0; + } + if (vPos.y > 1.0) { + vPos.y = -1.0; + } + + // Write back + particlesB.particles[index].pos = vPos; + particlesB.particles[index].vel = vVel; + return; + } + )"); + + auto bgl = dawn::utils::MakeBindGroupLayout( + device, { + {0, wgpu::ShaderStage::Compute, wgpu::BufferBindingType::Uniform}, + {1, wgpu::ShaderStage::Compute, wgpu::BufferBindingType::Storage}, + {2, wgpu::ShaderStage::Compute, wgpu::BufferBindingType::Storage}, + }); + + wgpu::PipelineLayout pl = dawn::utils::MakeBasicPipelineLayout(device, &bgl); + + wgpu::ComputePipelineDescriptor csDesc; + csDesc.layout = pl; + csDesc.compute.module = module; + csDesc.compute.entryPoint = "main"; + updatePipeline = device.CreateComputePipeline(&csDesc); + + for (uint32_t i = 0; i < 2; ++i) { + updateBGs[i] = dawn::utils::MakeBindGroup( + device, bgl, + { + {0, updateParams, 0, sizeof(SimParams)}, + {1, particleBuffers[i], 0, kNumParticles * sizeof(Particle)}, + {2, particleBuffers[(i + 1) % 2], 0, kNumParticles * sizeof(Particle)}, + }); + } +} + +wgpu::CommandBuffer createCommandBuffer(const wgpu::TextureView backbufferView, size_t i) { + auto& bufferDst = particleBuffers[(i + 1) % 2]; + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + + { + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); + pass.SetPipeline(updatePipeline); + pass.SetBindGroup(0, updateBGs[i]); + pass.DispatchWorkgroups(kNumParticles / 64); + pass.End(); + } + + { + dawn::utils::ComboRenderPassDescriptor renderPass({backbufferView}, depthStencilView); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + pass.SetPipeline(renderPipeline); + pass.SetVertexBuffer(0, bufferDst); + pass.SetVertexBuffer(1, modelBuffer); + pass.Draw(3, kNumParticles); + pass.End(); + } + + return encoder.Finish(); +} + +void init() { + device = CreateCppDawnDevice(); + + queue = device.GetQueue(); + swapchain = GetSwapChain(); + + initBuffers(); + initRender(); + initSim(); +} + +void frame() { + wgpu::TextureView backbufferView = swapchain.GetCurrentTextureView(); + + wgpu::CommandBuffer commandBuffer = createCommandBuffer(backbufferView, pingpong); + queue.Submit(1, &commandBuffer); + swapchain.Present(); + DoFlush(); + + pingpong = (pingpong + 1) % 2; +} + +int main(int argc, const char* argv[]) { + if (!InitSample(argc, argv)) { + return 1; + } + init(); + + while (!ShouldQuit()) { + ProcessEvents(); + frame(); + dawn::utils::USleep(16000); + } +}
diff --git a/src/samples/CppHelloTriangle.cpp b/src/samples/CppHelloTriangle.cpp new file mode 100644 index 0000000..b1b47a5 --- /dev/null +++ b/src/samples/CppHelloTriangle.cpp
@@ -0,0 +1,195 @@ +// Copyright 2017 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include <vector> + +#include "dawn/samples/SampleUtils.h" + +#include "dawn/utils/ComboRenderPipelineDescriptor.h" +#include "dawn/utils/SystemUtils.h" +#include "dawn/utils/WGPUHelpers.h" + +wgpu::Device device; + +wgpu::Buffer indexBuffer; +wgpu::Buffer vertexBuffer; + +wgpu::Texture texture; +wgpu::Sampler sampler; + +wgpu::Queue queue; +wgpu::SwapChain swapchain; +wgpu::TextureView depthStencilView; +wgpu::RenderPipeline pipeline; +wgpu::BindGroup bindGroup; + +void initBuffers() { + static const uint32_t indexData[3] = { + 0, + 1, + 2, + }; + indexBuffer = dawn::utils::CreateBufferFromData(device, indexData, sizeof(indexData), + wgpu::BufferUsage::Index); + + static const float vertexData[12] = { + 0.0f, 0.5f, 0.0f, 1.0f, -0.5f, -0.5f, 0.0f, 1.0f, 0.5f, -0.5f, 0.0f, 1.0f, + }; + vertexBuffer = dawn::utils::CreateBufferFromData(device, vertexData, sizeof(vertexData), + wgpu::BufferUsage::Vertex); +} + +void initTextures() { + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; + descriptor.size.width = 1024; + descriptor.size.height = 1024; + descriptor.size.depthOrArrayLayers = 1; + descriptor.sampleCount = 1; + descriptor.format = wgpu::TextureFormat::RGBA8Unorm; + descriptor.mipLevelCount = 1; + descriptor.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::TextureBinding; + texture = device.CreateTexture(&descriptor); + + sampler = device.CreateSampler(); + + // Initialize the texture with arbitrary data until we can load images + std::vector<uint8_t> data(4 * 1024 * 1024, 0); + for (size_t i = 0; i < data.size(); ++i) { + data[i] = static_cast<uint8_t>(i % 253); + } + + wgpu::Buffer stagingBuffer = dawn::utils::CreateBufferFromData( + device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc); + wgpu::ImageCopyBuffer imageCopyBuffer = + dawn::utils::CreateImageCopyBuffer(stagingBuffer, 0, 4 * 1024); + wgpu::ImageCopyTexture imageCopyTexture = + dawn::utils::CreateImageCopyTexture(texture, 0, {0, 0, 0}); + wgpu::Extent3D copySize = {1024, 1024, 1}; + + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, ©Size); + + wgpu::CommandBuffer copy = encoder.Finish(); + queue.Submit(1, ©); +} + +void init() { + device = CreateCppDawnDevice(); + + queue = device.GetQueue(); + swapchain = GetSwapChain(); + + initBuffers(); + initTextures(); + + wgpu::ShaderModule vsModule = dawn::utils::CreateShaderModule(device, R"( + @vertex fn main(@location(0) pos : vec4f) + -> @builtin(position) vec4f { + return pos; + })"); + + wgpu::ShaderModule fsModule = dawn::utils::CreateShaderModule(device, R"( + @group(0) @binding(0) var mySampler: sampler; + @group(0) @binding(1) var myTexture : texture_2d<f32>; + + @fragment fn main(@builtin(position) FragCoord : vec4f) + -> @location(0) vec4f { + return textureSample(myTexture, mySampler, FragCoord.xy / vec2f(640.0, 480.0)); + })"); + + auto bgl = dawn::utils::MakeBindGroupLayout( + device, { + {0, wgpu::ShaderStage::Fragment, wgpu::SamplerBindingType::Filtering}, + {1, wgpu::ShaderStage::Fragment, wgpu::TextureSampleType::Float}, + }); + + wgpu::PipelineLayout pl = dawn::utils::MakeBasicPipelineLayout(device, &bgl); + + depthStencilView = CreateDefaultDepthStencilView(device); + + dawn::utils::ComboRenderPipelineDescriptor descriptor; + descriptor.layout = dawn::utils::MakeBasicPipelineLayout(device, &bgl); + descriptor.vertex.module = vsModule; + descriptor.vertex.bufferCount = 1; + descriptor.cBuffers[0].arrayStride = 4 * sizeof(float); + descriptor.cBuffers[0].attributeCount = 1; + descriptor.cAttributes[0].format = wgpu::VertexFormat::Float32x4; + descriptor.cFragment.module = fsModule; + descriptor.cTargets[0].format = GetPreferredSwapChainTextureFormat(); + descriptor.EnableDepthStencil(wgpu::TextureFormat::Depth24PlusStencil8); + + pipeline = device.CreateRenderPipeline(&descriptor); + + wgpu::TextureView view = texture.CreateView(); + + bindGroup = dawn::utils::MakeBindGroup(device, bgl, {{0, sampler}, {1, view}}); +} + +struct { + uint32_t a; + float b; +} s; +void frame() { + s.a = (s.a + 1) % 256; + s.b += 0.02f; + if (s.b >= 1.0f) { + s.b = 0.0f; + } + + wgpu::TextureView backbufferView = swapchain.GetCurrentTextureView(); + dawn::utils::ComboRenderPassDescriptor renderPass({backbufferView}, depthStencilView); + + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + { + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + pass.SetPipeline(pipeline); + pass.SetBindGroup(0, bindGroup); + pass.SetVertexBuffer(0, vertexBuffer); + pass.SetIndexBuffer(indexBuffer, wgpu::IndexFormat::Uint32); + pass.DrawIndexed(3); + pass.End(); + } + + wgpu::CommandBuffer commands = encoder.Finish(); + queue.Submit(1, &commands); + swapchain.Present(); + DoFlush(); +} + +int main(int argc, const char* argv[]) { + if (!InitSample(argc, argv)) { + return 1; + } + init(); + + while (!ShouldQuit()) { + ProcessEvents(); + frame(); + dawn::utils::USleep(16000); + } +}
diff --git a/src/samples/SampleUtils.cpp b/src/samples/SampleUtils.cpp new file mode 100644 index 0000000..2def23b --- /dev/null +++ b/src/samples/SampleUtils.cpp
@@ -0,0 +1,443 @@ +// Copyright 2017 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "SampleUtils.h" + +#include <algorithm> +#include <cstring> +#include <memory> +#include <string> +#include <string_view> +#include <vector> + +#include "GLFW/glfw3.h" +#include "dawn/common/Assert.h" +#include "dawn/common/Log.h" +#include "dawn/common/Platform.h" +#include "dawn/common/SystemUtils.h" +#include "dawn/dawn_proc.h" +#include "dawn/native/DawnNative.h" +#include "dawn/utils/TerribleCommandBuffer.h" +#include "dawn/wire/WireClient.h" +#include "dawn/wire/WireServer.h" +#include "webgpu/webgpu_glfw.h" + +void PrintDeviceError(WGPUErrorType errorType, const char* message, void*) { + const char* errorTypeName = ""; + switch (errorType) { + case WGPUErrorType_Validation: + errorTypeName = "Validation"; + break; + case WGPUErrorType_OutOfMemory: + errorTypeName = "Out of memory"; + break; + case WGPUErrorType_Unknown: + errorTypeName = "Unknown"; + break; + case WGPUErrorType_DeviceLost: + errorTypeName = "Device lost"; + break; + default: + DAWN_UNREACHABLE(); + return; + } + dawn::ErrorLog() << errorTypeName << " error: " << message; +} + +void DeviceLostCallback(WGPUDeviceLostReason reason, const char* message, void*) { + dawn::ErrorLog() << "Device lost: " << message; +} + +void PrintGLFWError(int code, const char* message) { + dawn::ErrorLog() << "GLFW error: " << code << " - " << message; +} + +void DeviceLogCallback(WGPULoggingType type, const char* message, void*) { + dawn::ErrorLog() << "Device log: " << message; +} + +enum class CmdBufType { + None, + Terrible, + // TODO(cwallez@chromium.org): double terrible cmdbuf +}; + +// Default to D3D12, Metal, Vulkan, OpenGL in that order as D3D12 and Metal are the preferred on +// their respective platforms, and Vulkan is preferred to OpenGL +#if defined(DAWN_ENABLE_BACKEND_D3D12) +static wgpu::BackendType backendType = wgpu::BackendType::D3D12; +#elif defined(DAWN_ENABLE_BACKEND_D3D11) +static wgpu::BackendType backendType = wgpu::BackendType::D3D11; +#elif defined(DAWN_ENABLE_BACKEND_METAL) +static wgpu::BackendType backendType = wgpu::BackendType::Metal; +#elif defined(DAWN_ENABLE_BACKEND_VULKAN) +static wgpu::BackendType backendType = wgpu::BackendType::Vulkan; +#elif defined(DAWN_ENABLE_BACKEND_OPENGLES) +static wgpu::BackendType backendType = wgpu::BackendType::OpenGLES; +#elif defined(DAWN_ENABLE_BACKEND_DESKTOP_GL) +static wgpu::BackendType backendType = wgpu::BackendType::OpenGL; +#else +#error +#endif + +static wgpu::AdapterType adapterType = wgpu::AdapterType::Unknown; + +static std::vector<std::string> enableToggles; +static std::vector<std::string> disableToggles; + +static CmdBufType cmdBufType = CmdBufType::Terrible; +static std::unique_ptr<dawn::native::Instance> instance; +static wgpu::SwapChain swapChain; + +static GLFWwindow* window = nullptr; + +static dawn::wire::WireServer* wireServer = nullptr; +static dawn::wire::WireClient* wireClient = nullptr; +static dawn::utils::TerribleCommandBuffer* c2sBuf = nullptr; +static dawn::utils::TerribleCommandBuffer* s2cBuf = nullptr; + +static constexpr uint32_t kWidth = 640; +static constexpr uint32_t kHeight = 480; + +wgpu::Device CreateCppDawnDevice() { + dawn::ScopedEnvironmentVar angleDefaultPlatform; + if (dawn::GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM").first.empty()) { + angleDefaultPlatform.Set("ANGLE_DEFAULT_PLATFORM", "swiftshader"); + } + + glfwSetErrorCallback(PrintGLFWError); + if (!glfwInit()) { + return wgpu::Device(); + } + + // Create the test window with no client API. + glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); + glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_FALSE); + window = glfwCreateWindow(kWidth, kHeight, "Dawn window", nullptr, nullptr); + if (!window) { + return wgpu::Device(); + } + + WGPUInstanceDescriptor instanceDescriptor{}; + instanceDescriptor.features.timedWaitAnyEnable = true; + instance = std::make_unique<dawn::native::Instance>(&instanceDescriptor); + + wgpu::RequestAdapterOptions options = {}; + options.backendType = backendType; + + // Get an adapter for the backend to use, and create the device. + auto adapters = instance->EnumerateAdapters(&options); + wgpu::DawnAdapterPropertiesPowerPreference power_props{}; + wgpu::AdapterProperties adapterProperties{}; + adapterProperties.nextInChain = &power_props; + // Find the first adapter which satisfies the adapterType requirement. + auto isAdapterType = [&adapterProperties](const auto& adapter) -> bool { + // picks the first adapter when adapterType is unknown. + if (adapterType == wgpu::AdapterType::Unknown) { + return true; + } + adapter.GetProperties(&adapterProperties); + return adapterProperties.adapterType == adapterType; + }; + auto preferredAdapter = std::find_if(adapters.begin(), adapters.end(), isAdapterType); + if (preferredAdapter == adapters.end()) { + fprintf(stderr, "Failed to find an adapter! Please try another adapter type.\n"); + return wgpu::Device(); + } + + std::vector<const char*> enableToggleNames; + std::vector<const char*> disabledToggleNames; + for (const std::string& toggle : enableToggles) { + enableToggleNames.push_back(toggle.c_str()); + } + + for (const std::string& toggle : disableToggles) { + disabledToggleNames.push_back(toggle.c_str()); + } + WGPUDawnTogglesDescriptor toggles; + toggles.chain.sType = WGPUSType_DawnTogglesDescriptor; + toggles.chain.next = nullptr; + toggles.enabledToggles = enableToggleNames.data(); + toggles.enabledToggleCount = enableToggleNames.size(); + toggles.disabledToggles = disabledToggleNames.data(); + toggles.disabledToggleCount = disabledToggleNames.size(); + + WGPUDeviceDescriptor deviceDesc = {}; + deviceDesc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(&toggles); + + WGPUDevice backendDevice = preferredAdapter->CreateDevice(&deviceDesc); + DawnProcTable backendProcs = dawn::native::GetProcs(); + + // Create the swapchain + auto surfaceChainedDesc = wgpu::glfw::SetupWindowAndGetSurfaceDescriptor(window); + WGPUSurfaceDescriptor surfaceDesc; + surfaceDesc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(surfaceChainedDesc.get()); + WGPUSurface surface = backendProcs.instanceCreateSurface(instance->Get(), &surfaceDesc); + + WGPUSwapChainDescriptor swapChainDesc = {}; + swapChainDesc.usage = WGPUTextureUsage_RenderAttachment; + swapChainDesc.format = static_cast<WGPUTextureFormat>(GetPreferredSwapChainTextureFormat()); + swapChainDesc.width = kWidth; + swapChainDesc.height = kHeight; + swapChainDesc.presentMode = WGPUPresentMode_Mailbox; + WGPUSwapChain backendSwapChain = + backendProcs.deviceCreateSwapChain(backendDevice, surface, &swapChainDesc); + + // Choose whether to use the backend procs and devices/swapchains directly, or set up the wire. + WGPUDevice cDevice = nullptr; + DawnProcTable procs; + + switch (cmdBufType) { + case CmdBufType::None: + procs = backendProcs; + cDevice = backendDevice; + swapChain = wgpu::SwapChain::Acquire(backendSwapChain); + break; + + case CmdBufType::Terrible: { + c2sBuf = new dawn::utils::TerribleCommandBuffer(); + s2cBuf = new dawn::utils::TerribleCommandBuffer(); + + dawn::wire::WireServerDescriptor serverDesc = {}; + serverDesc.procs = &backendProcs; + serverDesc.serializer = s2cBuf; + + wireServer = new dawn::wire::WireServer(serverDesc); + c2sBuf->SetHandler(wireServer); + + dawn::wire::WireClientDescriptor clientDesc = {}; + clientDesc.serializer = c2sBuf; + + wireClient = new dawn::wire::WireClient(clientDesc); + procs = dawn::wire::client::GetProcs(); + s2cBuf->SetHandler(wireClient); + + auto deviceReservation = wireClient->ReserveDevice(); + wireServer->InjectDevice(backendDevice, deviceReservation.id, + deviceReservation.generation); + cDevice = deviceReservation.device; + + auto swapChainReservation = wireClient->ReserveSwapChain(cDevice, &swapChainDesc); + wireServer->InjectSwapChain(backendSwapChain, swapChainReservation.id, + swapChainReservation.generation, deviceReservation.id, + deviceReservation.generation); + swapChain = wgpu::SwapChain::Acquire(swapChainReservation.swapchain); + } break; + } + + dawnProcSetProcs(&procs); + procs.deviceSetUncapturedErrorCallback(cDevice, PrintDeviceError, nullptr); + procs.deviceSetDeviceLostCallback(cDevice, DeviceLostCallback, nullptr); + procs.deviceSetLoggingCallback(cDevice, DeviceLogCallback, nullptr); + return wgpu::Device::Acquire(cDevice); +} + +wgpu::TextureFormat GetPreferredSwapChainTextureFormat() { + // TODO(dawn:1362): Return the adapter's preferred format when implemented. + return wgpu::TextureFormat::BGRA8Unorm; +} + +wgpu::SwapChain GetSwapChain() { + return swapChain; +} + +wgpu::TextureView CreateDefaultDepthStencilView(const wgpu::Device& device) { + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; + descriptor.size.width = kWidth; + descriptor.size.height = kHeight; + descriptor.size.depthOrArrayLayers = 1; + descriptor.sampleCount = 1; + descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8; + descriptor.mipLevelCount = 1; + descriptor.usage = wgpu::TextureUsage::RenderAttachment; + auto depthStencilTexture = device.CreateTexture(&descriptor); + return depthStencilTexture.CreateView(); +} + +bool InitSample(int argc, const char** argv) { + for (int i = 1; i < argc; i++) { + std::string_view arg(argv[i]); + std::string_view opt, value; + + static constexpr struct Option { + const char* shortOpt; + const char* longOpt; + bool hasValue; + } options[] = { + {"-b", "--backend=", true}, {"-c", "--cmd-buf=", true}, + {"-e", "--enable-toggle=", true}, {"-d", "--disable-toggle=", true}, + {"-a", "--adapter-type=", true}, {"-h", "--help", false}, + }; + + for (const Option& option : options) { + if (!option.hasValue) { + if (arg == option.shortOpt || arg == option.longOpt) { + opt = option.shortOpt; + break; + } + continue; + } + + if (arg == option.shortOpt) { + opt = option.shortOpt; + if (++i < argc) { + value = argv[i]; + } + break; + } + + if (arg.rfind(option.longOpt, 0) == 0) { + opt = option.shortOpt; + if (option.hasValue) { + value = arg.substr(strlen(option.longOpt)); + } + break; + } + } + + if (opt == "-b") { + if (value == "d3d11") { + backendType = wgpu::BackendType::D3D11; + continue; + } + if (value == "d3d12") { + backendType = wgpu::BackendType::D3D12; + continue; + } + if (value == "metal") { + backendType = wgpu::BackendType::Metal; + continue; + } + if (value == "null") { + backendType = wgpu::BackendType::Null; + continue; + } + if (value == "opengl") { + backendType = wgpu::BackendType::OpenGL; + continue; + } + if (value == "opengles") { + backendType = wgpu::BackendType::OpenGLES; + continue; + } + if (value == "vulkan") { + backendType = wgpu::BackendType::Vulkan; + continue; + } + fprintf(stderr, + "--backend expects a backend name (opengl, opengles, metal, d3d12, null, " + "vulkan)\n"); + return false; + } + + if (opt == "-c") { + if (value == "none") { + cmdBufType = CmdBufType::None; + continue; + } + if (value == "terrible") { + cmdBufType = CmdBufType::Terrible; + continue; + } + fprintf(stderr, "--command-buffer expects a command buffer name (none, terrible)\n"); + return false; + } + + if (opt == "-e") { + enableToggles.push_back(std::string(value)); + continue; + } + + if (opt == "-d") { + disableToggles.push_back(std::string(value)); + continue; + } + + if (opt == "-a") { + if (value == "discrete") { + adapterType = wgpu::AdapterType::DiscreteGPU; + continue; + } + if (value == "integrated") { + adapterType = wgpu::AdapterType::IntegratedGPU; + continue; + } + if (value == "cpu") { + adapterType = wgpu::AdapterType::CPU; + continue; + } + fprintf(stderr, "--adapter-type expects an adapter type (discrete, integrated, cpu)\n"); + return false; + } + + if (opt == "-h") { + printf( + "Usage: %s [-b BACKEND] [-c COMMAND_BUFFER] [-e TOGGLE] [-d TOGGLE] [-a " + "ADAPTER]\n", + argv[0]); + printf(" BACKEND is one of: d3d12, metal, null, opengl, opengles, vulkan\n"); + printf(" COMMAND_BUFFER is one of: none, terrible\n"); + printf(" TOGGLE is device toggle name to enable or disable\n"); + printf(" ADAPTER is one of: discrete, integrated, cpu\n"); + return false; + } + } + + // TODO(dawn:810): Reenable once the OpenGL(ES) backend is able to create its own context such + // that it can use surface-based swapchains. + if (backendType == wgpu::BackendType::OpenGL || backendType == wgpu::BackendType::OpenGLES) { + fprintf(stderr, + "The OpenGL(ES) backend is temporarily not supported for samples. See " + "https://crbug.com/dawn/810"); + return false; + } + + return true; +} + +void DoFlush() { + if (cmdBufType == CmdBufType::Terrible) { + bool c2sSuccess = c2sBuf->Flush(); + bool s2cSuccess = s2cBuf->Flush(); + + DAWN_ASSERT(c2sSuccess && s2cSuccess); + } + glfwPollEvents(); +} + +bool ShouldQuit() { + return glfwWindowShouldClose(window); +} + +GLFWwindow* GetGLFWWindow() { + return window; +} + +void ProcessEvents() { + dawn::native::InstanceProcessEvents(instance->Get()); +}
diff --git a/src/samples/SampleUtils.h b/src/samples/SampleUtils.h new file mode 100644 index 0000000..fb7e289 --- /dev/null +++ b/src/samples/SampleUtils.h
@@ -0,0 +1,46 @@ +// Copyright 2017 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_DAWN_SAMPLES_SAMPLEUTILS_H_ +#define SRC_DAWN_SAMPLES_SAMPLEUTILS_H_ + +#include "dawn/webgpu_cpp.h" + +bool InitSample(int argc, const char** argv); +void DoFlush(); +bool ShouldQuit(); + +struct GLFWwindow; +struct GLFWwindow* GetGLFWWindow(); + +wgpu::Device CreateCppDawnDevice(); +wgpu::TextureFormat GetPreferredSwapChainTextureFormat(); +wgpu::SwapChain GetSwapChain(); +wgpu::TextureView CreateDefaultDepthStencilView(const wgpu::Device& device); +void ProcessEvents(); + +#endif // SRC_DAWN_SAMPLES_SAMPLEUTILS_H_
diff --git a/third_party/CMakeLists.txt b/third_party/CMakeLists.txt new file mode 100644 index 0000000..d7bfc62 --- /dev/null +++ b/third_party/CMakeLists.txt
@@ -0,0 +1,66 @@ +# Copyright 2022 The Dawn & Tint Authors +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# Don't build testing in third_party dependencies +set(BUILD_TESTING OFF) + +# fetch_dawn_dependencies.py is an alternative to using depot_tools +# It is particularly interesting when building dawn as a subdirectory in +# a parent project that does not want to use depot_tools. +if (${DAWN_FETCH_DEPENDENCIES}) + find_package(PythonInterp 3 REQUIRED) + + set(EXTRA_FETCH_ARGS) + + message(STATUS "Running fetch_dawn_dependencies:") + execute_process( + COMMAND + ${PYTHON_EXECUTABLE} + "${PROJECT_SOURCE_DIR}/tools/fetch_dawn_dependencies.py" + --directory ${PROJECT_SOURCE_DIR} + ${EXTRA_FETCH_ARGS} + ) +endif () + +if (NOT TARGET dawn) + set(DAWN_BUILD_SAMPLES OFF CACHE BOOL "" FORCE) + set(DAWN_USE_GLFW ON CACHE BOOL "" FORCE) + + message(STATUS "Dawn Samples: using Dawn at ${SAMPLES_DAWN_DIR}") + add_subdirectory(${SAMPLES_DAWN_DIR} "${CMAKE_CURRENT_BINARY_DIR}/dawn") +endif() + +if (NOT TARGET glfw) + set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE) + set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE) + set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) + set(GLFW_BUILD_X11 ${DAWN_USE_X11} CACHE BOOL "" FORCE) + set(GLFW_BUILD_WAYLAND ${DAWN_USE_WAYLAND} CACHE BOOL "" FORCE) + + message(STATUS "Dawn Samples: using GLFW at ${SAMPLES_GLFW_DIR}") + add_subdirectory(${SAMPLES_GLFW_DIR} "${CMAKE_CURRENT_BINARY_DIR}/glfw") +endif()
diff --git a/tools/fetch_dawn_dependencies.py b/tools/fetch_dawn_dependencies.py new file mode 100644 index 0000000..e5b46ea --- /dev/null +++ b/tools/fetch_dawn_dependencies.py
@@ -0,0 +1,215 @@ +# Copyright 2023 The Dawn & Tint Authors +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +""" +Helper script to download Dawn's source dependencies without the need to +install depot_tools by manually. This script implements a subset of +`gclient sync`. + +This helps embedders, for example through CMake, get all the sources with +a single add_subdirectory call (or FetchContent) instead of more complex setups + +Note that this script executes blindly the content of DEPS file, run it only on +a project that you trust not to contain malicious DEPS files. +""" + +import os +import sys +import subprocess +import argparse +from pathlib import Path + +parser = argparse.ArgumentParser( + prog='fetch_dawn_dependencies', + description=__doc__, +) + +parser.add_argument('-d', + '--directory', + type=str, + default="", + help=""" + Working directory, in which we read and apply DEPS files recusively. If not + specified, the current working directory is used. + """) + +parser.add_argument('-g', + '--git', + type=str, + default="git", + help=""" + Path to the git command used to. By default, git is retrieved from the PATH. + You may also use this option to specify extra argument for all calls to git. + """) + +parser.add_argument('-s', + '--shallow', + action='store_true', + default=True, + help=""" + Clone repositories without commit history (only getting data for the + requested commit). + NB: The git server hosting the dependencies must have turned on the + `uploadpack.allowReachableSHA1InWant` option. + NB2: git submodules may not work as expected (but they are not used by Dawn + dependencies). + """) +parser.add_argument('-ns', + '--no-shallow', + action='store_false', + dest='shallow', + help="Deactivate shallow cloning.") + + +def main(args): + # The dependencies that we need to pull from the DEPS files. + # Dependencies of dependencies are prefixed by their ancestors. + required_submodules = [ + 'third_party/dawn', + 'third_party/glfw', + ] + + root_dir = Path(args.directory).resolve() + + process_dir(args, root_dir, required_submodules) + + +def process_dir(args, dir_path, required_submodules): + """ + Install dependencies for the provided directory by processing the DEPS file + that it contains (if it exists). + Recursively install dependencies in sub-directories that are created by + cloning dependencies. + """ + deps_path = dir_path / 'DEPS' + if not deps_path.is_file(): + return + + log(f"Listing dependencies from {dir_path}") + DEPS = open(deps_path).read() + + ldict = {} + exec(DEPS, globals(), ldict) + deps = ldict.get('deps') + variables = ldict.get('vars', {}) + + if deps is None: + log(f"ERROR: DEPS file '{deps_path}' does not define a 'deps' variable" + ) + exit(1) + + for submodule in required_submodules: + if submodule not in deps: + continue + submodule_path = dir_path / Path(submodule) + + raw_url = deps[submodule]['url'] + git_url, git_tag = raw_url.format(**variables).rsplit('@', 1) + + # Run git from within the submodule's path (don't use for clone) + git = lambda *x: subprocess.run([args.git, '-C', submodule_path, *x], + capture_output=True) + + log(f"Fetching dependency '{submodule}'") + if (submodule_path / ".git").is_dir(): + # The module was already cloned, but we may need to update it + proc = git('rev-parse', 'HEAD') + need_update = proc.stdout.decode().strip() != git_tag + + if need_update: + # The module was already cloned, but we may need to update it + proc = git('cat-file', '-t', git_tag) + git_tag_exists = proc.returncode == 0 + + if not git_tag_exists: + log(f"Updating '{submodule_path}' from '{git_url}'") + if args.shallow: + git('fetch', 'origin', git_tag, '--depth', '1') + else: + git('fetch', 'origin') + + log(f"Checking out tag '{git_tag}'") + git('checkout', git_tag) + + else: + os.makedirs(submodule_path / ".git", exist_ok=True) + if args.shallow: + log(f"Shallow cloning '{git_url}' at '{git_tag}' into '{submodule_path}'" + ) + shallow_clone(git, git_url, git_tag) + else: + log(f"Cloning '{git_url}' into '{submodule_path}'") + subprocess.run([ + args.git, + 'clone', + '--recurse-submodules', + git_url, + submodule_path, + ], + capture_output=True) + + log(f"Checking out tag '{git_tag}'") + git('checkout', git_tag) + + # Recursive call + required_subsubmodules = [ + m[len(submodule) + 1:] for m in required_submodules + if m.startswith(submodule + "/") + ] + process_dir(args, submodule_path, required_subsubmodules) + + +def shallow_clone(git, git_url, git_tag): + """ + Fetching only 1 commit is not exposed in the git clone API, so we decompose + it manually in git init, git fetch, git reset. + """ + git('init') + git('fetch', git_url, git_tag, '--depth', '1') + + +def log(msg): + """Just makes it look good in the CMake log flow.""" + print(f"-- -- {msg}") + + +class Var: + """ + Mock Var class, that the content of DEPS files assume to exist when they + are exec-ed. + """ + def __init__(self, name): + self.name = name + + def __add__(self, text): + return self.name + text + + def __radd__(self, text): + return text + self.name + + +if __name__ == "__main__": + main(parser.parse_args())
