fix whitespaceHEADmain

20 files changed, 179 insertions, 179 deletions

diff --git a/src/draw/opengl.c b/src/draw/opengl.c
index 76c44f9..ac5f250 100644
--- a/src/draw/opengl.c
+++ b/src/draw/opengl.c
@@ -21,7 +21,7 @@ struct gl_shader {
 
 struct gl_texture {
     GLuint txo;
-    GLenum type;  
+    GLenum type;
 };
 
 static struct {
@@ -40,63 +40,63 @@ static struct {
 
 static void opengl_error(GLenum err, const char *file, int line)
 {
-	switch (err) {
-		case GL_INVALID_ENUM:                  fprintf(stderr, "opengl error: INVALID_ENUM %s:%d\n", file, line); break;
-		case GL_INVALID_VALUE:                 fprintf(stderr, "opengl error: INVALID_VALUE %s:%d\n", file, line); break;
-		case GL_INVALID_OPERATION:             fprintf(stderr, "opengl error: INVALID_OPERATION %s:%d\n", file, line); break;
-		case GL_STACK_OVERFLOW:                fprintf(stderr, "opengl error: STACK_OVERFLOW %s:%d\n", file, line); break;
-		case GL_STACK_UNDERFLOW:               fprintf(stderr, "opengl error: STACK_UNDERFLOW %s:%d\n", file, line); break;
-		case GL_OUT_OF_MEMORY:                 fprintf(stderr, "opengl error: OUT_OF_MEMORY %s:%d\n", file, line); break;
-		case GL_INVALID_FRAMEBUFFER_OPERATION: fprintf(stderr, "opengl error: INVALID_FRAMEBUFFER_OPERATION %s:%d\n", file, line); break;
-		default: break;
-	}
+    switch (err) {
+        case GL_INVALID_ENUM:                  fprintf(stderr, "opengl error: INVALID_ENUM %s:%d\n", file, line); break;
+        case GL_INVALID_VALUE:                 fprintf(stderr, "opengl error: INVALID_VALUE %s:%d\n", file, line); break;
+        case GL_INVALID_OPERATION:             fprintf(stderr, "opengl error: INVALID_OPERATION %s:%d\n", file, line); break;
+        case GL_STACK_OVERFLOW:                fprintf(stderr, "opengl error: STACK_OVERFLOW %s:%d\n", file, line); break;
+        case GL_STACK_UNDERFLOW:               fprintf(stderr, "opengl error: STACK_UNDERFLOW %s:%d\n", file, line); break;
+        case GL_OUT_OF_MEMORY:                 fprintf(stderr, "opengl error: OUT_OF_MEMORY %s:%d\n", file, line); break;
+        case GL_INVALID_FRAMEBUFFER_OPERATION: fprintf(stderr, "opengl error: INVALID_FRAMEBUFFER_OPERATION %s:%d\n", file, line); break;
+        default: break;
+    }
 }
 
 #define GL_DEBUG opengl_debug(__FILE__, __LINE__);
 
 __attribute__((unused)) static void opengl_debug(const char *file, int line)
 {
-	GLenum err = glGetError();
-	if (err != GL_NO_ERROR)
-		opengl_error(err, file, line);
+    GLenum err = glGetError();
+    if (err != GL_NO_ERROR)
+        opengl_error(err, file, line);
 }
 
 static const char *debug_source_to_string(GLenum source)
 {
-	switch (source) {
-		case GL_DEBUG_SOURCE_API: return "API";
-		case GL_DEBUG_SOURCE_WINDOW_SYSTEM: return "WINDOW SYSTEM";
+    switch (source) {
+        case GL_DEBUG_SOURCE_API: return "API";
+        case GL_DEBUG_SOURCE_WINDOW_SYSTEM: return "WINDOW SYSTEM";
         case GL_DEBUG_SOURCE_SHADER_COMPILER: return "SHADER COMPILER";
-		case GL_DEBUG_SOURCE_THIRD_PARTY: return "THIRD PARTY";
-		case GL_DEBUG_SOURCE_APPLICATION: return "APPLICATION";
+        case GL_DEBUG_SOURCE_THIRD_PARTY: return "THIRD PARTY";
+        case GL_DEBUG_SOURCE_APPLICATION: return "APPLICATION";
         case GL_DEBUG_SOURCE_OTHER: return "OTHER";
-		default: return "UNKNOWN";
-	}    
+        default: return "UNKNOWN";
+    }
 }
 
 static const char *debug_type_to_string(GLenum type)
 {
-	switch (type) {
-		case GL_DEBUG_TYPE_ERROR: return "ERROR";
-		case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "DEPRECATED BEHAVIOR";
-		case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "UDEFINED BEHAVIOR";
-		case GL_DEBUG_TYPE_PORTABILITY: return "PORTABILITY";
-		case GL_DEBUG_TYPE_PERFORMANCE: return "PERFORMANCE";
-		case GL_DEBUG_TYPE_OTHER: return "OTHER";
+    switch (type) {
+        case GL_DEBUG_TYPE_ERROR: return "ERROR";
+        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "DEPRECATED BEHAVIOR";
+        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "UDEFINED BEHAVIOR";
+        case GL_DEBUG_TYPE_PORTABILITY: return "PORTABILITY";
+        case GL_DEBUG_TYPE_PERFORMANCE: return "PERFORMANCE";
+        case GL_DEBUG_TYPE_OTHER: return "OTHER";
         case GL_DEBUG_TYPE_MARKER: return "MARKER";
-		default: return "UNKNOWN";
-	}    
+        default: return "UNKNOWN";
+    }
 }
 
 static const char *debug_severity_to_string(GLenum severity)
 {
-	switch (severity) {
-		case GL_DEBUG_SEVERITY_HIGH: return "HIGH";
-		case GL_DEBUG_SEVERITY_MEDIUM: return "MEDIUM";
-		case GL_DEBUG_SEVERITY_LOW: return "LOW";
-		case GL_DEBUG_SEVERITY_NOTIFICATION: return "NOTIFICATION";
-		default: return "UNKNOWN";
-	}    
+    switch (severity) {
+        case GL_DEBUG_SEVERITY_HIGH: return "HIGH";
+        case GL_DEBUG_SEVERITY_MEDIUM: return "MEDIUM";
+        case GL_DEBUG_SEVERITY_LOW: return "LOW";
+        case GL_DEBUG_SEVERITY_NOTIFICATION: return "NOTIFICATION";
+        default: return "UNKNOWN";
+    }
 }
 
 static void APIENTRY debug_message_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *msg, const void *data)
@@ -104,8 +104,8 @@ static void APIENTRY debug_message_callback(GLenum source, GLenum type, GLuint i
     (void) data, (void) length;
     if (severity == GL_DEBUG_SEVERITY_NOTIFICATION) return;
     fprintf(stderr, "%d: %s of %s severity, raised from %s: %s\n",
-	    id, debug_type_to_string(type), debug_severity_to_string(severity),
-	    debug_source_to_string(source), msg);
+        id, debug_type_to_string(type), debug_severity_to_string(severity),
+        debug_source_to_string(source), msg);
 }
 
 static void init_egl(unsigned int size[2])
@@ -148,28 +148,28 @@ static void init_target(unsigned int size[2])
 {
     state.target.size[0] = size[0];
     state.target.size[1] = size[1];
-	state.target.buffer = malloc(size[0] * size[1] * 4);
+    state.target.buffer = malloc(size[0] * size[1] * 4);
 
-	glGenRenderbuffers(1, &state.target.rbo);
-	glBindRenderbuffer(GL_RENDERBUFFER, state.target.rbo);
-	glRenderbufferStorageMultisample(GL_RENDERBUFFER, 8, GL_DEPTH24_STENCIL8, size[0], size[1]);
+    glGenRenderbuffers(1, &state.target.rbo);
+    glBindRenderbuffer(GL_RENDERBUFFER, state.target.rbo);
+    glRenderbufferStorageMultisample(GL_RENDERBUFFER, 8, GL_DEPTH24_STENCIL8, size[0], size[1]);
 
-	glGenTextures(2, state.target.txos);
+    glGenTextures(2, state.target.txos);
 
-	glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, state.target.txos[0]);
-	glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 8, GL_RGBA, size[0], size[1], GL_TRUE);
+    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, state.target.txos[0]);
+    glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 8, GL_RGBA, size[0], size[1], GL_TRUE);
 
