Add shader code listings

Overv · Overv · commit e0454c98f297 · 2017-01-19T19:10:14.000+01:00
diff --git a/03_Drawing_a_triangle/00_Setup/00_Base_code.md b/03_Drawing_a_triangle/00_Setup/00_Base_code.md
@@ -319,4 +319,4 @@ When you run the program now you should see a window titled `Vulkan` show up
 until the application is terminated by closing the window. Now that we have the
 skeleton for the Vulkan application, let's [create the first Vulkan object](!Drawing_a_triangle/Setup/Instance)!
 
-[Full code listing](/code/base_code.cpp)
+[C++ code](/code/base_code.cpp) /
diff --git a/03_Drawing_a_triangle/00_Setup/01_Instance.md b/03_Drawing_a_triangle/00_Setup/01_Instance.md
@@ -170,4 +170,4 @@ list.
 Before continuing with the more complex steps after instance creation, it's time
 to evaluate our debugging options by checking out [validation layers](!Drawing_a_triangle/Setup/Validation_layers).
 
-[Full code listing](/code/instance_creation.cpp)
+[C++ code](/code/instance_creation.cpp) /
diff --git a/03_Drawing_a_triangle/00_Setup/02_Validation_layers.md b/03_Drawing_a_triangle/00_Setup/02_Validation_layers.md
@@ -377,4 +377,4 @@ you how helpful the validation layers are with catching them and to teach you
 how important it is to know exactly what you're doing with Vulkan. Now it's time
 to look at [Vulkan devices in the system](!Drawing_a_triangle/Setup/Physical_devices_and_queue_families).
 
-[Full code listing](/code/validation_layers.cpp)
+[C++ code](/code/validation_layers.cpp) /
diff --git a/03_Drawing_a_triangle/00_Setup/03_Physical_devices_and_queue_families.md b/03_Drawing_a_triangle/00_Setup/03_Physical_devices_and_queue_families.md
@@ -277,4 +277,4 @@ Great, that's all we need for now to find the right physical device! The next
 step is to [create a logical device](!Drawing_a_triangle/Setup/Logical_device_and_queues)
 to interface with it.
 
-[Full code listing](/code/physical_device_selection.cpp)
+[C++ code](/code/physical_device_selection.cpp) /
diff --git a/03_Drawing_a_triangle/00_Setup/04_Logical_device_and_queues.md b/03_Drawing_a_triangle/00_Setup/04_Logical_device_and_queues.md
@@ -159,4 +159,4 @@ With the logical device and queue handles we can now actually start using the
 graphics card to do things! In the next few chapters we'll set up the resources
 to present results to the window system.
 
-[Full code listing](/code/logical_device.cpp)
+[C++ code](/code/logical_device.cpp) /
diff --git a/03_Drawing_a_triangle/01_Presentation/00_Window_surface.md b/03_Drawing_a_triangle/01_Presentation/00_Window_surface.md
@@ -215,4 +215,4 @@ In case the queue families are the same, the two handles will most likely have
 the same value now. In the next chapter we're going to look at swap chains and
 how they give us the ability to present images to the surface.
 
-[Full code listing](/code/window_surface.cpp)
+[C++ code](/code/window_surface.cpp) /
diff --git a/03_Drawing_a_triangle/01_Presentation/01_Swap_chain.md b/03_Drawing_a_triangle/01_Presentation/01_Swap_chain.md
@@ -585,4 +585,4 @@ We now have a set of images that can be drawn onto and can be presented to the
 window. The next two chapters will cover how we can set up the images as render
 targets and then we start looking into the actual drawing commands!
 
-[Full code listing](/code/swap_chain_creation.cpp)
+[C++ code](/code/swap_chain_creation.cpp) /
diff --git a/03_Drawing_a_triangle/01_Presentation/02_Image_views.md b/03_Drawing_a_triangle/01_Presentation/02_Image_views.md
@@ -119,4 +119,4 @@ quite ready to be used as a render target just yet. That requires one more step
 of indirection, known as a framebuffer. But first we'll have to set up the
 graphics pipeline.
 
