| // Copyright 2017 The Dawn Authors |
| // |
| // 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 "SampleUtils.h" |
| |
| #include "utils/ComboRenderPipelineDescriptor.h" |
| #include "utils/SystemUtils.h" |
| #include "utils/WGPUHelpers.h" |
| |
| #include <vector> |
| |
| 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 = |
| 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 = 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::Sampled; |
| 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 = utils::CreateBufferFromData( |
| device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc); |
| wgpu::ImageCopyBuffer imageCopyBuffer = |
| utils::CreateImageCopyBuffer(stagingBuffer, 0, 4 * 1024); |
| wgpu::ImageCopyTexture imageCopyTexture = 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(device); |
| swapchain.Configure(GetPreferredSwapChainTextureFormat(), wgpu::TextureUsage::RenderAttachment, |
| 640, 480); |
| |
| initBuffers(); |
| initTextures(); |
| |
| wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"( |
| [[builtin(position)]] var<out> Position : vec4<f32>; |
| [[location(0)]] var<in> pos : vec4<f32>; |
| [[stage(vertex)]] fn main() -> void { |
| Position = pos; |
| return; |
| })"); |
| |
| wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"( |
| [[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>; |
| [[group(0), binding(0)]] var mySampler: sampler; |
| [[group(0), binding(1)]] var myTexture : texture_2d<f32>; |
| |
| [[location(0)]] var<out> FragColor : vec4<f32>; |
| [[stage(fragment)]] fn main() -> void { |
| FragColor = textureSample(myTexture, mySampler, FragCoord.xy / vec2<f32>(640.0, 480.0)); |
| return; |
| })"); |
| |
| auto bgl = utils::MakeBindGroupLayout( |
| device, { |
| {0, wgpu::ShaderStage::Fragment, wgpu::SamplerBindingType::Filtering}, |
| {1, wgpu::ShaderStage::Fragment, wgpu::TextureSampleType::Float}, |
| }); |
| |
| wgpu::PipelineLayout pl = utils::MakeBasicPipelineLayout(device, &bgl); |
| |
| depthStencilView = CreateDefaultDepthStencilView(device); |
| |
| utils::ComboRenderPipelineDescriptor2 descriptor; |
| descriptor.layout = 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.CreateRenderPipeline2(&descriptor); |
| |
| wgpu::TextureView view = texture.CreateView(); |
| |
| bindGroup = 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(); |
| 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.EndPass(); |
| } |
| |
| 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()) { |
| frame(); |
| utils::USleep(16000); |
| } |
| |
| // TODO release stuff |
| } |