-	glBindTexture(GL_TEXTURE_2D, state.target.txos[1]);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size[0], size[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    glBindTexture(GL_TEXTURE_2D, state.target.txos[1]);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size[0], size[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
-	glGenFramebuffers(2, state.target.fbos);
+    glGenFramebuffers(2, state.target.fbos);
 
-	glBindFramebuffer(GL_FRAMEBUFFER, state.target.fbos[0]);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, state.target.txos[0], 0);
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, state.target.rbo);
+    glBindFramebuffer(GL_FRAMEBUFFER, state.target.fbos[0]);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, state.target.txos[0], 0);
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, state.target.rbo);
 
-	glBindFramebuffer(GL_FRAMEBUFFER, state.target.fbos[1]);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, state.target.txos[1], 0);
+    glBindFramebuffer(GL_FRAMEBUFFER, state.target.fbos[1]);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, state.target.txos[1], 0);
 }
 
 static void init_shaders()
@@ -201,35 +201,35 @@ static void init_shaders()
     GLuint src_ids[4];
 
     for (size_t i = 0; i < 4; i++) {
-		src_ids[i] = glCreateShader(src[i].type);
-		GLint size = src[i].size;
-		glShaderSource(src_ids[i], 1, &src[i].src, &size);
-		glCompileShader(src_ids[i]);
-
-		GLint success;
-		glGetShaderiv(src_ids[i], GL_COMPILE_STATUS, &success);
-		if (!success) {
-			char error[BUFSIZ];
-			glGetShaderInfoLog(src_ids[i], BUFSIZ, nullptr, error);
-			eprintf("failed to compile %s: %s", src[i].name, error);
-		}
+        src_ids[i] = glCreateShader(src[i].type);
+        GLint size = src[i].size;
+        glShaderSource(src_ids[i], 1, &src[i].src, &size);
+        glCompileShader(src_ids[i]);
+
+        GLint success;
+        glGetShaderiv(src_ids[i], GL_COMPILE_STATUS, &success);
+        if (!success) {
+            char error[BUFSIZ];
+            glGetShaderInfoLog(src_ids[i], BUFSIZ, nullptr, error);
+            eprintf("failed to compile %s: %s", src[i].name, error);
+        }
     }
 
     const char *names[3] = { "color", "texture", "cubemap" };
     for (size_t i = 0; i < 3; i++) {
         struct gl_shader *shader = &state.shaders[i];
-    	shader->program = glCreateProgram();
+        shader->program = glCreateProgram();
         glAttachShader(shader->program, src_ids[0]);
         glAttachShader(shader->program, src_ids[i+1]);
         glLinkProgram(shader->program);
 
-    	GLint success;
-    	glGetProgramiv(shader->program, GL_LINK_STATUS, &success);
-    	if (!success) {
-			char error[BUFSIZ];
-			glGetShaderInfoLog(shader->program, BUFSIZ, nullptr, error);
-			eprintf("failed to link %s shader: %s", names[i], error);
-    	}
+        GLint success;
+        glGetProgramiv(shader->program, GL_LINK_STATUS, &success);
+        if (!success) {
+            char error[BUFSIZ];
+            glGetShaderInfoLog(shader->program, BUFSIZ, nullptr, error);
+            eprintf("failed to link %s shader: %s", names[i], error);
+        }
 
         shader->loc_color = glGetUniformLocation(shader->program, "color");
         shader->loc_model = glGetUniformLocation(shader->program, "model");
@@ -245,8 +245,8 @@ static void opengl_init(unsigned int size[2])
     init_egl(size);
 
     if (true) {
-    	glEnable(GL_DEBUG_OUTPUT);
-    	glDebugMessageCallback(debug_message_callback, nullptr);
+        glEnable(GL_DEBUG_OUTPUT);
+        glDebugMessageCallback(debug_message_callback, nullptr);
     }
 
     init_target(size);
@@ -263,7 +263,7 @@ static bool opengl_create_mesh(size_t n_verts, const struct draw_vertex verts[n_
     glBindVertexArray(mesh.vao);
     glBindBuffer(GL_ARRAY_BUFFER, mesh.vbo);
 
-	glBufferData(GL_ARRAY_BUFFER, mesh.count * sizeof(struct draw_vertex), verts, GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, mesh.count * sizeof(struct draw_vertex), verts, GL_STATIC_DRAW);
 
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(struct draw_vertex), (GLvoid *) offsetof(struct draw_vertex, pos));
     glEnableVertexAttribArray(0);
@@ -273,7 +273,7 @@ static bool opengl_create_mesh(size_t n_verts, const struct draw_vertex verts[n_
 
     *id = state.meshes.len;
     arraybuf_insert(&state.meshes, mesh);
-    return true;    
+    return true;
 }
 
 static void image_flip(rgba_data dst, rgba_data src, unsigned int size[2])
@@ -291,10 +291,10 @@ static bool opengl_create_texture(enum texture_type type, unsigned int size[2],
         case TEXTURE_2D: tex.type = GL_TEXTURE_2D; break;
         case TEXTURE_CUBEMAP: tex.type = GL_TEXTURE_CUBE_MAP; break;
     }
-	glGenTextures(1, &tex.txo);
-	glBindTexture(tex.type, tex.txo);
+    glGenTextures(1, &tex.txo);
+    glBindTexture(tex.type, tex.txo);
 
-	rgba_data flipped = malloc(size[0]*size[1]*4);
+    rgba_data flipped = malloc(size[0]*size[1]*4);
 
     size_t n_faces = tex.type == GL_TEXTURE_CUBE_MAP ? 6 : 1;
     for (size_t i = 0; i < n_faces; i++) {
@@ -302,18 +302,18 @@ static bool opengl_create_texture(enum texture_type type, unsigned int size[2],
             ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + i
             : GL_TEXTURE_2D;
         image_flip(flipped, faces[i], size);
-    	glTexImage2D(target, 0, GL_RGBA, size[0], size[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, flipped);
-	}
+        glTexImage2D(target, 0, GL_RGBA, size[0], size[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, flipped);
+    }
 
-	free(flipped);
+    free(flipped);
 
     GLint filter = bilinear ? GL_LINEAR : GL_NEAREST;
     glTexParameteri(tex.type, GL_TEXTURE_MIN_FILTER, filter);
     glTexParameteri(tex.type, GL_TEXTURE_MAG_FILTER, filter);
 
     GLint wrap = tex.type == GL_TEXTURE_CUBE_MAP ? GL_CLAMP_TO_EDGE : GL_REPEAT;
-	glTexParameteri(tex.type, GL_TEXTURE_WRAP_S, wrap);
-	glTexParameteri(tex.type, GL_TEXTURE_WRAP_T, wrap);
+    glTexParameteri(tex.type, GL_TEXTURE_WRAP_S, wrap);
+    glTexParameteri(tex.type, GL_TEXTURE_WRAP_T, wrap);
     if (tex.type == GL_TEXTURE_CUBE_MAP)
         glTexParameteri(tex.type, GL_TEXTURE_WRAP_R, wrap);
 
@@ -325,7 +325,7 @@ static bool opengl_create_texture(enum texture_type type, unsigned int size[2],
 static void opengl_draw_frame(struct draw_frame *frame, rgba_data out_data)
 {
     glEnable(GL_DEPTH_TEST);
-	glEnable(GL_MULTISAMPLE);
+    glEnable(GL_MULTISAMPLE);
 
     glBindFramebuffer(GL_FRAMEBUFFER, state.target.fbos[0]);
     glViewport(0, 0, state.target.size[0], state.target.size[1]);
@@ -345,7 +345,7 @@ static void opengl_draw_frame(struct draw_frame *frame, rgba_data out_data)
     }
 
     /*
-	glEnable(GL_CULL_FACE);
+    glEnable(GL_CULL_FACE);
     glCullFace(GL_BACK);
     glFrontFace(GL_CCW);
     */
@@ -362,7 +362,7 @@ static void opengl_draw_frame(struct draw_frame *frame, rgba_data out_data)
         } else {
             texture = nullptr;
             shader = &state.shaders[0];
-        }     
+        }
 
         glUseProgram(shader->program);
         glUniform3fv(shader->loc_color, 1, call->surface.color);
@@ -374,20 +374,20 @@ static void opengl_draw_frame(struct draw_frame *frame, rgba_data out_data)
         }
 
         glBindVertexArray(mesh->vao);
-    	glDrawArrays(GL_TRIANGLES, 0, mesh->count);
+        glDrawArrays(GL_TRIANGLES, 0, mesh->count);
     }
 
-	glBindFramebuffer(GL_READ_FRAMEBUFFER, state.target.fbos[0]);
-	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, state.target.fbos[1]);
-	glBlitFramebuffer(
-	    0, 0, state.target.size[0], state.target.size[1],
-	    0, 0, state.target.size[0], state.target.size[1],
-	    GL_COLOR_BUFFER_BIT, GL_NEAREST);
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, state.target.fbos[0]);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, state.target.fbos[1]);
+    glBlitFramebuffer(
+        0, 0, state.target.size[0], state.target.size[1],
+        0, 0, state.target.size[0], state.target.size[1],
+        GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
-	glBindFramebuffer(GL_FRAMEBUFFER, state.target.fbos[1]);
-	glPixelStorei(GL_PACK_ALIGNMENT, 1);
-	glReadPixels(0, 0, state.target.size[0], state.target.size[1],
-	    GL_RGBA, GL_UNSIGNED_BYTE, state.target.buffer);
+    glBindFramebuffer(GL_FRAMEBUFFER, state.target.fbos[1]);
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    glReadPixels(0, 0, state.target.size[0], state.target.size[1],
+        GL_RGBA, GL_UNSIGNED_BYTE, state.target.buffer);
 
     image_flip(out_data, state.target.buffer, state.target.size);
 }