-[Full code listing](/code/image_views.cpp)
+[C++ code](/code/image_views.cpp) /
diff --git a/03_Drawing_a_triangle/02_Graphics_pipeline_basics/00_Introduction.md b/03_Drawing_a_triangle/02_Graphics_pipeline_basics/00_Introduction.md
@@ -96,4 +96,4 @@ void createGraphicsPipeline() {
 }
 ```
 
-[Full code listing](/code/graphics_pipeline.cpp)
+[C++ code](/code/graphics_pipeline.cpp) /
diff --git a/03_Drawing_a_triangle/02_Graphics_pipeline_basics/01_Shader_modules.md b/03_Drawing_a_triangle/02_Graphics_pipeline_basics/01_Shader_modules.md
@@ -464,4 +464,6 @@ VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShade
 That's all there is to describing the programmable stages of the pipeline. In
 the next chapter we'll look at the fixed-function stages.
 
-[Full code listing](/code/shader_modules.cpp)
+[C++ code](/code/shader_modules.cpp) /
+[Vertex shader](/code/shader_base.vert) /
+[Fragment shader](/code/shader_base.frag)
diff --git a/03_Drawing_a_triangle/02_Graphics_pipeline_basics/02_Fixed_functions.md b/03_Drawing_a_triangle/02_Graphics_pipeline_basics/02_Fixed_functions.md
@@ -398,4 +398,6 @@ is not what you expect.
 There is however one more object to create before we can finally create the
 graphics pipeline and that is a [render pass](!Drawing_a_triangle/Graphics_pipeline_basics/Render_passes).
 
-[Full code listing](/code/fixed_functions.cpp)
+[C++ code](/code/fixed_functions.cpp) /
+[Vertex shader](/code/shader_base.vert) /
+[Fragment shader](/code/shader_base.frag)
diff --git a/03_Drawing_a_triangle/02_Graphics_pipeline_basics/03_Render_passes.md b/03_Drawing_a_triangle/02_Graphics_pipeline_basics/03_Render_passes.md
@@ -197,4 +197,6 @@ if (vkCreateRenderPass(device, &renderPassInfo, nullptr, renderPass.replace()) !
 That was a lot of work, but in the next chapter it all comes together to finally
 create the graphics pipeline object!
 
-[Full code listing](/code/render_passes.cpp)
+[C++ code](/code/render_passes.cpp) /
+[Vertex shader](/code/shader_base.vert) /
+[Fragment shader](/code/shader_base.frag)
diff --git a/03_Drawing_a_triangle/02_Graphics_pipeline_basics/04_Conclusion.md b/03_Drawing_a_triangle/02_Graphics_pipeline_basics/04_Conclusion.md
@@ -97,4 +97,6 @@ successful pipeline creation! We are already getting quite close to seeing
 something pop up on the screen. In the next couple of chapters we'll set up the
 actual framebuffers from the swap chain images and prepare the drawing commands.
 
-[Full code listing](/code/graphics_pipeline_complete.cpp)
+[C++ code](/code/graphics_pipeline_complete.cpp) /
+[Vertex shader](/code/shader_base.vert) /
+[Fragment shader](/code/shader_base.frag)
diff --git a/03_Drawing_a_triangle/03_Drawing/00_Framebuffers.md b/03_Drawing_a_triangle/03_Drawing/00_Framebuffers.md
@@ -89,4 +89,6 @@ We've now reached the milestone where we have all of the objects that are
 required for rendering. In the next chapter we're going to write the first
 actual drawing commands.
 
-[Full code listing](/code/framebuffers.cpp)
+[C++ code](/code/framebuffers.cpp) /
+[Vertex shader](/code/shader_base.vert) /
+[Fragment shader](/code/shader_base.frag)
diff --git a/03_Drawing_a_triangle/03_Drawing/01_Command_buffers.md b/03_Drawing_a_triangle/03_Drawing/01_Command_buffers.md
@@ -293,4 +293,6 @@ In the next chapter we'll write the code for the main loop, which will acquire
 an image from the swap chain, execute the right command buffer and return the
 finished image to the swap chain.
 
-[Full code listing](/code/command_buffers.cpp)
+[C++ code](/code/command_buffers.cpp) /
+[Vertex shader](/code/shader_base.vert) /
+[Fragment shader](/code/shader_base.frag)
diff --git a/03_Drawing_a_triangle/03_Drawing/02_Rendering_and_presentation.md b/03_Drawing_a_triangle/03_Drawing/02_Rendering_and_presentation.md
@@ -355,4 +355,6 @@ from this point on.
 In the next chapter we'll deal with one more small thing that is required for a
 well-behaved Vulkan program.
 
-[Full code listing](/code/hello_triangle.cpp)
+[C++ code](/code/hello_triangle.cpp) /
+[Vertex shader](/code/shader_base.vert) /
+[Fragment shader](/code/shader_base.frag)
diff --git a/03_Drawing_a_triangle/04_Swap_chain_recreation.md b/03_Drawing_a_triangle/04_Swap_chain_recreation.md
@@ -180,4 +180,6 @@ Congratulations, you've now finished your very first well-behaved Vulkan
 program! In the next chapter we're going to get rid of the hardcoded vertices in
 the vertex shader and actually use a vertex buffer.
 
-[Full code listing](/code/swap_chain_recreation.cpp)
+[C++ code](/code/swap_chain_recreation.cpp) /
+[Vertex shader](/code/shader_base.vert) /
+[Fragment shader](/code/shader_base.frag)
diff --git a/04_Vertex_buffers/00_Vertex_input_description.md b/04_Vertex_buffers/00_Vertex_input_description.md
@@ -213,4 +213,6 @@ validation layers enabled, you'll see that it complains that there is no vertex
 buffer bound to the binding. The next step is to create a vertex buffer and move
 the vertex data to it so the GPU is able to access it.
 
-[Full code listing](/code/vertex_input.cpp)
+[C++ code](/code/vertex_input.cpp) /
+[Vertex shader](/code/shader_vertexbuffer.vert) /
+[Fragment shader](/code/shader_vertexbuffer.frag)
diff --git a/04_Vertex_buffers/01_Vertex_buffer_creation.md b/04_Vertex_buffers/01_Vertex_buffer_creation.md
@@ -312,4 +312,6 @@ Run the program again and you should see the following:
 In the next chapter we'll look at a different way to copy vertex data to a
 vertex buffer that results in better performance, but takes some more work.
 
-[Full code listing](/code/vertex_buffer.cpp)
+[C++ code](/code/vertex_buffer.cpp) /
+[Vertex shader](/code/shader_vertexbuffer.vert) /
+[Fragment shader](/code/shader_vertexbuffer.frag)
diff --git a/04_Vertex_buffers/02_Staging_buffer.md b/04_Vertex_buffers/02_Staging_buffer.md
@@ -251,4 +251,6 @@ any Vulkan program to properly handle allocations. It's okay to use a separate
 allocation for every resource for this tutorial, because we won't come close to
 hitting any of these limits for now.
 
-[Full code listing](/code/staging_buffer.cpp)
+[C++ code](/code/staging_buffer.cpp) /
+[Vertex shader](/code/shader_vertexbuffer.vert) /
+[Fragment shader](/code/shader_vertexbuffer.frag)
diff --git a/04_Vertex_buffers/03_Index_buffer.md b/04_Vertex_buffers/03_Index_buffer.md
@@ -154,4 +154,6 @@ provided that their data is refreshed, of course. This is known as *aliasing*
 and some Vulkan functions have explicit flags to specify that you want to do
 this.
 
-[Full code listing](/code/index_buffer.cpp)
+[C++ code](/code/index_buffer.cpp) /
+[Vertex shader](/code/shader_vertexbuffer.vert) /
+[Fragment shader](/code/shader_vertexbuffer.frag)
diff --git a/05_Uniform_buffers/00_Descriptor_layout_and_buffer.md b/05_Uniform_buffers/00_Descriptor_layout_and_buffer.md
@@ -378,4 +378,6 @@ In the next chapter we'll look at descriptor sets, which will actually bind the
 `VkBuffer` to the uniform buffer descriptor so that the shader can access this
 transformation data.
 
-[Full code listing](/code/descriptor_layout.cpp)
+[C++ code](/code/descriptor_layout.cpp) /
+[Vertex shader](/code/shader_ubo.vert) /
+[Fragment shader](/code/shader_ubo.frag)
diff --git a/05_Uniform_buffers/01_Descriptor_pool_and_sets.md b/05_Uniform_buffers/01_Descriptor_pool_and_sets.md
@@ -240,4 +240,6 @@ You can use this feature to put descriptors that vary per-object and descriptors
 that are shared into separate descriptor sets. In that case you avoid rebinding
 most of the descriptors across draw calls which is potentially more efficient.
 
-[Full code listing](/code/descriptor_set.cpp)
+[C++ code](/code/descriptor_set.cpp) / /
+[Vertex shader](/code/shader_ubo.vert) / /
+[Fragment shader](/code/shader_ubo.frag)
diff --git a/06_Texture_mapping/00_Images.md b/06_Texture_mapping/00_Images.md
@@ -790,4 +790,6 @@ if you need to update the data in an image often.
 The image now contains the texture, but we still need a way to access it from
 the graphics pipeline. We'll work on that in the next chapter.
 
-[Full code listing](/code/texture_image.cpp)
+[C++ code](/code/texture_image.cpp) /
+[Vertex shader](/code/shader_ubo.vert) /
+[Fragment shader](/code/shader_ubo.frag)
diff --git a/06_Texture_mapping/01_Image_view_and_sampler.md b/06_Texture_mapping/01_Image_view_and_sampler.md
@@ -281,4 +281,6 @@ a single state.
 In the next chapter we will expose the image and sampler objects to the shaders
 to draw the texture onto the square.
 
-[Full code listing](/code/sampler.cpp)
+[C++ code](/code/sampler.cpp) /
+[Vertex shader](/code/shader_ubo.vert) /
+[Fragment shader](/code/shader_ubo.frag)
diff --git a/06_Texture_mapping/02_Combined_image_sampler.md b/06_Texture_mapping/02_Combined_image_sampler.md
@@ -265,4 +265,6 @@ when combined with images that are also written to in framebuffers. You can use
 these images as inputs to implement cool effects like post-processing and camera
 displays within the 3D world.
 
-[Full code listing](/code/texture_mapping.cpp)
+[C++ code](/code/texture_mapping.cpp) /
+[Vertex shader](/code/shader_textures.vert) /
+[Fragment shader](/code/shader_textures.frag)
diff --git a/07_Depth_buffering.md b/07_Depth_buffering.md
@@ -552,4 +552,6 @@ Congratulations, your application is now finally ready to render arbitrary 3D
 geometry and have it look right. We're going to try this out in the next chapter
 by drawing a textured model!
 
-[Full code listing](/code/depth_buffering.cpp)
+[C++ code](/code/depth_buffering.cpp) /
+[Vertex shader](/code/shader_textures.vert) /
+[Fragment shader](/code/shader_textures.frag)
diff --git a/08_Loading_models.md b/08_Loading_models.md
@@ -342,4 +342,6 @@ lighting, post-processing effects and shadow mapping. You should be able to
 learn how these effects work from tutorials for other APIs, because despite
 Vulkan's explicitness, many concepts still work the same.
 
-[Full code listing](/code/model_loading.cpp)
+[C++ code](/code/model_loading.cpp) /
+[Vertex shader](/code/shader_textures.vert) /
+[Fragment shader](/code/shader_textures.frag)
diff --git a/code/shader_base.frag b/code/shader_base.frag
@@ -0,0 +1,10 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}
diff --git a/code/shader_base.vert b/code/shader_base.vert
@@ -0,0 +1,25 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+layout(location = 0) out vec3 fragColor;
+
+vec2 positions[3] = vec2[](
+    vec2(0.0, -0.5),
+    vec2(0.5, 0.5),
+    vec2(-0.5, 0.5)
+);
+
+vec3 colors[3] = vec3[](
+    vec3(1.0, 0.0, 0.0),
+    vec3(0.0, 1.0, 0.0),
+    vec3(0.0, 0.0, 1.0)
+);
+
+void main() {
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    fragColor = colors[gl_VertexIndex];
+}
diff --git a/code/shader_textures.frag b/code/shader_textures.frag
@@ -0,0 +1,13 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 1) uniform sampler2D texSampler;
+
+layout(location = 0) in vec3 fragColor;
+layout(location = 1) in vec2 fragTexCoord;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = texture(texSampler, fragTexCoord);
+}
diff --git a/code/shader_textures.vert b/code/shader_textures.vert
@@ -0,0 +1,25 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 0) uniform UniformBufferObject {
+    mat4 model;
+    mat4 view;
+    mat4 proj;
+} ubo;
+
+layout(location = 0) in vec3 inPosition;
+layout(location = 1) in vec3 inColor;
+layout(location = 2) in vec2 inTexCoord;
+
+layout(location = 0) out vec3 fragColor;
+layout(location = 1) out vec2 fragTexCoord;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+    gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0);
+    fragColor = inColor;
+    fragTexCoord = inTexCoord;
+}
diff --git a/code/shader_ubo.frag b/code/shader_ubo.frag
@@ -0,0 +1,10 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}
diff --git a/code/shader_ubo.vert b/code/shader_ubo.vert
@@ -0,0 +1,22 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 0) uniform UniformBufferObject {
+    mat4 model;
+    mat4 view;
+    mat4 proj;
+} ubo;
+
+layout(location = 0) in vec3 inPosition;
+layout(location = 1) in vec3 inColor;
+
+layout(location = 0) out vec3 fragColor;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+    gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0);
+    fragColor = inColor;
+}
diff --git a/code/shader_vertexbuffer.frag b/code/shader_vertexbuffer.frag
@@ -0,0 +1,10 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}
diff --git a/code/shader_vertexbuffer.vert b/code/shader_vertexbuffer.vert
@@ -0,0 +1,16 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec2 inPosition;
+layout(location = 1) in vec3 inColor;
+
+layout(location = 0) out vec3 fragColor;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+    gl_Position = vec4(inPosition, 0.0, 1.0);
+    fragColor = inColor;
+}

Original file line number	Diff line number	Diff line change
`@@ -96,4 +96,4 @@ void createGraphicsPipeline() {`
`96`	`96`	`}`
`97`	`97`	```
`98`	`98`
`99`		`-[Full code listing](/code/graphics_pipeline.cpp)`
	`99`	`+[C++ code](/code/graphics_pipeline.cpp) /`