Introduce render passes

* First API design (many features missing, including input attachments)
* Metal implementation (no OpenGL yet)
* Render-to-texture demo (a little broken until we have depth buffers)
* Update examples to use render passes

examples/Animometer.cpp

@@ -22,6 +22,8 @@
 nxt::Device device;
 nxt::Queue queue;
 nxt::Pipeline pipeline;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
 
 float RandomFloat(float min, float max) {
     float zeroOne = rand() / float(RAND_MAX);
@@ -103,7 +105,9 @@ void init() {
         })"
     );
 
+    CreateDefaultRenderPass(device, &renderpass, &framebuffer);
     pipeline = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 0)
         .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
         .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
         .GetResult();
@@ -129,6 +133,7 @@ void frame() {
     for (int j = 0; j < 50; j++) {
 
         nxt::CommandBufferBuilder builder = device.CreateCommandBufferBuilder()
+            .BeginRenderPass(renderpass, framebuffer)
             .SetPipeline(pipeline)
             .Clone();
 
@@ -140,6 +145,7 @@ void frame() {
             i++;
         }
 
+        builder.EndRenderPass();
         commands[j] = builder.GetResult();
     }
 

examples/CMakeLists.txt

@@ -60,6 +60,10 @@ add_executable(HelloCompute HelloCompute.cpp)
 target_link_libraries(HelloCompute utils)
 SetCXX14(HelloCompute)
 
+add_executable(RenderToTexture RenderToTexture.cpp)
+target_link_libraries(RenderToTexture utils)
+SetCXX14(RenderToTexture)
+
 add_executable(Animometer Animometer.cpp)
 target_link_libraries(Animometer utils)
 SetCXX14(Animometer)

examples/ComputeBoids.cpp

@@ -28,6 +28,8 @@ nxt::Buffer modelBuffer;
 std::array<nxt::Buffer, 2> particleBuffers;
 
 nxt::Pipeline renderPipeline;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
 
 nxt::Buffer updateParams;
 nxt::Pipeline updatePipeline;
@@ -134,7 +136,9 @@ void initRender() {
         .SetInput(1, sizeof(glm::vec2), nxt::InputStepMode::Vertex)
         .GetResult();
 
+    CreateDefaultRenderPass(device, &renderpass, &framebuffer);
     renderPipeline = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 0)
         .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
         .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
         .SetInputState(inputState)
@@ -279,11 +283,13 @@ void initCommandBuffers() {
             .SetBindGroup(0, updateBGs[i])
             .Dispatch(kNumParticles, 1, 1)
 
-            .SetPipeline(renderPipeline)
-            .TransitionBufferUsage(bufferDst, nxt::BufferUsageBit::Vertex)
-            .SetVertexBuffers(0, 1, &bufferDst, zeroOffsets)
-            .SetVertexBuffers(1, 1, &modelBuffer, zeroOffsets)
-            .DrawArrays(3, kNumParticles, 0, 0)
+            .BeginRenderPass(renderpass, framebuffer)
+                .SetPipeline(renderPipeline)
+                .TransitionBufferUsage(bufferDst, nxt::BufferUsageBit::Vertex)
+                .SetVertexBuffers(0, 1, &bufferDst, zeroOffsets)
+                .SetVertexBuffers(1, 1, &modelBuffer, zeroOffsets)
+                .DrawArrays(3, kNumParticles, 0, 0)
+            .EndRenderPass()
 
             .GetResult();
     }

examples/HelloCompute.cpp

@@ -22,6 +22,8 @@ nxt::Queue queue;
 nxt::Buffer buffer;
 nxt::Pipeline renderPipeline;
 nxt::BindGroup renderBindGroup;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
 nxt::Pipeline computePipeline;
 nxt::BindGroup computeBindGroup;
 
@@ -107,7 +109,9 @@ void init() {
             .SetBindGroupLayout(0, bgl)
             .GetResult();
 
+        CreateDefaultRenderPass(device, &renderpass, &framebuffer);
         renderPipeline = device.CreatePipelineBuilder()
+            .SetSubpass(renderpass, 0)
             .SetLayout(pl)
             .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
             .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
@@ -128,10 +132,12 @@ void frame() {
         .SetBindGroup(0, computeBindGroup)
         .Dispatch(1, 1, 1)
 
-        .SetPipeline(renderPipeline)
-        .TransitionBufferUsage(buffer, nxt::BufferUsageBit::Uniform)
-        .SetBindGroup(0, renderBindGroup)
-        .DrawArrays(3, 1, 0, 0)
+        .BeginRenderPass(renderpass, framebuffer)
+            .SetPipeline(renderPipeline)
+            .TransitionBufferUsage(buffer, nxt::BufferUsageBit::Uniform)
+            .SetBindGroup(0, renderBindGroup)
+            .DrawArrays(3, 1, 0, 0)
+        .EndRenderPass()
 
         .GetResult();
 

examples/HelloIndices.cpp

@@ -24,6 +24,8 @@ nxt::Buffer vertexBuffer;
 
 nxt::Queue queue;
 nxt::Pipeline pipeline;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
 
 void initBuffers() {
     static const uint32_t indexData[3] = {
@@ -82,7 +84,9 @@ void init() {
         .SetInput(0, 4 * sizeof(float), nxt::InputStepMode::Vertex)
         .GetResult();
 
+    CreateDefaultRenderPass(device, &renderpass, &framebuffer);
     pipeline = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 0)
         .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
         .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
         .SetInputState(inputState)
@@ -92,10 +96,12 @@ void init() {
 void frame() {
     static const uint32_t vertexBufferOffsets[1] = {0};
     nxt::CommandBuffer commands = device.CreateCommandBufferBuilder()
-        .SetPipeline(pipeline)
-        .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
-        .SetIndexBuffer(indexBuffer, 0, nxt::IndexFormat::Uint32)
-        .DrawElements(3, 1, 0, 0)
+        .BeginRenderPass(renderpass, framebuffer)
+            .SetPipeline(pipeline)
+            .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
+            .SetIndexBuffer(indexBuffer, 0, nxt::IndexFormat::Uint32)
+            .DrawElements(3, 1, 0, 0)
+        .EndRenderPass()
         .GetResult();
 
     queue.Submit(1, &commands);

examples/HelloInstancing.cpp

@@ -24,6 +24,8 @@ nxt::Buffer instanceBuffer;
 
 nxt::Queue queue;
 nxt::Pipeline pipeline;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
 
 void initBuffers() {
     static const float vertexData[12] = {
@@ -89,7 +91,9 @@ void init() {
         .SetInput(1, 2 * sizeof(float), nxt::InputStepMode::Instance)
         .GetResult();
 
+    CreateDefaultRenderPass(device, &renderpass, &framebuffer);
     pipeline = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 0)
         .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
         .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
         .SetInputState(inputState)
@@ -99,10 +103,12 @@ void init() {
 void frame() {
     static const uint32_t vertexBufferOffsets[1] = {0};
     nxt::CommandBuffer commands = device.CreateCommandBufferBuilder()
-        .SetPipeline(pipeline)
-        .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
-        .SetVertexBuffers(1, 1, &instanceBuffer, vertexBufferOffsets)
-        .DrawArrays(3, 4, 0, 0)
+        .BeginRenderPass(renderpass, framebuffer)
+            .SetPipeline(pipeline)
+            .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
+            .SetVertexBuffers(1, 1, &instanceBuffer, vertexBufferOffsets)
+            .DrawArrays(3, 4, 0, 0)
+        .EndRenderPass()
         .GetResult();
 
     queue.Submit(1, &commands);

examples/HelloTriangle.c

@@ -19,6 +19,8 @@
 nxtDevice device;
 nxtQueue queue;
 nxtPipeline pipeline;
+nxtRenderPass renderpass;
+nxtFramebuffer framebuffer;
 
 void init() {
     nxtProcTable procs;
@@ -47,8 +49,25 @@ void init() {
         "}\n";
     nxtShaderModule fsModule = CreateShaderModule(device, NXT_SHADER_STAGE_FRAGMENT, fs);
 
+    {
+        nxtRenderPassBuilder builder = nxtDeviceCreateRenderPassBuilder(device);
+        nxtRenderPassBuilderSetAttachmentCount(builder, 1);
+        nxtRenderPassBuilderAttachmentSetFormat(builder, 0, NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM);
+        nxtRenderPassBuilderSetSubpassCount(builder, 1);
+        nxtRenderPassBuilderSubpassSetColorAttachment(builder, 0, 0, 0);
+        renderpass = nxtRenderPassBuilderGetResult(builder);
+        nxtRenderPassBuilderRelease(builder);
+    }
+    {
+        nxtFramebufferBuilder builder = nxtDeviceCreateFramebufferBuilder(device);
+        nxtFramebufferBuilderSetRenderPass(builder, renderpass);
+        nxtFramebufferBuilderSetDimensions(builder, 640, 480);
+        framebuffer = nxtFramebufferBuilderGetResult(builder);
+        nxtFramebufferBuilderRelease(builder);
+    }
     {
         nxtPipelineBuilder builder = nxtDeviceCreatePipelineBuilder(device);
+        nxtPipelineBuilderSetSubpass(builder, renderpass, 0);
         nxtPipelineBuilderSetStage(builder, NXT_SHADER_STAGE_VERTEX, vsModule, "main");
         nxtPipelineBuilderSetStage(builder, NXT_SHADER_STAGE_FRAGMENT, fsModule, "main");
         pipeline = nxtPipelineBuilderGetResult(builder);
@@ -63,8 +82,10 @@ void frame() {
     nxtCommandBuffer commands;
     {
         nxtCommandBufferBuilder builder = nxtDeviceCreateCommandBufferBuilder(device);
+        nxtCommandBufferBuilderBeginRenderPass(builder, renderpass, framebuffer);
         nxtCommandBufferBuilderSetPipeline(builder, pipeline);
         nxtCommandBufferBuilderDrawArrays(builder, 3, 1, 0, 0);
+        nxtCommandBufferBuilderEndRenderPass(builder);
         commands = nxtCommandBufferBuilderGetResult(builder);
         nxtCommandBufferBuilderRelease(builder);
     }

examples/HelloTriangle.cpp

@@ -27,6 +27,8 @@ nxt::Sampler sampler;
 
 nxt::Queue queue;
 nxt::Pipeline pipeline;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
 nxt::BindGroup bindGroup;
 
 void initBuffers() {
@@ -135,7 +137,9 @@ void init() {
         .SetBindGroupLayout(0, bgl)
         .GetResult();
 
+    CreateDefaultRenderPass(device, &renderpass, &framebuffer);
     pipeline = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 0)
         .SetLayout(pl)
         .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
         .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
@@ -159,11 +163,13 @@ void frame() {
     if (s.b >= 1.0f) {s.b = 0.0f;}
     static const uint32_t vertexBufferOffsets[1] = {0};
     nxt::CommandBuffer commands = device.CreateCommandBufferBuilder()
-        .SetPipeline(pipeline)
-        .SetBindGroup(0, bindGroup)
-        .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
-        .SetIndexBuffer(indexBuffer, 0, nxt::IndexFormat::Uint32)
-        .DrawElements(3, 1, 0, 0)
+        .BeginRenderPass(renderpass, framebuffer)
+            .SetPipeline(pipeline)
+            .SetBindGroup(0, bindGroup)
+            .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
+            .SetIndexBuffer(indexBuffer, 0, nxt::IndexFormat::Uint32)
+            .DrawElements(3, 1, 0, 0)
+        .EndRenderPass()
         .GetResult();
 
     queue.Submit(1, &commands);

examples/HelloUBO.cpp

@@ -19,6 +19,8 @@
 nxt::Device device;
 nxt::Queue queue;
 nxt::Pipeline pipeline;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
 nxt::Buffer buffer;
 nxt::BindGroup bindGroup;
 
@@ -59,7 +61,9 @@ void init() {
         .SetBindGroupLayout(0, bgl)
         .GetResult();
 
+    CreateDefaultRenderPass(device, &renderpass, &framebuffer);
     pipeline = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 0)
         .SetLayout(pl)
         .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
         .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
@@ -91,10 +95,12 @@ void frame() {
     buffer.SetSubData(0, sizeof(s) / sizeof(uint32_t), reinterpret_cast<uint32_t*>(&s));
 
     nxt::CommandBuffer commands = device.CreateCommandBufferBuilder()
-        .SetPipeline(pipeline)
-        .TransitionBufferUsage(buffer, nxt::BufferUsageBit::Uniform)
-        .SetBindGroup(0, bindGroup)
-        .DrawArrays(3, 1, 0, 0)
+        .BeginRenderPass(renderpass, framebuffer)
+            .SetPipeline(pipeline)
+            .TransitionBufferUsage(buffer, nxt::BufferUsageBit::Uniform)
+            .SetBindGroup(0, bindGroup)
+            .DrawArrays(3, 1, 0, 0)
+        .EndRenderPass()
         .GetResult();
 
     queue.Submit(1, &commands);

examples/HelloVertices.cpp

@@ -23,6 +23,8 @@ nxt::Buffer vertexBuffer;
 
 nxt::Queue queue;
 nxt::Pipeline pipeline;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
 
 void initBuffers() {
     static const float vertexData[12] = {
@@ -59,7 +61,7 @@ void init() {
 
     nxt::ShaderModule fsModule = CreateShaderModule(device, nxt::ShaderStage::Fragment, R"(
         #version 450
-        out vec4 fragColor;
+        layout(location = 0) out vec4 fragColor;
         void main() {
             fragColor = vec4(1.0, 0.0, 0.0, 1.0);
         })"
@@ -70,7 +72,9 @@ void init() {
         .SetInput(0, 4 * sizeof(float), nxt::InputStepMode::Vertex)
         .GetResult();
 
+    CreateDefaultRenderPass(device, &renderpass, &framebuffer);
     pipeline = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 0)
         .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
         .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
         .SetInputState(inputState)
@@ -80,9 +84,11 @@ void init() {
 void frame() {
     static const uint32_t vertexBufferOffsets[1] = {0};
     nxt::CommandBuffer commands = device.CreateCommandBufferBuilder()
-        .SetPipeline(pipeline)
-        .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
-        .DrawArrays(3, 1, 0, 0)
+        .BeginRenderPass(renderpass, framebuffer)
+            .SetPipeline(pipeline)
+            .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
+            .DrawArrays(3, 1, 0, 0)
+        .EndRenderPass()
         .GetResult();
 
     queue.Submit(1, &commands);

examples/RenderToTexture.cpp

@@ -0,0 +1,235 @@
+// Copyright 2017 The NXT 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 "Utils.h"
+
+#include <unistd.h>
+#include <vector>
+
+nxt::Device device;
+
+nxt::Buffer vertexBuffer;
+nxt::Buffer vertexBufferQuad;
+
+nxt::Texture renderTarget;
+nxt::TextureView renderTargetView;
+nxt::Sampler samplerPost;
+
+nxt::Queue queue;
+nxt::Pipeline pipeline;
+nxt::Pipeline pipelinePost;
+nxt::BindGroup bindGroup;
+nxt::RenderPass renderpass;
+nxt::Framebuffer framebuffer;
+
+void initBuffers() {
+    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 = device.CreateBufferBuilder()
+        .SetAllowedUsage(nxt::BufferUsageBit::Mapped | nxt::BufferUsageBit::Vertex)
+        .SetInitialUsage(nxt::BufferUsageBit::Mapped)
+        .SetSize(sizeof(vertexData))
+        .GetResult();
+    vertexBuffer.SetSubData(0, sizeof(vertexData) / sizeof(uint32_t),
+            reinterpret_cast<const uint32_t*>(vertexData));
+    vertexBuffer.FreezeUsage(nxt::BufferUsageBit::Vertex);
+
+    static const float vertexDataQuad[24] = {
+        -1.0f, -1.0f, 0.0f, 1.0f,
+        -1.0f, 1.0f, 0.0f, 1.0f,
+        1.0f, -1.0f, 0.0f, 1.0f,
+        -1.0f, 1.0f, 0.0f, 1.0f,
+        1.0f, -1.0f, 0.0f, 1.0f,
+        1.0f, 1.0f, 0.0f, 1.0f,
+    };
+    vertexBufferQuad = device.CreateBufferBuilder()
+        .SetAllowedUsage(nxt::BufferUsageBit::Mapped | nxt::BufferUsageBit::Vertex)
+        .SetInitialUsage(nxt::BufferUsageBit::Mapped)
+        .SetSize(sizeof(vertexDataQuad))
+        .GetResult();
+    vertexBufferQuad.SetSubData(0, sizeof(vertexDataQuad) / sizeof(uint32_t),
+            reinterpret_cast<const uint32_t*>(vertexDataQuad));
+    vertexBufferQuad.FreezeUsage(nxt::BufferUsageBit::Vertex);
+}
+
+void initTextures() {
+    renderTarget = device.CreateTextureBuilder()
+        .SetDimension(nxt::TextureDimension::e2D)
+        .SetExtent(640, 480, 1)
+        .SetFormat(nxt::TextureFormat::R8G8B8A8Unorm)
+        .SetMipLevels(1)
+        .SetAllowedUsage(nxt::TextureUsageBit::ColorAttachment | nxt::TextureUsageBit::Sampled)
+        .SetInitialUsage(nxt::TextureUsageBit::ColorAttachment)
+        .GetResult();
+    renderTargetView = renderTarget.CreateTextureViewBuilder().GetResult();
+
+    samplerPost = device.CreateSamplerBuilder()
+        .SetFilterMode(nxt::FilterMode::Linear, nxt::FilterMode::Linear, nxt::FilterMode::Linear)
+        .GetResult();
+}
+
+void initRenderPass() {
+    renderpass = device.CreateRenderPassBuilder()
+        .SetAttachmentCount(2)
+        .AttachmentSetFormat(0, nxt::TextureFormat::R8G8B8A8Unorm)
+        .AttachmentSetFormat(1, nxt::TextureFormat::R8G8B8A8Unorm)
+        .SetSubpassCount(2)
+        // subpass 0
+        .SubpassSetColorAttachment(0, 0, 0) // -> render target
+        // subpass 1
+        .SubpassSetColorAttachment(1, 0, 1) // -> back buffer
+        .GetResult();
+    framebuffer = device.CreateFramebufferBuilder()
+        .SetRenderPass(renderpass)
+        // attachment 0 -> render target
+        .SetAttachment(0, renderTargetView)
+        // attachment 1 -> back buffer
+        // (implicit) // TODO(kainino@chromium.org): use the texture provided by WSI
+        .SetDimensions(640, 480)
+        .GetResult();
+}
+
+void initPipeline() {
+    nxt::ShaderModule vsModule = CreateShaderModule(device, nxt::ShaderStage::Vertex, R"(
+        #version 450
+        layout(location = 0) in vec4 pos;
+        void main() {
+            gl_Position = pos;
+        })"
+    );
+
+    nxt::ShaderModule fsModule = CreateShaderModule(device, nxt::ShaderStage::Fragment, R"(
+        #version 450
+        layout(location = 0) out vec4 fragColor;
+        void main() {
+            fragColor = vec4(1.0, 0.0, 0.0, 1.0);
+        })"
+    );
+
+    auto inputState = device.CreateInputStateBuilder()
+        .SetAttribute(0, 0, nxt::VertexFormat::FloatR32G32B32A32, 0)
+        .SetInput(0, 4 * sizeof(float), nxt::InputStepMode::Vertex)
+        .GetResult();
+
+    pipeline = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 0)
+        .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
+        .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
+        .SetInputState(inputState)
+        .GetResult();
+}
+
+void initPipelinePost() {
+    nxt::ShaderModule vsModule = CreateShaderModule(device, nxt::ShaderStage::Vertex, R"(
+        #version 450
+        layout(location = 0) in vec4 pos;
+        void main() {
+            gl_Position = pos;
+        })"
+    );
+
+    nxt::ShaderModule fsModule = CreateShaderModule(device, nxt::ShaderStage::Fragment, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform sampler samp;
+        layout(set = 0, binding = 1) uniform texture2D tex;
+        layout(location = 0) out vec4 fragColor;
+        void main() {
+            fragColor = texture(sampler2D(tex, samp), gl_FragCoord.xy / vec2(640.0, 480.0)) + vec4(0.0, 0.0, 0.5, 0.0);
+        })"
+    );
+
+    auto inputState = device.CreateInputStateBuilder()
+        .SetAttribute(0, 0, nxt::VertexFormat::FloatR32G32B32A32, 0)
+        .SetInput(0, 4 * sizeof(float), nxt::InputStepMode::Vertex)
+        .GetResult();
+
+    nxt::BindGroupLayout bgl = device.CreateBindGroupLayoutBuilder()
+        .SetBindingsType(nxt::ShaderStageBit::Fragment, nxt::BindingType::Sampler, 0, 1)
+        .SetBindingsType(nxt::ShaderStageBit::Fragment, nxt::BindingType::SampledTexture, 1, 1)
+        .GetResult();
+
+    nxt::PipelineLayout pl = device.CreatePipelineLayoutBuilder()
+        .SetBindGroupLayout(0, bgl)
+        .GetResult();
+
+    pipelinePost = device.CreatePipelineBuilder()
+        .SetSubpass(renderpass, 1)
+        .SetLayout(pl)
+        .SetStage(nxt::ShaderStage::Vertex, vsModule, "main")
+        .SetStage(nxt::ShaderStage::Fragment, fsModule, "main")
+        .SetInputState(inputState)
+        .GetResult();
+
+    bindGroup = device.CreateBindGroupBuilder()
+        .SetLayout(bgl)
+        .SetUsage(nxt::BindGroupUsage::Frozen)
+        .SetSamplers(0, 1, &samplerPost)
+        .SetTextureViews(1, 1, &renderTargetView)
+        .GetResult();
+}
+
+void init() {
+    nxtProcTable procs;
+    GetProcTableAndDevice(&procs, &device);
+    nxtSetProcs(&procs);
+
+    queue = device.CreateQueueBuilder().GetResult();
+
+    initBuffers();
+    initTextures();
+    initRenderPass();
+    initPipeline();
+    initPipelinePost();
+}
+
+void frame() {
+    static const uint32_t vertexBufferOffsets[1] = {0};
+    nxt::CommandBuffer commands = device.CreateCommandBufferBuilder()
+        .BeginRenderPass(renderpass, framebuffer)
+            // renderTarget is not transitioned here because it's implicit in
+            // BeginRenderPass or AdvanceSubpass.
+            .SetPipeline(pipeline)
+            .SetVertexBuffers(0, 1, &vertexBuffer, vertexBufferOffsets)
+            .DrawArrays(3, 1, 0, 0)
+        .AdvanceSubpass()
+            // renderTarget must be transitioned here because it's Sampled, not
+            // ColorAttachment or InputAttachment.
+            .TransitionTextureUsage(renderTarget, nxt::TextureUsageBit::Sampled)
+            .SetPipeline(pipelinePost)
+            .SetBindGroup(0, bindGroup)
+            .SetVertexBuffers(0, 1, &vertexBufferQuad, vertexBufferOffsets)
+            .DrawArrays(6, 1, 0, 0)
+        .EndRenderPass()
+        .GetResult();
+
+    queue.Submit(1, &commands);
+    SwapBuffers();
+}
+
+int main(int argc, const char* argv[]) {
+    if (!InitUtils(argc, argv)) {
+        return 1;
+    }
+    init();
+
+    while (!ShouldQuit()) {
+        frame();
+        usleep(16000);
+    }
+
+    // TODO release stuff
+}

examples/Utils.cpp

@@ -200,6 +200,19 @@ nxt::ShaderModule CreateShaderModule(const nxt::Device& device, nxt::ShaderStage
         .GetResult();
 }
 
+void CreateDefaultRenderPass(const nxt::Device& device, nxt::RenderPass* renderPass, nxt::Framebuffer* framebuffer) {
+    *renderPass = device.CreateRenderPassBuilder()
+        .SetAttachmentCount(1)
+        .AttachmentSetFormat(0, nxt::TextureFormat::R8G8B8A8Unorm)
+        .SetSubpassCount(1)
+        .SubpassSetColorAttachment(0, 0, 0)
+        .GetResult();
+    *framebuffer = device.CreateFramebufferBuilder()
+        .SetRenderPass(*renderPass)
+        .SetDimensions(640, 480)
+        .GetResult();
+}
+
 extern "C" {
     bool InitUtils(int argc, const char** argv) {
         for (int i = 0; i < argc; i++) {

examples/Utils.h

@@ -32,6 +32,7 @@ extern "C" {
     #include <nxt/nxtcpp.h>
     void GetProcTableAndDevice(nxtProcTable* procs, nxt::Device* device);
     nxt::ShaderModule CreateShaderModule(const nxt::Device& device, nxt::ShaderStage stage, const char* source);
+    void CreateDefaultRenderPass(const nxt::Device& device, nxt::RenderPass* renderPass, nxt::Framebuffer* framebuffer);
 #else
     void GetProcTableAndDevice(nxtProcTable* procs, nxtDevice* device);
     nxtShaderModule CreateShaderModule(nxtDevice device, nxtShaderStage stage, const char* source);