@@ -396,9 +396,9 @@ static void opengl_cleanup()
 {
     free(state.target.buffer);
 
-	glDeleteRenderbuffers(1, &state.target.rbo);
-	glDeleteTextures(2, state.target.txos);
-	glDeleteFramebuffers(2, state.target.fbos);
+    glDeleteRenderbuffers(1, &state.target.rbo);
+    glDeleteTextures(2, state.target.txos);
+    glDeleteFramebuffers(2, state.target.fbos);
 
     for (size_t i = 0; i < 3; i++)
         glDeleteProgram(state.shaders[i].program);
diff --git a/src/expr.c b/src/expr.c
index a808232..e299529 100644
--- a/src/expr.c
+++ b/src/expr.c
@@ -34,12 +34,12 @@ double expr_eval(struct expr *expr, double time)
                 case OP_MIN:
                     for (size_t i = 0; i < n_args; i++)
                         if (i == 0 || args[i] < accum)
-                            accum = args[i]; 
+                            accum = args[i];
                     return accum;
                 case OP_MAX:
                     for (size_t i = 0; i < n_args; i++)
                         if (i == 0 || args[i] > accum)
-                            accum = args[i]; 
+                            accum = args[i];
                     return accum;
                 case OP_CLAMP:
                     if (args[0] < args[1]) return args[1];
diff --git a/src/fmt/nut.c b/src/fmt/nut.c
index 886a054..f574ec7 100644
--- a/src/fmt/nut.c
+++ b/src/fmt/nut.c
@@ -38,7 +38,7 @@ static void put_f(struct nut_output *out, size_t len, const void *data)
 
 static void put_u8(struct nut_output *out, uint8_t v)
 {
-    put_f(out, sizeof v, &v);    
+    put_f(out, sizeof v, &v);
 }
 
 static void put_u32(struct nut_output *out, uint32_t v)
@@ -78,7 +78,7 @@ static size_t put_packet_header(struct nut_output *out, size_t data_len, uint64_
 static void put_packet_data(struct nut_output *out, size_t len, void *data)
 {
     put_f(out, len, data);
-    put_u32(out, crc32(len, data));    
+    put_u32(out, crc32(len, data));
 }
 
 static void put_packet(struct nut_output *out, size_t len, void *data, uint64_t startcode)
@@ -162,8 +162,8 @@ void nut_write_start(struct nut_writer *wr, FILE *f, unsigned int fps, unsigned
         put_v(&main, 0);
     put_v(&main, 256-4); // count
 
-	put_v(&main, 0); // header_count_minus1
-	put_v(&main, 0); // main_flags 
+    put_v(&main, 0); // header_count_minus1
+    put_v(&main, 0); // main_flags
 
     put_packet(&wr->out, main.len, main.ptr,
         0x7A561F5F04ADULL + (((uint64_t)('N'<<8) + 'M')<<48));
@@ -210,7 +210,7 @@ void nut_write_frame(struct nut_writer *wr, void *data)
     put_f(&wr->out, frame.len, frame.ptr);
     put_u32(&wr->out, crc32(frame.len, frame.ptr));
 
-    put_f(&wr->out, wr->frame_size, data);    
+    put_f(&wr->out, wr->frame_size, data);
 }
 
 void nut_write_end(struct nut_writer *wr)
diff --git a/src/fmt/nut.h b/src/fmt/nut.h
index 383eaad..fd6b96d 100644
--- a/src/fmt/nut.h
+++ b/src/fmt/nut.h
@@ -32,7 +32,7 @@ struct nut_syncp_off
 
 struct nut_writer
 {
-    struct nut_output out;  
+    struct nut_output out;
     size_t frame_size;
     size_t last_syncpoint;
     size_t n_frame;
diff --git a/src/lex.c b/src/lex.c
index 29ddba8..e5e5040 100644
--- a/src/lex.c
+++ b/src/lex.c
@@ -106,7 +106,7 @@ static str lex_string(struct source *src, size_t start)
                     break;
                 case '\"':
                     c = '\"';
-                    break;                    
+                    break;
                 default:
                     source_error(src, loc_last(src), "unknown escape");
                     break;
diff --git a/src/main.c b/src/main.c
index c81f1d6..f775b23 100644
--- a/src/main.c
+++ b/src/main.c
@@ -115,10 +115,10 @@ static void run(struct registry *reg, struct params *params)
     fclose(outfile);
     draw->cleanup();
     scene_free(&scene);
-    source_free(&src);    
+    source_free(&src);
 }
 
-static const char *help_text = 
+static const char *help_text =
 "usage: %s [options] <scenefile>\n"
 "    -o | --out <outfile>    File to write resulting .nut video to. A default may be provided by the\n"
 "                            scene file. Otherwise, video is written to stdout unless stdout is a\n"
@@ -135,7 +135,7 @@ static const char *help_text =
 "                            (default: 1.0). Video will be rendered ahead of time by this amount.\n"
 "    -v | --verbose          Print debugging information.\n"
 "    -h | --help             Display this help text.\n";
- 
+
 int main(int argc, char **argv)
 {
     struct registry reg = {};
@@ -229,7 +229,7 @@ int main(int argc, char **argv)
         eprintf("too many arguments (see -h)\n");
     if (remain_args < 1)
         eprintf("missing scene file (see -h)\n");
-    
+
     params.infile = str_intro(argv[optind]);
 
     run(&reg, &params);
diff --git a/src/parse.c b/src/parse.c
index b6af245..57cab52 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -15,7 +15,7 @@ static struct var *get_var(struct token *tok, struct source *src, struct registr
     struct var *var = nullptr;
     map_find(&reg->vars, tok->var, &var);
     if (!var)
-        source_error(src, tok->loc, "no such variable: $%.*s", PSTR(tok->var));    
+        source_error(src, tok->loc, "no such variable: $%.*s", PSTR(tok->var));
     return var;
 }
 
@@ -102,7 +102,7 @@ double parse_eval_expr_range(struct token *tok, struct source *src, struct regis
         source_error(src, tok->loc, "%f is smaller than %f", num, low);
     if (num > high)
         source_error(src, tok->loc, "%f is larger than %f", num, high);
-    return num;    
+    return num;
 }
 
 unsigned int parse_eval_expr_uint(struct token *tok, struct source *src, struct registry *reg)
@@ -299,7 +299,7 @@ static void parse_pos(struct token *tok, struct pos *pos, struct source *src, st
     switch (tok->op.type) {
         case OP_POS:
             if (tok->op.children.len != 3)
-                source_error(src, tok->loc, "'pos' expects exactly three arguments");          
+                source_error(src, tok->loc, "'pos' expects exactly three arguments");
             pos->type = POS_ABSOLUTE;
             for (size_t i = 0; i < tok->op.children.len; i++)
                 parse_expr(&tok->op.children.ptr[i], &pos->absolute[i], src, reg, true);
@@ -336,12 +336,12 @@ static void parse_surface(size_t n_attrs, struct token attrs[n_attrs], struct su
                 break;
             case OP_COLOR:
                 if (tok->op.children.len != 1)
-                    source_error(src, tok->loc, "'color' expects exactly one argument");   
+                    source_error(src, tok->loc, "'color' expects exactly one argument");
                 expr_free(&surf->color);
                 parse_expr(&tok->op.children.ptr[0], &surf->color, src, reg, true);
                 break;
             default:
-                source_error(src, tok->op.name_loc, "not a valid surface attribute");            
+                source_error(src, tok->op.name_loc, "not a valid surface attribute");
         }
     }
 }
diff --git a/src/print.c b/src/print.c
index 92c2a3b..68f87a1 100644
--- a/src/print.c
+++ b/src/print.c
@@ -76,7 +76,7 @@ void print_seq(FILE *f, size_t n_inst, struct seq_inst inst[n_inst], enum scene_
                     fprintf(f, "%u: ", inst[i].rep.times);
                 print_seq(f, inst[i].rep.children.len, inst[i].rep.children.ptr, stage);
                 fprintf(f, ")");
-                break;          
+                break;
         }
     }
 }
@@ -150,7 +150,7 @@ void print_node(FILE *f, struct node *node, enum scene_stage stage, unsigned int
                     fprintf(f, "(");
                     for (size_t i = 0; i < 3; i++) {
                         if (i) fprintf(f, " ");
-                        print_expr(f, &node->camera.target.absolute[i]);                       
+                        print_expr(f, &node->camera.target.absolute[i]);
                     }
                     fprintf(f, ") ");
                     break;
diff --git a/src/print.h b/src/print.h
index 06d6fde..50a22d3 100644
--- a/src/print.h
+++ b/src/print.h
@@ -9,7 +9,7 @@ enum scene_stage
 {
     SCENE_PARSED,
     SCENE_BOUND,
-    SCENE_LOADED,  
+    SCENE_LOADED,
 };
 
 void print_token(FILE *f, struct token *tok, unsigned int indent);
diff --git a/src/render.c b/src/render.c
index fe0c200..0db8e19 100644
--- a/src/render.c
+++ b/src/render.c
@@ -40,18 +40,18 @@ static void render_node(struct node *node, mat4x4 model, draw_calls *calls, doub
                         vals[op][i] = expr_eval(&node->transform.op[op][i], time);
 
             mat4x4 trans;
-        	mat4x4_identity(trans);
-        	mat4x4_translate(trans, vals[TR_TRANSLATE][0], vals[TR_TRANSLATE][1], vals[TR_TRANSLATE][2]);
-        	mat4x4_scale_aniso(trans, trans, vals[TR_SCALE][0], vals[TR_SCALE][1], vals[TR_SCALE][2]);
-        	mat4x4_rotate_X(trans, trans, deg2rad(vals[TR_ROTATE][0]));
-        	mat4x4_rotate_Y(trans, trans, deg2rad(vals[TR_ROTATE][1]));
-        	mat4x4_rotate_Z(trans, trans, deg2rad(vals[TR_ROTATE][2]));
-
-        	mat4x4 new_model;
-        	mat4x4_mul(new_model, model, trans);
-
-        	for (size_t i = 0; i < node->transform.children.len; i++)
-        	    render_node(&node->transform.children.ptr[i], new_model, calls, time);
+            mat4x4_identity(trans);
+            mat4x4_translate(trans, vals[TR_TRANSLATE][0], vals[TR_TRANSLATE][1], vals[TR_TRANSLATE][2]);
+            mat4x4_scale_aniso(trans, trans, vals[TR_SCALE][0], vals[TR_SCALE][1], vals[TR_SCALE][2]);
+            mat4x4_rotate_X(trans, trans, deg2rad(vals[TR_ROTATE][0]));
+            mat4x4_rotate_Y(trans, trans, deg2rad(vals[TR_ROTATE][1]));
+            mat4x4_rotate_Z(trans, trans, deg2rad(vals[TR_ROTATE][2]));
+
+            mat4x4 new_model;
+            mat4x4_mul(new_model, model, trans);
+
+            for (size_t i = 0; i < node->transform.children.len; i++)
+                render_node(&node->transform.children.ptr[i], new_model, calls, time);
             break;
         }
         case NODE_CAMERA: {
@@ -143,7 +143,7 @@ static void render_seq(size_t n_inst, struct seq_inst inst[n_inst], struct scene
                         struct timespec ts_now;
                         clock_gettime(CLOCK_REALTIME, &ts_now);
                         double e_time = (double)
-                            (ts_now.tv_nsec - state->start_ts.tv_nsec) / 1000000000.0 + 
+                            (ts_now.tv_nsec - state->start_ts.tv_nsec) / 1000000000.0 +
                             (ts_now.tv_sec - state->start_ts.tv_sec);
                         double ahead = time - e_time - scene->live.data;
                         if (ahead > 0.0) {
@@ -154,7 +154,7 @@ static void render_seq(size_t n_inst, struct seq_inst inst[n_inst], struct scene
                             nanosleep(&ts_sleep, nullptr);
                         }
                     }
-                
+
                     struct draw_frame frame;
                     render_frame(&frame, scene, &state->calls_buf, time);
                     draw->draw_frame(&frame, state->render_buffer);
diff --git a/src/resource.h b/src/resource.h
index 1e6a354..12f4336 100644
--- a/src/resource.h
+++ b/src/resource.h
@@ -8,7 +8,7 @@
 struct texture_source
 {
     enum texture_type type;
-    struct loc_str path;   
+    struct loc_str path;
 };
 
 struct texture
diff --git a/src/scene.c b/src/scene.c
index 54677e9..7016cc8 100644
--- a/src/scene.c
+++ b/src/scene.c
@@ -16,7 +16,7 @@ void proj_default(struct projection *proj, enum projection_type type)
         case PROJ_ORTHO: {
             float planes[6] = { -1.f, +1.f, -1.f, 1.f, 1.f, -1.f };
             memcpy(proj->ortho.planes, planes, sizeof planes);
-            break;    
+            break;
         }
     }
 }
diff --git a/src/scene.h b/src/scene.h
index dfcf635..2a49581 100644
--- a/src/scene.h
+++ b/src/scene.h
@@ -51,7 +51,7 @@ struct transform
 {
     bool has_op[TRANSFORM_OPS_N][3];
     struct expr op[TRANSFORM_OPS_N][3];
-    array(struct node) children;  
+    array(struct node) children;
 };
 
 struct surface
@@ -68,7 +68,7 @@ struct object
 
 enum node_type
 {
-    NODE_TRANSFORM,  
+    NODE_TRANSFORM,
     NODE_OBJECT,
     NODE_CAMERA,
     NODE_BONE,
@@ -103,7 +103,7 @@ struct seq_inst
         struct camera *pov;
         struct {
             unsigned int times;
-            array(struct seq_inst) children;      
+            array(struct seq_inst) children;
         } rep;
         double time;
     };
diff --git a/src/shader/fragment_color.glsl b/src/shader/fragment_color.glsl
index 6980821..ffefe67 100644
--- a/src/shader/fragment_color.glsl
+++ b/src/shader/fragment_color.glsl
@@ -9,5 +9,5 @@ uniform vec3 color;
 
 void main()
 {
-	out_color = vec4(color, 1.0);
+    out_color = vec4(color, 1.0);
 }
diff --git a/src/shader/fragment_cubemap.glsl b/src/shader/fragment_cubemap.glsl
index fad97b4..3fa3157 100644
--- a/src/shader/fragment_cubemap.glsl
+++ b/src/shader/fragment_cubemap.glsl
@@ -10,7 +10,7 @@ uniform samplerCube tex;
 
 void main()
 {
-	out_color = texture(tex, normalize(frag_pos)) * vec4(color, 1.0);
-	if (out_color.a == 0.0)
-		discard;
+    out_color = texture(tex, normalize(frag_pos)) * vec4(color, 1.0);
+    if (out_color.a == 0.0)
+        discard;
 }
diff --git a/src/shader/fragment_texture.glsl b/src/shader/fragment_texture.glsl
index 43c40bc..35797b6 100644
--- a/src/shader/fragment_texture.glsl
+++ b/src/shader/fragment_texture.glsl
@@ -10,7 +10,7 @@ uniform sampler2D tex;
 
 void main()
 {
-	out_color = texture(tex, frag_tex) * vec4(color, 1.0);
-	if (out_color.a == 0.0)
-		discard;
+    out_color = texture(tex, frag_tex) * vec4(color, 1.0);
+    if (out_color.a == 0.0)
+        discard;
 }
diff --git a/src/shader/vertex.glsl b/src/shader/vertex.glsl
index 9389715..341e160 100644
--- a/src/shader/vertex.glsl
+++ b/src/shader/vertex.glsl
@@ -11,7 +11,7 @@ uniform mat4 view_proj;
 
 void main()
 {
-	gl_Position = view_proj * model * vec4(vert_pos, 1.0);
-	frag_pos = vert_pos;
-	frag_tex = vert_tex;
+    gl_Position = view_proj * model * vec4(vert_pos, 1.0);
+    frag_pos = vert_pos;
+    frag_tex = vert_tex;
 }
diff --git a/src/source.c b/src/source.c
index cc544e4..e73c4b2 100644
--- a/src/source.c
+++ b/src/source.c
@@ -31,7 +31,7 @@ void source_error(struct source *src, struct range loc, const char *fmt, ...)
     va_start(args, fmt);
     vfprintf(stderr, fmt, args);
     va_end(args);
-    
+
     fprintf(stderr, "\n");
 
     while (line.ptr && line.ptr < p_end) {
diff --git a/src/source.h b/src/source.h
index c88c2b4..3f95d2b 100644
--- a/src/source.h
+++ b/src/source.h
@@ -7,7 +7,7 @@
 
 struct range
 {
-    size_t start, end;  
+    size_t start, end;
 };
 
 struct loc_str
diff --git a/src/util/str.c b/src/util/str.c
index 09bf822..97945bc 100644
--- a/src/util/str.c
+++ b/src/util/str.c
@@ -2,55 +2,55 @@
 
 static bool match_char(char c, str tokens)
 {
-	for (size_t t = 0; t < tokens.len; t++)
-		if (c == tokens.ptr[t])
-			return true;
+    for (size_t t = 0; t < tokens.len; t++)
+        if (c == tokens.ptr[t])
+            return true;
 
-	return false;
+    return false;
 }
 
 size_t str_find(str s, str tokens)
 {
-	for (size_t i = 0; i < s.len; i++)
-		if (match_char(s.ptr[i], tokens))
-			return i;
+    for (size_t i = 0; i < s.len; i++)
+        if (match_char(s.ptr[i], tokens))
+            return i;
 
-	return s.len;
+    return s.len;
 }
 
 str str_walk(str *s, str sep)
 {
-	if (s->len == 0)
-		return (str) {};
+    if (s->len == 0)
+        return (str) {};
 
-	size_t x = str_find(*s, sep);
-	size_t o = x + (x < s->len);
+    size_t x = str_find(*s, sep);
+    size_t o = x + (x < s->len);
 
-	*s = str_advance(*s, o);
+    *s = str_advance(*s, o);
 
     return (str) { x, s->ptr - o };
 }
 
 str str_eat(str s, str tokens)
 {
-	while (s.len > 0 && match_char(s.ptr[0], tokens))
-		s = str_advance(s, 1);
-	return s;
+    while (s.len > 0 && match_char(s.ptr[0], tokens))
+        s = str_advance(s, 1);
+    return s;
 }
 
 str str_advance(str s, size_t x)
 {
-	s.len -= x;
-	s.ptr += x;
-	return s;
+    s.len -= x;
+    s.ptr += x;
+    return s;
 }
 
 bool str_start(str s, str start)
 {
-	if (s.len < start.len)
-		return false;
-	s.len = start.len;
-	return array_eq(s, start);
+    if (s.len < start.len)
+        return false;
+    s.len = start.len;
+    return array_eq(s, start);
 }
 
 str str_intro(char *s)
@@ -68,7 +68,7 @@ str str_intro(char *s)
         return false; \
     *x = v; \
     return true;
-    
+
 
 bool str_parse_int(str s, long *x)
 {