Normal vectors

Author: Pilzschaf

shaders/model_frag.glsl

@@ -1,7 +1,10 @@
 #version 450 core
 
+layout(location = 0) in vec3 in_normal;
+
 layout(location = 0) out vec4 out_color;
 
 void main() {
-	out_color = vec4(1.0);
+	vec3 normal = normalize(in_normal);
+	out_color = vec4(normal * 0.5 + 0.5, 1.0);
 }

shaders/model_frag.spv

@@ -1,7 +1,11 @@
 #version 450 core
 
 layout(location = 0) in vec3 in_position;
+layout(location = 1) in vec3 in_normal;
+
+layout(location = 0) out vec3 out_normal;
 
 void main() {
 	gl_Position = vec4(in_position.x, -in_position.y, in_position.z, 1.0);
+	out_normal = in_normal;
 }

shaders/model_vert.glsl

@@ -196,15 +196,19 @@ void initApplication(SDL_Window* window) {
 									vertexAttributeDescriptions, ARRAY_COUNT(vertexAttributeDescriptions), &vertexInputBinding, 1, &descriptorLayout);
 
 
-	VkVertexInputAttributeDescription modelAttributeDescriptions[1] = {};
+	VkVertexInputAttributeDescription modelAttributeDescriptions[2] = {};
 	modelAttributeDescriptions[0].binding = 0;
 	modelAttributeDescriptions[0].location = 0;
 	modelAttributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT;
 	modelAttributeDescriptions[0].offset = 0;
+	modelAttributeDescriptions[1].binding = 0;
+	modelAttributeDescriptions[1].location = 1;
+	modelAttributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
+	modelAttributeDescriptions[1].offset = 0;
 	VkVertexInputBindingDescription modelInputBinding = {};
 	modelInputBinding.binding = 0;
 	modelInputBinding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
-	modelInputBinding.stride = sizeof(float) * 3;
+	modelInputBinding.stride = sizeof(float) * 6;
 	modelPipeline = createPipeline(context, "../shaders/model_vert.spv", "../shaders/model_frag.spv", renderPass, swapchain.width, swapchain.height,
 									modelAttributeDescriptions, ARRAY_COUNT(modelAttributeDescriptions), &modelInputBinding, 0, 0);
 

shaders/model_vert.spv

@@ -3,6 +3,19 @@
 #define CGLTF_IMPLEMENTATION
 #include <cgltf/cgltf.h>
 
+// Stride in bytes. Element size in bytes
+void fillBuffer(uint32_t inputStride, void* inputData, uint32_t outputStride, void* outputData, uint32_t numElements, uint32_t elementSize) {
+    uint8_t* output = (uint8_t*)outputData;
+    uint8_t* input = (uint8_t*)inputData;
+    for(uint32_t i = 0; i < numElements; ++i) {
+        for(uint32_t b = 0; b < elementSize; ++b) {
+            output[b] = input[b];
+        }
+        output += outputStride;
+        input += inputStride;
+    }
+}
+
 Model createModel(VulkanContext* context, const char* filename) {
     Model result = {};
     cgltf_options options = {};
@@ -15,7 +28,6 @@ Model createModel(VulkanContext* context, const char* filename) {
             assert(data->meshes[0].primitives_count == 1);
             assert(data->meshes[0].primitives[0].attributes_count > 0);
             assert(data->meshes[0].primitives[0].attributes[0].type == cgltf_attribute_type_position);
-            assert(data->meshes[0].primitives[0].attributes[0].data->stride == sizeof(float)*3);
             assert(data->meshes[0].primitives[0].indices->component_type == cgltf_component_type_r_16u);
             assert(data->meshes[0].primitives[0].indices->stride == sizeof(uint16_t));
 
@@ -30,12 +42,28 @@ Model createModel(VulkanContext* context, const char* filename) {
 
 
             // Vertices
-            bufferBase = (uint8_t*)data->meshes[0].primitives[0].attributes[0].data->buffer_view->buffer->data;
-            uint64_t vertexDataSize = data->meshes[0].primitives[0].attributes[0].data->buffer_view->size;
-            void* vertexData = bufferBase + data->meshes[0].primitives[0].attributes[0].data->buffer_view->offset;
-
+            uint64_t numVertices = data->meshes[0].primitives[0].attributes->data->count;
+            uint64_t vertexDataSize = sizeof(float) * 6 * numVertices;
+            uint8_t* vertexData = new uint8_t[vertexDataSize];
+            for(uint64_t i = 0; i < data->meshes[0].primitives[0].attributes_count; ++i) {
+                cgltf_attribute* attribute = data->meshes[0].primitives[0].attributes + i;
+                if(attribute->type == cgltf_attribute_type_position) {
+                    assert(attribute->data->stride == sizeof(float)*3);
+                    bufferBase = (uint8_t*)attribute->data->buffer_view->buffer->data;
+                    uint64_t positionDataSize = attribute->data->buffer_view->size;
+                    void* positionData = bufferBase + attribute->data->buffer_view->offset;
+                    fillBuffer(sizeof(float)*3, positionData, sizeof(float) * 6, vertexData, numVertices, sizeof(float)*3);
+                } else  if(attribute->type == cgltf_attribute_type_normal) {
+                    assert(attribute->data->stride == sizeof(float)*3);
+                    bufferBase = (uint8_t*)attribute->data->buffer_view->buffer->data;
+                    uint64_t normalDataSize = attribute->data->buffer_view->size;
+                    void* normalData = bufferBase + attribute->data->buffer_view->offset;
+                    fillBuffer(sizeof(float)*3, normalData, sizeof(float) * 6, vertexData+(sizeof(float)*3), numVertices, sizeof(float)*3);
+                }
+            }
             createBuffer(context, &result.vertexBuffer, vertexDataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
             uploadDataToBuffer(context, &result.vertexBuffer, vertexData, vertexDataSize);
+            delete[] vertexData;
         }
         cgltf_free(data);
     }