2018-07-18 09:40:26 +00:00
|
|
|
// Copyright 2017 The Dawn Authors
|
2017-04-20 18:38:20 +00:00
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
|
2017-06-19 17:15:13 +00:00
|
|
|
#include "SampleUtils.h"
|
2017-04-20 18:38:20 +00:00
|
|
|
|
2017-07-17 21:13:57 +00:00
|
|
|
#include "utils/SystemUtils.h"
|
2019-10-25 11:36:47 +00:00
|
|
|
#include "utils/WGPUHelpers.h"
|
2017-06-19 17:09:41 +00:00
|
|
|
|
2019-10-25 11:36:47 +00:00
|
|
|
WGPUDevice device;
|
|
|
|
WGPUQueue queue;
|
|
|
|
WGPUSwapChain swapchain;
|
|
|
|
WGPURenderPipeline pipeline;
|
2017-04-20 18:38:20 +00:00
|
|
|
|
2019-10-25 11:36:47 +00:00
|
|
|
WGPUTextureFormat swapChainFormat;
|
2018-01-19 17:51:18 +00:00
|
|
|
|
2017-04-20 18:38:20 +00:00
|
|
|
void init() {
|
2018-07-18 12:06:10 +00:00
|
|
|
device = CreateCppDawnDevice().Release();
|
2021-02-04 15:33:42 +00:00
|
|
|
queue = wgpuDeviceGetQueue(device);
|
2017-04-20 18:38:20 +00:00
|
|
|
|
2017-07-28 01:30:57 +00:00
|
|
|
{
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPUSwapChainDescriptor descriptor = {};
|
2019-02-15 11:15:58 +00:00
|
|
|
descriptor.implementation = GetSwapChainImplementation();
|
2020-01-23 17:20:38 +00:00
|
|
|
swapchain = wgpuDeviceCreateSwapChain(device, nullptr, &descriptor);
|
2017-07-28 01:30:57 +00:00
|
|
|
}
|
2019-10-25 11:36:47 +00:00
|
|
|
swapChainFormat = static_cast<WGPUTextureFormat>(GetPreferredSwapChainTextureFormat());
|
2020-10-27 15:35:56 +00:00
|
|
|
wgpuSwapChainConfigure(swapchain, swapChainFormat, WGPUTextureUsage_RenderAttachment, 640, 480);
|
2017-07-28 01:30:57 +00:00
|
|
|
|
2017-04-20 18:38:20 +00:00
|
|
|
const char* vs =
|
2021-01-21 15:41:20 +00:00
|
|
|
"[[builtin(vertex_index)]] var<in> VertexIndex : u32;\n"
|
2020-11-26 16:39:46 +00:00
|
|
|
"[[builtin(position)]] var<out> Position : vec4<f32>;\n"
|
|
|
|
"const pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(\n"
|
|
|
|
" vec2<f32>( 0.0, 0.5),\n"
|
|
|
|
" vec2<f32>(-0.5, -0.5),\n"
|
|
|
|
" vec2<f32>( 0.5, -0.5)\n"
|
|
|
|
");\n"
|
|
|
|
"[[stage(vertex)]] fn main() -> void {\n"
|
|
|
|
" Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);\n"
|
|
|
|
" return;\n"
|
2017-04-20 18:38:20 +00:00
|
|
|
"}\n";
|
2020-11-26 16:39:46 +00:00
|
|
|
WGPUShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, vs).Release();
|
2017-04-20 18:38:20 +00:00
|
|
|
|
|
|
|
const char* fs =
|
2020-11-26 16:39:46 +00:00
|
|
|
"[[location(0)]] var<out> fragColor : vec4<f32>;\n"
|
|
|
|
"[[stage(fragment)]] fn main() -> void {\n"
|
|
|
|
" fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);\n"
|
|
|
|
" return;\n"
|
2017-04-20 18:38:20 +00:00
|
|
|
"}\n";
|
2020-11-26 16:39:46 +00:00
|
|
|
WGPUShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, fs).Release();
|
2017-04-20 18:38:20 +00:00
|
|
|
|
|
|
|
{
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPURenderPipelineDescriptor descriptor = {};
|
2018-12-10 19:47:22 +00:00
|
|
|
|
2019-09-05 09:35:07 +00:00
|
|
|
descriptor.vertexStage.module = vsModule;
|
|
|
|
descriptor.vertexStage.entryPoint = "main";
|
2018-12-10 19:47:22 +00:00
|
|
|
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPUProgrammableStageDescriptor fragmentStage = {};
|
2018-12-10 19:47:22 +00:00
|
|
|
fragmentStage.module = fsModule;
|
|
|
|
fragmentStage.entryPoint = "main";
|
|
|
|
descriptor.fragmentStage = &fragmentStage;
|
|
|
|
|
|
|
|
descriptor.sampleCount = 1;
|
|
|
|
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPUBlendDescriptor blendDescriptor = {};
|
2019-10-25 11:36:47 +00:00
|
|
|
blendDescriptor.operation = WGPUBlendOperation_Add;
|
|
|
|
blendDescriptor.srcFactor = WGPUBlendFactor_One;
|
|
|
|
blendDescriptor.dstFactor = WGPUBlendFactor_One;
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPUColorStateDescriptor colorStateDescriptor = {};
|
2019-02-15 02:20:57 +00:00
|
|
|
colorStateDescriptor.format = swapChainFormat;
|
|
|
|
colorStateDescriptor.alphaBlend = blendDescriptor;
|
|
|
|
colorStateDescriptor.colorBlend = blendDescriptor;
|
2019-10-25 11:36:47 +00:00
|
|
|
colorStateDescriptor.writeMask = WGPUColorWriteMask_All;
|
2019-02-20 13:00:36 +00:00
|
|
|
|
2019-02-21 00:45:19 +00:00
|
|
|
descriptor.colorStateCount = 1;
|
2019-09-20 23:22:27 +00:00
|
|
|
descriptor.colorStates = &colorStateDescriptor;
|
2018-12-10 19:47:22 +00:00
|
|
|
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPUPipelineLayoutDescriptor pl = {};
|
2019-02-21 00:45:19 +00:00
|
|
|
pl.bindGroupLayoutCount = 0;
|
2018-12-10 19:47:22 +00:00
|
|
|
pl.bindGroupLayouts = nullptr;
|
2019-10-25 11:36:47 +00:00
|
|
|
descriptor.layout = wgpuDeviceCreatePipelineLayout(device, &pl);
|
2018-12-10 19:47:22 +00:00
|
|
|
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPUVertexStateDescriptor vertexState = {};
|
2020-11-26 16:39:46 +00:00
|
|
|
vertexState.indexFormat = WGPUIndexFormat_Undefined;
|
2019-11-07 22:23:29 +00:00
|
|
|
vertexState.vertexBufferCount = 0;
|
|
|
|
vertexState.vertexBuffers = nullptr;
|
|
|
|
descriptor.vertexState = &vertexState;
|
2018-12-10 19:47:22 +00:00
|
|
|
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPURasterizationStateDescriptor rasterizationState = {};
|
2019-10-25 11:36:47 +00:00
|
|
|
rasterizationState.frontFace = WGPUFrontFace_CCW;
|
|
|
|
rasterizationState.cullMode = WGPUCullMode_None;
|
2019-04-11 18:46:54 +00:00
|
|
|
rasterizationState.depthBias = 0;
|
|
|
|
rasterizationState.depthBiasSlopeScale = 0.0;
|
|
|
|
rasterizationState.depthBiasClamp = 0.0;
|
|
|
|
descriptor.rasterizationState = &rasterizationState;
|
|
|
|
|
2019-10-25 11:36:47 +00:00
|
|
|
descriptor.primitiveTopology = WGPUPrimitiveTopology_TriangleList;
|
2019-07-15 20:47:56 +00:00
|
|
|
descriptor.sampleMask = 0xFFFFFFFF;
|
|
|
|
descriptor.alphaToCoverageEnabled = false;
|
2018-12-10 19:47:22 +00:00
|
|
|
|
2019-02-15 02:20:57 +00:00
|
|
|
descriptor.depthStencilState = nullptr;
|
2018-12-10 19:47:22 +00:00
|
|
|
|
2019-10-25 11:36:47 +00:00
|
|
|
pipeline = wgpuDeviceCreateRenderPipeline(device, &descriptor);
|
2017-04-20 18:38:20 +00:00
|
|
|
}
|
|
|
|
|
2019-10-25 11:36:47 +00:00
|
|
|
wgpuShaderModuleRelease(vsModule);
|
|
|
|
wgpuShaderModuleRelease(fsModule);
|
2017-04-20 18:38:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void frame() {
|
2019-11-12 18:30:11 +00:00
|
|
|
WGPUTextureView backbufferView = wgpuSwapChainGetCurrentTextureView(swapchain);
|
2020-02-28 22:29:15 +00:00
|
|
|
WGPURenderPassDescriptor renderpassInfo = {};
|
|
|
|
WGPURenderPassColorAttachmentDescriptor colorAttachment = {};
|
2017-07-28 01:30:57 +00:00
|
|
|
{
|
2018-12-19 08:21:13 +00:00
|
|
|
colorAttachment.attachment = backbufferView;
|
|
|
|
colorAttachment.resolveTarget = nullptr;
|
2020-07-10 20:33:08 +00:00
|
|
|
colorAttachment.clearColor = {0.0f, 0.0f, 0.0f, 0.0f};
|
2019-10-25 11:36:47 +00:00
|
|
|
colorAttachment.loadOp = WGPULoadOp_Clear;
|
|
|
|
colorAttachment.storeOp = WGPUStoreOp_Store;
|
2019-02-27 09:21:56 +00:00
|
|
|
renderpassInfo.colorAttachmentCount = 1;
|
2019-09-20 22:59:47 +00:00
|
|
|
renderpassInfo.colorAttachments = &colorAttachment;
|
2019-02-27 09:21:56 +00:00
|
|
|
renderpassInfo.depthStencilAttachment = nullptr;
|
2017-07-28 01:30:57 +00:00
|
|
|
}
|
2019-10-25 11:36:47 +00:00
|
|
|
WGPUCommandBuffer commands;
|
2017-04-20 18:38:20 +00:00
|
|
|
{
|
2019-10-25 11:36:47 +00:00
|
|
|
WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
|
2018-09-21 00:24:37 +00:00
|
|
|
|
2019-10-25 11:36:47 +00:00
|
|
|
WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(encoder, &renderpassInfo);
|
|
|
|
wgpuRenderPassEncoderSetPipeline(pass, pipeline);
|
|
|
|
wgpuRenderPassEncoderDraw(pass, 3, 1, 0, 0);
|
|
|
|
wgpuRenderPassEncoderEndPass(pass);
|
|
|
|
wgpuRenderPassEncoderRelease(pass);
|
2018-09-21 00:24:37 +00:00
|
|
|
|
2019-10-25 11:36:47 +00:00
|
|
|
commands = wgpuCommandEncoderFinish(encoder, nullptr);
|
|
|
|
wgpuCommandEncoderRelease(encoder);
|
2017-04-20 18:38:20 +00:00
|
|
|
}
|
|
|
|
|
2019-10-25 11:36:47 +00:00
|
|
|
wgpuQueueSubmit(queue, 1, &commands);
|
|
|
|
wgpuCommandBufferRelease(commands);
|
2019-11-12 18:30:11 +00:00
|
|
|
wgpuSwapChainPresent(swapchain);
|
2019-10-25 11:36:47 +00:00
|
|
|
wgpuTextureViewRelease(backbufferView);
|
2017-04-20 18:38:20 +00:00
|
|
|
|
2017-07-28 01:30:57 +00:00
|
|
|
DoFlush();
|
2017-04-20 18:38:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, const char* argv[]) {
|
2017-06-19 17:15:13 +00:00
|
|
|
if (!InitSample(argc, argv)) {
|
2017-04-20 18:38:20 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
init();
|
|
|
|
|
|
|
|
while (!ShouldQuit()) {
|
|
|
|
frame();
|
2017-07-17 21:13:57 +00:00
|
|
|
utils::USleep(16000);
|
2017-04-20 18:38:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// TODO release stuff
|
|
|
|
}
|