summaryrefslogtreecommitdiff
path: root/saw.c
diff options
context:
space:
mode:
authorMitya Selivanov <automainint@guattari.tech>2024-07-14 21:12:37 +0200
committerMitya Selivanov <automainint@guattari.tech>2024-07-14 21:12:37 +0200
commit30740ca4131d1f574718262451b4410207dc8d4e (patch)
treefc88b16a216079397ad85b9c6b1a1c1c5712a814 /saw.c
parent5e3c99bb1cf1d03ea006300121265571f5008fd2 (diff)
downloadsaw-30740ca4131d1f574718262451b4410207dc8d4e.zip
Reworking the build system
Diffstat (limited to 'saw.c')
-rw-r--r--saw.c4679
1 files changed, 4679 insertions, 0 deletions
diff --git a/saw.c b/saw.c
new file mode 100644
index 0000000..0abda6c
--- /dev/null
+++ b/saw.c
@@ -0,0 +1,4679 @@
+#if 0 /*
+#/ ================================================================
+#/
+#/ saw.c
+#/
+#/ Music sequencer and audio editor.
+#/
+#/ (C) 2024 Mitya Selivanov <guattari.tech>, MIT License
+#/
+#/ ----------------------------------------------------------------
+#/
+#/ To-Do list
+#/
+#/ - Code
+#/ - Self-compiling single-source code
+#/ - Logging routines
+#/ - Tools
+#/ - Transactional undo and redo
+#/ - Rational bezier curves
+#/ - Biquad filter
+#/ - Fourier transform
+#/ - Parallel computation
+#/ - Module code compilation
+#/ - Sound
+#/ - Apply volume during sound generation
+#/ - Implement proper frequency shift
+#/ - Unify similar logic for Oscillators and Samplers
+#/ - Internal sample rate for time values
+#/ (28224000, divisible by 192000 and 44100)
+#/ - Dynamic buffer size
+#/ - BPM
+#/ - Volume
+#/ - Simple tonal synth
+#/ - Unisons
+#/ - Wavetables
+#/ - Kick
+#/ - Snare
+#/ - Cymbal
+#/ - EQ
+#/ - Delay
+#/ - Reverb
+#/ - Combs
+#/ - All-passes
+#/ - Compressor
+#/ - Limiter
+#/ - Sample rendering
+#/ - UI
+#/ - Panning and scaling
+#/ - Grid size changing
+#/ - Selection and copy-paste
+#/ - Help pop-up
+#/ - Spectrum view
+#/ - Effects stack
+#/ - Catalog
+#/ - Curve view
+#/ - Wave view
+#/ - Matrix view
+#/ - Graph view
+#/ - Module code view
+#/ - File browser
+#/ - Dynamic layout
+#/ - Color theme customization
+#/ - Custom font and localization
+#/ - Data
+#/ - Floating point number format without data loss
+#/ - WAV export
+#/ - Project load and store
+#/ - Automatic serialization
+#/ - Hot loading
+#/ - Plugin module
+#/ - VST3 wrapper
+#/ - LV2 wrapper
+#/ - MIDI export
+#/ - MIDI import
+#/ - Drag & drop sheet files
+#/ - Drag & drop project files
+#/
+#/ Bugs
+#/
+#/ - Sampler clicking
+#/ - Windows and macOS compilation issues
+#/
+#/ Done features
+#/
+#/ - Build
+#/ - Code setup for dependencies
+#/ - nanovg and miniaudio setup
+#/ - Faster recompilation
+#/ - WebAssembly
+#/ - Sound
+#/ - Track looping
+#/ - Buffering
+#/ - Drag & drop audio files
+#/ - Sampler
+#/ - Pythagorean tuning
+#/ - UI
+#/ - Piano roll
+#/ - Playback control
+#/ - Text rendering
+#/ - Piano roll panning
+#/ - Track composing
+#/ - Instrument settings
+#/ - Touchscreen support
+#/ - Data
+#/ - State load and store
+#/ - WAV import
+#/ - Sample loading
+#/ - Drag & drop in web
+#/
+#/ ================================================================
+#/
+#/ Self-compilation shell script
+#/
+#/ ================================================================
+SRC=${0##*./}
+gcc -DBUILDME=1 -o buildme $SRC && ./buildme $@ && rm buildme
+exit $? */
+#endif
+
+// ================================================================
+//
+// GLOBAL COMPILATION OPTIONS
+//
+// ================================================================
+
+//#define BUILDME 1
+//#define DEPENDENCIES 1
+//#define EXE 1
+//#define TESTS 1
+
+#define _GNU_SOURCE
+
+// ================================================================
+//
+// BUILD SYSTEM
+//
+// ================================================================
+
+#if BUILDME
+
+#include "kit/allocator.c"
+#include "kit/array_ref.c"
+#include "kit/dynamic_array.c"
+#include "kit/file.c"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <assert.h>
+
+#define PROJECT "saw"
+#define SOURCE "saw.c"
+
+#define REQUIRE_MATH 1
+#define REQUIRE_DL 0
+#define REQUIRE_THREADS 0
+#define REQUIRE_SOCKETS 0
+#define REQUIRE_GRAPHICS 1
+#define REQUIRE_OPENGL 1
+#define REQUIRE_VULKAN 0
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#define STATIC_RUNTIME 1
+#else
+#define STATIC_RUNTIME 0
+#endif
+
+enum {
+ LINUX,
+ WINDOWS,
+ MACOS,
+};
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#define DLM "\\"
+#define OS WINDOWS
+#elif defined(__APPLE__)
+#define DLM "/"
+#define OS MACOS
+#else // assume Linux
+#define DLM "/"
+#define OS LINUX
+#endif
+
+enum {
+ BUFFER_COUNT = 16,
+ BUFFER_SIZE = 512,
+ STRING_COUNT = 64,
+ STRING_SIZE = 512,
+};
+
+c8 _buffers[BUFFER_COUNT][BUFFER_SIZE];
+i32 _buffer_index = 0;
+
+c8 _strings[STRING_COUNT][STRING_SIZE];
+i32 _string_index;
+
+c8 *build_type = "debug";
+c8 *compiler_c = "";
+c8 *destination = "";
+c8 *extra_options = "";
+c8 *extra_link_options = "";
+c8 *postfix_obj = ".o";
+c8 *postfix_exe = "";
+c8 *flag_obj = "-c -o ";
+c8 *flag_exe = "-o ";
+c8 *flags = "";
+c8 *link_flags = "";
+
+b8 run_tests = 1;
+
+void print_help(void) {
+ printf(
+ "Build tool for C projects\n\n"
+ "Usage: ./saw.c [OPTIONS]\n\n"
+ " -h --help - Print this help\n"
+ " -t --type - Set build type: debug, release\n"
+ " -c --compiler - Set compiler to use: gcc, clang, cl, emcc\n"
+ " -d --destination - Set destination path\n"
+ " -o --options - Set additional compiler options\n"
+ " -l --link - Set additional linker options\n"
+ " -s --skiptests - Do not run tests\n\n"
+ );
+ fflush(stdout);
+}
+
+c8 lowercase_char(c8 c) {
+ if (c >= 'A' && c <= 'Z')
+ return c + ('a' - 'A');
+ return c;
+}
+
+c8 *lowercase(c8 *s) {
+ i32 i = 0;
+ for (; s[i] != '\0'; ++i) {
+ assert(i + 1 < BUFFER_SIZE);
+ _buffers[_buffer_index][i] = lowercase_char(s[i]);
+ }
+ _buffers[_buffer_index][i] = '\0';
+ c8 *result = _buffers[_buffer_index];
+ _buffer_index = (_buffer_index + 1) % BUFFER_COUNT;
+ return result;
+}
+
+void fmt_v(c8 *format, va_list args) {
+ vsprintf(_buffers[_buffer_index], format, args);
+}
+
+c8 *fmt(c8 *format, ...) {
+ va_list args;
+ va_start(args, format);
+ fmt_v(format, args);
+ c8 *result = _buffers[_buffer_index];
+ _buffer_index = (_buffer_index + 1) % BUFFER_COUNT;
+ va_end(args);
+ return result;
+}
+
+void fmt_dup_v(c8 *format, va_list args) {
+ vsprintf(_strings[_string_index], format, args);
+}
+
+c8 *fmt_dup(c8 *format, ...) {
+ va_list args;
+ va_start(args, format);
+ assert(_string_index < STRING_COUNT);
+ fmt_v(format, args);
+ c8 *result = _strings[_string_index++];
+ va_end(args);
+ return result;
+}
+
+b8 str_eq_lower(c8 *a, c8 *b) {
+ return strcmp(lowercase(a), lowercase(b)) == 0;
+}
+
+b8 str_eq(c8 *a, c8 *b) {
+ return strcmp(a, b) == 0;
+}
+
+b8 check_compiler(c8 *name) {
+ if (str_eq_lower(name, "cl") || str_eq_lower(name, "cl.exe")) {
+ i32 s = system(fmt("%s", name));
+ if (WEXITSTATUS(s) != 0)
+ return 0;
+ return 1;
+ }
+ i32 s = system(fmt("%s --version", name));
+ if (WEXITSTATUS(s) != 0)
+ return 0;
+ return 1;
+}
+
+enum {
+ MAX_LENGTH = 200,
+};
+
+i64 int_len(u32 x) {
+ i64 len = 0;
+
+ do {
+ x /= 10;
+ ++len;
+ } while (x > 0);
+
+ return len;
+}
+
+i64 print_bytes(FILE *out, FILE *in) {
+ i64 size = 0, line_len = MAX_LENGTH;
+
+ while (!feof(in)) {
+ u32 x = 0;
+
+ i64 n = fread(&x, 1, sizeof x, in);
+ if (n <= 0)
+ break;
+
+ i64 len = int_len(x);
+
+ line_len += len + 2;
+
+ if (line_len >= MAX_LENGTH) {
+ fprintf(out, "\n ");
+ line_len = 3 + len;
+ }
+
+ fprintf(out, " %u,", x);
+
+ size += n;
+ }
+
+ return size;
+}
+
+i32 main(i32 argc, c8 **argv) {
+ // Handle command line arguments
+ //
+
+ for (i32 i = 1; i < argc; ++i) {
+ if (str_eq_lower(argv[i], "?")) {
+ print_help();
+ return 0;
+ } else if (argv[i][0] == '-') {
+ if (argv[i][1] == '-') {
+ c8 *opt = argv[i] + 2;
+ if (str_eq_lower(opt, "help")) {
+ print_help();
+ return 0;
+ }
+ else if (str_eq_lower(opt, "type"))
+ build_type = argv[++i];
+ else if (str_eq_lower(opt, "compiler"))
+ compiler_c = argv[++i];
+ else if (str_eq_lower(opt, "destination"))
+ destination = argv[++i];
+ else if (str_eq_lower(opt, "options"))
+ extra_options = argv[++i];
+ else if (str_eq_lower(opt, "link"))
+ extra_link_options = argv[++i];
+ else if (str_eq_lower(opt, "skiptests"))
+ run_tests = 0;
+ else
+ printf("Unknown option ignored `%s`\n", argv[i]);
+ } else {
+ i32 consumed = 0;
+ for (i32 j = 1; argv[i][j] != '\0'; ++j) {
+ switch (argv[i][j]) {
+ case 'h':
+ case 'H':
+ print_help();
+ return 0;
+
+ case 't':
+ build_type = argv[i + (++consumed)];
+ break;
+
+ case 'c':
+ compiler_c = argv[i + (++consumed)];
+ break;
+
+ case 'd':
+ destination = argv[i + (++consumed)];
+ break;
+
+ case 'o':
+ extra_options = argv[i + (++consumed)];
+ break;
+
+ case 'l':
+ extra_link_options = argv[i + (++consumed)];
+ break;
+
+ case 's':
+ run_tests = 0;
+ break;
+
+ default:
+ printf("Unknown option ignored `-%c`\n", argv[i][j]);
+ }
+ }
+ i += consumed;
+ }
+ } else {
+ printf("Unknown option ignored `%s`\n", argv[i]);
+ }
+ }
+
+ fflush(stdout);
+
+ // Find C compiler
+ //
+
+ if (compiler_c[0] != '\0') {
+ if (check_compiler(compiler_c))
+ printf("C compiler found - %s\n", compiler_c);
+ else {
+ printf("C compiler not found\n");
+ return 1;
+ }
+ } else
+ switch (OS) {
+ case LINUX:
+ if (check_compiler("gcc")) {
+ compiler_c = "gcc";
+ printf("C compiler found - GCC\n");
+ } else if (check_compiler("clang")) {
+ compiler_c = "clang";
+ printf("C compiler found - Clang");
+ } else if (check_compiler("cc")) {
+ compiler_c = "cc";
+ printf("C compiler found - cc");
+ }
+ break;
+
+ case WINDOWS:
+ if (check_compiler("cl")) {
+ compiler_c = "cl";
+ printf("C compiler found - MSVC\n");
+ } else if (check_compiler("gcc")) {
+ compiler_c = "gcc";
+ printf("C compiler found - GCC\n");
+ } else if (check_compiler("clang")) {
+ compiler_c = "clang";
+ printf("C compiler found - Clang");
+ }
+ break;
+
+ case MACOS:
+ if (check_compiler("clang")) {
+ compiler_c = "clang";
+ printf("C compiler found - Clang");
+ } else if (check_compiler("gcc")) {
+ compiler_c = "gcc";
+ printf("C compiler found - GCC\n");
+ } else if (check_compiler("cc")) {
+ compiler_c = "cc";
+ printf("C compiler found - cc");
+ }
+ break;
+
+ default:;
+ }
+
+ if (compiler_c[0] == '\0') {
+ printf("C compiler not found\n");
+ return 1;
+ }
+
+ fflush(stdout);
+
+ // Prepare compilation options
+ //
+
+ if (OS == WINDOWS)
+ postfix_exe = ".exe";
+
+ if (str_eq(compiler_c, "cc")) {
+ destination[0] == '\0' && (destination = "build_cc");
+ } else if (str_eq(compiler_c, "gcc")) {
+ destination[0] == '\0' && (destination = "build_gcc");
+ } else if (str_eq(compiler_c, "clang")) {
+ destination[0] == '\0' && (destination = "build_clang");
+ } else if (str_eq_lower(compiler_c, "cl") || str_eq_lower(compiler_c, "cl.exe")) {
+ destination[0] == '\0' && (destination = "build_cl");
+ postfix_obj = ".obj";
+ flag_obj = "-c -Fo";
+ flag_exe = "-Fe";
+ } else if (str_eq(compiler_c, "emcc")) {
+ destination[0] == '\0' && (destination = "build_emcc");
+ postfix_exe = ".js";
+ run_tests = 0;
+ }
+
+ if (str_eq_lower(compiler_c, "cl") || str_eq_lower(compiler_c, "cl.exe")) {
+ if (str_eq_lower(build_type, "release"))
+ flags = "-O2 -DNDEBUG";
+ else
+ flags = "-Od";
+ } else if (str_eq(compiler_c, "clang")) {
+ if (str_eq_lower(build_type, "release"))
+ flags = "-O3 -DNDEBUG";
+ else
+ flags = "-O0";
+ } else {
+ if (str_eq_lower(build_type, "release"))
+ flags = "-O3 -DNDEBUG";
+ else if (OS != WINDOWS && str_eq(compiler_c, "gcc") && !STATIC_RUNTIME)
+ flags = "-Wall -Wextra -Wno-missing-braces -Wno-missing-field-initializers -Werror -pedantic -O0 -fsanitize=undefined,address,leak -mshstk";
+ else
+ flags = "-Wall -Wextra -Wno-missing-braces -Wno-missing-field-initializers -Werror -pedantic -O0";
+ }
+
+ if (OS == WINDOWS) {
+ if (str_eq_lower(compiler_c, "cl") || str_eq_lower(compiler_c, "cl.exe")) {
+ if (str_eq_lower(build_type, "debug"))
+ link_flags =
+#if REQUIRE_SOCKETS
+ "Ws2_32.lib "
+#endif
+ "Shlwapi.lib Advapi32.lib "
+#if STATIC_RUNTIME
+ "/MTd "
+#endif
+ "";
+ else
+ link_flags =
+#if REQUIRE_SOCKETS
+ "Ws2_32.lib "
+#endif
+ "Shlwapi.lib Advapi32.lib "
+#if STATIC_RUNTIME
+ "/MT "
+#endif
+ "";
+ } else
+ link_flags =
+#if REQUIRE_SOCKETS
+ "-lWs2_32 "
+#endif
+ "-lShlwapi -lAdvapi32"
+#if STATIC_RUNTIME
+ "-static "
+#endif
+ "";
+ }
+
+ if (OS == LINUX)
+ link_flags =
+#if REQUIRE_THREADS
+ "-pthread "
+#endif
+#if REQUIRE_MATH
+ "-lm "
+#endif
+#if REQUIRE_DL
+ "-ldl "
+#endif
+#if REQUIRE_GRAPHICS
+ "-lX11 -lXi -lXcursor "
+#endif
+#if REQUIRE_OPENGL
+ "-lGL "
+#endif
+#if REQUIRE_VULKAN
+ "-lvulkan "
+#endif
+#if STATIC_RUNTIME
+ "-static "
+#endif
+ "";
+
+ if (str_eq(compiler_c, "emcc"))
+ link_flags =
+#if REQUIRE_OPENGL
+ "-sFULL_ES3=1 "
+#endif
+ "";
+
+ if (extra_options[0] != '\0')
+ flags = fmt_dup("%s %s", extra_options, flags);
+ if (extra_link_options[0] != '\0')
+ link_flags = fmt_dup("%s %s", extra_link_options, link_flags);
+
+ // Prepare destination folder
+ //
+
+ destination[0] == '\0' && (destination = "build");
+
+ if (OS == WINDOWS)
+ system(fmt("if not exist %s mkdir %s", destination, destination));
+ else
+ system(fmt("mkdir %s -p", destination));
+
+ // Print info
+ //
+
+ printf("\nCompiler options: %s\n", flags);
+ printf( "Link options: %s\n\n", link_flags);
+ fflush(stdout);
+
+ // Code generation
+ //
+
+ if (path_type(SZ("build_fonts.inl.h")) == PATH_NONE) {
+ printf("Code generation\n");
+ fflush(stdout);
+
+ FILE *out = fopen("build_fonts.inl.h", "wb");
+ assert(out != NULL);
+
+ fprintf(out, "// "
+ "====================================================="
+ "===========\n");
+ fprintf(out, "//\n");
+ fprintf(out, "// Saw generated code\n");
+ fprintf(out, "//\n");
+ fprintf(out, "// "
+ "====================================================="
+ "===========\n\n");
+
+ fprintf(out, "#ifndef BUILD_FONTS_INL_H\n");
+ fprintf(out, "#define BUILD_FONTS_INL_H\n\n");
+ fprintf(out, "#include \"kit/types.h\"\n\n");
+
+ // Write Domitian Roman
+ //
+ {
+ FILE *in = fopen("fonts/domitian_roman.ttf", "rb");
+ assert(in != NULL);
+
+ fprintf(out, "u32 ttf_text[] = {");
+
+ i64 n = print_bytes(out, in);
+
+ fprintf(out, "\n};\n\n");
+ fprintf(out, "enum { TTF_TEXT_SIZE = %lld, };\n\n", n);
+
+ fclose(in);
+ }
+
+ // Write Font Awesome
+ //
+ {
+ FILE *in = fopen("fonts/font_awesome_6_free_solid_900.ttf", "rb");
+ assert(in != NULL);
+
+ fprintf(out, "u32 ttf_icons[] = {");
+
+ i64 n = print_bytes(out, in);
+
+ fprintf(out, "\n};\n\n");
+ fprintf(out, "enum { TTF_ICONS_SIZE = %lld, };\n\n", n);
+
+ fclose(in);
+ }
+
+ fprintf(out, "#endif\n");
+ fclose(out);
+ }
+
+ // Build the project
+ //
+
+ c8 *deps = fmt("%s" DLM "thirdparty%s", destination, postfix_obj);
+
+ if (path_type(str(strlen(deps), deps)) == PATH_NONE) {
+ printf("Rebuild dependencies\n");
+ fflush(stdout);
+
+ i32 s = system(fmt(
+ "%s %s -DDEPENDENCIES=1 "
+ "%s%s" DLM "thirdparty%s "
+ SOURCE
+ " %s",
+ compiler_c, flags,
+ flag_obj, destination, postfix_obj,
+ link_flags)
+ );
+
+ if (WEXITSTATUS(s) != 0)
+ return 1;
+ fflush(stdout);
+ }
+
+ printf("Build the test suite\n");
+ fflush(stdout);
+
+ i32 s = system(fmt(
+ "%s %s -DTESTS=1 "
+ "%s%s" DLM "test_suite%s "
+ SOURCE
+ " %s",
+ compiler_c, flags,
+ flag_exe, destination, postfix_exe,
+ link_flags)
+ );
+
+ if (WEXITSTATUS(s) != 0)
+ return 1;
+ fflush(stdout);
+
+ printf("Build " PROJECT " executable\n");
+ fflush(stdout);
+
+ s = system(fmt(
+ "%s %s -DEXE=1 "
+ "%s%s" DLM PROJECT "%s "
+ "%s" DLM "thirdparty%s "
+ SOURCE
+ " %s",
+ compiler_c, flags,
+ flag_exe, destination, postfix_exe,
+ destination, postfix_obj,
+ link_flags)
+ );
+
+ if (WEXITSTATUS(s) != 0)
+ return 1;
+ fflush(stdout);
+
+ if (!run_tests)
+ return 0;
+
+ // Run tests
+ //
+
+ i32 status = 0;
+
+ printf("Run tests\n\n");
+ fflush(stdout);
+
+ s = system(fmt("\"%s" DLM "test_suite\"", destination));
+
+ if (WEXITSTATUS(s) != 0)
+ status = 1;
+ fflush(stdout);
+
+ if (status == 0)
+ printf("\nAll done - OK.\n");
+ else
+ printf("\nAll done - FAILURE.\n");
+
+ return status;
+}
+
+// ================================================================
+//
+// DEPENDENCIES
+//
+// ================================================================
+
+#elif DEPENDENCIES
+
+#if defined(__EMSCRIPTEN__)
+# define SOKOL_GLES3
+# define NANOVG_GLES3 1
+#else
+# define SOKOL_GLCORE33
+# define NANOVG_GL3 1
+#endif
+
+#ifdef __GNUC__
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+#define SOKOL_APP_IMPL
+// hotfix for weird GCC bug
+#ifdef __linux__
+# include <emmintrin.h>
+#endif
+#include "kit/_lib.c"
+#include "sokol/sokol_app.h"
+#ifdef __GNUC__
+# pragma GCC diagnostic pop
+#endif
+
+#ifdef __GNUC__
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-result"
+#endif
+#define MINIAUDIO_IMPLEMENTATION
+#include "miniaudio/miniaudio.h"
+#ifdef __GNUC__
+# pragma GCC diagnostic pop
+#endif
+
+#include "nanovg/nanovg.c"
+#include "nanovg/nanovg_gl.c"
+
+// ================================================================
+//
+// EXECUTABLE
+//
+// ================================================================
+
+#elif EXE
+
+// ================================================================
+//
+// Headers
+//
+// ================================================================
+
+#include "kit/math.h"
+#include "kit/time.h"
+#include "kit/string_ref.h"
+#include "kit/mersenne_twister_64.h"
+#include "kit/secure_random.h"
+#include "kit/file.h"
+#include "kit/input_buffer.h"
+#include "kit/threads.h"
+#include "kit/status.h"
+
+#if defined(__EMSCRIPTEN__)
+# include <GLES3/gl3.h>
+# define SOKOL_GLES3
+# define NANOVG_GLES3 1
+#else
+# include <GL/gl.h>
+# define SOKOL_GLCORE33
+# define NANOVG_GL3 1
+#endif
+
+#include "sokol/sokol_app.h"
+#include "nanovg/nanovg.h"
+#include "nanovg/nanovg_gl.h"
+#include "miniaudio/miniaudio.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+// ttf_text, TTF_TEXT_SIZE
+// ttf_icons, TTF_ICONS_SIZE
+#include "build_fonts.inl.h"
+
+// ================================================================
+//
+// Definitions
+//
+// ================================================================
+
+// Program version
+//
+
+#define VERSION_MAJOR 0
+#define VERSION_MINOR 0
+#define VERSION_BABY 3
+#define VERSION_DEV 1
+
+// Constants
+//
+
+#define EPS 0.00001
+#define REFERENCE_PITCH 440.0 // A_4
+#define EQUAL_TEMPERAMENT_FACTOR 1.05946309436 // 2^(1/12)
+#define GLOBAL_VOLUME 2.0
+
+#define SPACES SZ(" \t\n\r")
+#define DELIM SZ(" \t\n\r}")
+#define NUMS SZ(" \t\n\r+-0123456789.")
+
+enum {
+ CHANNEL_COUNT = 2,
+ SAMPLE_RATE = 44100,
+ BUFFER_SIZE = 1024 * 16,
+
+ REFERENCE_PITCH_INDEX = 5 * 12, // index of A_4
+
+#ifdef __EMSCRIPTEN__
+ TRACK_COUNT = 8,
+ ROLL_COUNT = 16,
+ PITCH_COUNT = 80,
+ VOICE_COUNT = 16,
+ SHEET_SIZE = 200,
+#else
+ TRACK_COUNT = 16,
+ ROLL_COUNT = 64,
+ PITCH_COUNT = 100,
+ VOICE_COUNT = 64,
+ SHEET_SIZE = 200,
+#endif
+
+ ROLL_DEFAULT_RATE = 8,
+ ROLL_DEFAULT_UI_OFFSET_Y = 2000,
+
+ TUNING_EQUAL_TEMPERAMENT = 0,
+ TUNING_PYTHAGOREAN,
+
+ WAVE_SINE = 0,
+ WAVE_UP,
+ WAVE_DOWN,
+ WAVE_SQUARE_UP,
+ WAVE_SQUARE_DOWN,
+ WAVE_KICK,
+ WAVE_COUNT,
+
+ INSTRUMENT_NONE = 0,
+ INSTRUMENT_OSCILLATOR,
+ INSTRUMENT_SAMPLER,
+
+ SAMPLER_OUTLINE_SIZE = 64,
+
+ EDIT_MODE_HAND = 0,
+ EDIT_MODE_ERASE,
+ EDIT_MODE_PAN,
+ EDIT_MODE_CLONE,
+
+ TINT_WHITE = 0,
+ TINT_ORANGE,
+ TINT_PINK,
+
+ UI_MAIN = 0,
+ UI_DEV,
+
+ UI_TAB_COUNT,
+};
+
+// Data types
+//
+
+typedef struct {
+ b8 enabled;
+ i64 time;
+ f64 duration;
+ f64 frequency;
+ f64 amplitude;
+ f64 phase[2];
+ i64 track;
+} Voice;
+
+typedef struct {
+ b8 enabled;
+ i64 time;
+ i64 duration;
+ i64 pitch;
+} Roll_Note;
+
+typedef struct {
+ b8 enabled;
+ i64 track;
+ b8 pitch_turned_off[PITCH_COUNT];
+ f64 tuning[PITCH_COUNT];
+ i64 tuning_tag;
+ i64 mark_pitch;
+ i64 rate;
+ Roll_Note notes[SHEET_SIZE];
+ i64 time;
+ i64 duration;
+ i64 loop_duration;
+ f64 ui_offset_x;
+ f64 ui_offset_y;
+
+ // dynamic properties
+ //
+ i32 last_index;
+ b8 grid_input;
+ i32 grid_note;
+ i32 grid_time;
+ b8 ui_offset_x_input;
+ b8 ui_offset_y_input;
+ b8 loop_input;
+} Roll;
+
+typedef struct {
+ f64 sustain;
+ f64 attack;
+ f64 decay;
+ f64 release;
+} Envelope;
+
+typedef struct {
+ i32 wave;
+ f64 warp;
+ f64 phase;
+ f64 stereo_width;
+ f64 volume;
+ Envelope envelope;
+} Oscillator;
+
+typedef DA(u8) da_u8_t;
+typedef DA(f32) da_f32_t;
+
+typedef struct {
+ da_f32_t data;
+ da_f32_t outline;
+ f64 begin;
+ f64 end;
+ f64 crossfade;
+ f64 base_frequency;
+ f64 volume;
+ Envelope envelope;
+} Sampler;
+
+typedef struct {
+ i32 instrument;
+ union {
+ Oscillator oscillator;
+ Sampler sampler;
+ };
+} Track;
+
+typedef struct {
+ // dynamic properties
+ //
+ b8 grid_input;
+ i32 grid_roll;
+ i32 grid_cell;
+ b8 ui_offset_input;
+ f64 ui_offset_x;
+ f64 ui_offset_y;
+ b8 duplicate_input;
+} Compose;
+
+typedef struct {
+ f32 normal[4];
+ f32 active[4];
+ f32 hover[4];
+} UI_Color;
+
+typedef struct {
+ b8 enabled;
+ b8 selected;
+ i64 row;
+ f64 time;
+ f64 duration;
+} UI_Grid_Item;
+
+typedef struct {
+ f64 x0; // widget position x
+ f64 y0; // widget position y
+ f64 width; // widget width
+ f64 height; // widget height
+ f64 offset_y; // grid offset y
+ f64 scale_x; // grid scale x
+ f64 scale_y; // grid scale y
+
+ // timeline
+ i64 time_begin;
+ i64 time_end;
+ i64 time_cursor;
+ i64 time_offset;
+
+ // The time rate determines how to convert item time into position
+ // on the X axis.
+ //
+ // x = (time - time_offset) * scale_x / time_rate
+ //
+ i64 time_rate;
+
+ i64 meter_num; // numerator
+ i64 meter_den; // denominator
+
+ i64 items_size;
+ UI_Grid_Item *items;
+} UI_Grid;
+
+// ================================================================
+//
+// Global state
+//
+// NOTE
+// At some point we want to move all global data into a struct
+// context_t.
+//
+// ================================================================
+
+// Graphics
+//
+
+struct NVGcontext *nvg;
+i32 font_text = -1;
+i32 font_icons = -1;
+
+// Audio
+//
+
+ma_device audio_device;
+
+// Input events
+//
+
+f64 mouse_x = 0;
+f64 mouse_y = 0;
+f64 mouse_dx = 0;
+f64 mouse_dy = 0;
+b8 lbutton_click = 0;
+b8 lbutton_down = 0;
+b8 rbutton_click = 0;
+b8 rbutton_down = 0;
+b8 mbutton_click = 0;
+b8 mbutton_down = 0;
+b8 mouse_on = 0;
+b8 shift_on = 0;
+b8 ctrl_on = 0;
+
+// Playback
+//
+
+b8 playback_suspended = 1;
+b8 playback_on = 0;
+i64 playback_frame = 0;
+i64 playback_lookahead = 0;
+i64 playback_offset_read = 0;
+i64 playback_offset_write = 0;
+mtx_t playback_mutex;
+
+// Buffers
+//
+
+f32 playback_buffer[BUFFER_SIZE];
+f32 playback_temp[BUFFER_SIZE];
+b8 key_pressed[512];
+c8 drop_file_name[4096];
+da_u8_t drop_file_data;
+
+// Project state
+//
+
+i64 current_track = 0;
+i64 current_roll = 0;
+i64 edit_mode = EDIT_MODE_HAND;
+mt64_state_t rng_mt64;
+
+c8 project_file_buf[4096];
+str_t project_file;
+
+Voice voices[VOICE_COUNT] = { 0 };
+Roll rolls[ROLL_COUNT];
+Track tracks[TRACK_COUNT];
+
+Compose compose = {
+ .grid_input = 0,
+ .grid_roll = 0,
+ .grid_cell = 0,
+ .ui_offset_input = 0,
+ .ui_offset_x = 0.,
+ .ui_offset_y = 0.,
+ .duplicate_input = 0,
+};
+
+UI_Color ui_colors[] = {
+ {
+ // TINT_WHITE
+ .normal = { .7f, .7f, .7f, .7f },
+ .active = { .7f, .7f, .7f, 1.f },
+ .hover = { 1.f, 1.f, 1.f, 1.f },
+ }, {
+ // TINT_ORANGE
+ .normal = { .9f, .65f, .4f, .6f },
+ .active = { .9f, .65f, .4f, 1.f },
+ .hover = { 1.f, 1.f, 1.f, 1.f },
+ }, {
+ // TINT_PINK
+ .normal = { .7f, .3f, .6f, .7f },
+ .active = { .8f, .25f, .6f, 1.f },
+ .hover = { 1.f, 1.f, 1.f, 1.f },
+ }
+};
+
+i64 ui_input_index = 0;
+i64 ui_input_active = -1;
+f64 ui_input_buffer = 0.;
+
+i32 ui_tab = UI_MAIN;
+
+// ================================================================
+//
+// Sound
+//
+// NOTE
+// When music and signal processing procedures become stable enough
+// we will separate them into a library and add tests.
+//
+// ================================================================
+
+#ifdef __GNUC__
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunknown-pragmas"
+# pragma GCC push_options
+# pragma GCC optimize("O3")
+#endif
+
+void tuning_equal_temperament(f64 *tuning) {
+ assert(tuning != NULL);
+ if (tuning == NULL)
+ return;
+
+ for (i64 i = 0; i < PITCH_COUNT; ++i)
+ tuning[i] = REFERENCE_PITCH *
+ pow(EQUAL_TEMPERAMENT_FACTOR,
+ (f64) (i - REFERENCE_PITCH_INDEX));
+}
+
+void tuning_pythagorean(f64 *tuning, i64 base_pitch) {
+ assert(tuning != NULL && base_pitch >= 0 &&
+ base_pitch < PITCH_COUNT);
+ if (tuning == NULL || base_pitch < 0 || base_pitch >= PITCH_COUNT)
+ return;
+
+ f64 ref_freq = tuning[base_pitch];
+
+ f64 v[12] = {
+ ref_freq, // unison
+ ref_freq * 256. / 243., // minor second
+ ref_freq * 9. / 8., // major second
+ ref_freq * 32. / 27., // minor third
+ ref_freq * 81. / 64., // major third
+ ref_freq * 4. / 3., // perfect fourth
+ ref_freq * 1024. / 729., // diminished fifth
+ ref_freq * 3. / 2., // perfect fifth
+ ref_freq * 128. / 81., // minor sixth
+ ref_freq * 27. / 16., // major sixth
+ ref_freq * 16. / 9., // minor seventh
+ ref_freq * 243. / 128., // major seventh
+ };
+
+ for (i64 i = 0; i < PITCH_COUNT && i < base_pitch; i++) {
+ i64 octave = (base_pitch - i + 11) / 12;
+ i64 k = i - (base_pitch - 12 * octave);
+ assert(k >= 0 && k < 12);
+ tuning[i] = v[k] * pow(.5, octave);
+ }
+
+ for (i64 i = base_pitch; i < PITCH_COUNT && i < base_pitch + 12;
+ i++)
+ tuning[i] = v[i - base_pitch];
+
+ for (i64 i = base_pitch + 12; i < PITCH_COUNT; i++) {
+ i64 octave = (i - base_pitch) / 12;
+ i64 k = (i - base_pitch) % 12;
+ assert(k >= 0 && k < 12);
+ tuning[i] = v[k] * pow(2., octave);
+ }
+}
+
+f64 random_f64(f64 min, f64 max) {
+ if (max - min < EPS)
+ return min;
+ u64 x = mt64_generate(&rng_mt64);
+ u64 range = (u64) ((max - min) * 10000 + 0.5);
+ return min + (max - min) * ((1.0 / range) * (x % (range + 1)));
+}
+
+f64 envelope(f64 t, f64 attack, f64 decay, f64 sustain,
+ f64 duration, f64 release) {
+ f64 a = 1.;
+ if (t < attack)
+ a *= t / attack;
+ else if (t < attack + decay)
+ a *= 1. - (1. - sustain) * (t - attack) / decay;
+ else
+ a *= sustain;
+ if (t >= duration && t < duration + release)
+ a *= (duration + release - t) / release;
+ else if (t >= duration + release)
+ a = 0.;
+ return a;
+}
+
+f64 pitch_amplitude(i64 pitch) {
+ return .2 / exp(0.02 * pitch);
+}
+
+void play_voice(Track *track, Roll *roll,
+ i64 pitch, i64 duration) {
+ if (pitch < 0 || pitch >= PITCH_COUNT)
+ return;
+
+ assert(!voices[VOICE_COUNT - 1].enabled);
+ if (voices[VOICE_COUNT - 1].enabled)
+ return;
+
+ for (i32 n = VOICE_COUNT - 1; n > 0; --n)
+ voices[n] = voices[n - 1];
+
+ f64 frequency = roll->tuning[pitch];
+
+ switch (track->instrument) {
+ case INSTRUMENT_OSCILLATOR: {
+ Oscillator *osc = &track->oscillator;
+
+ f64 s = osc->stereo_width / 8;
+
+ voices[0] = (Voice) {
+ .enabled = 1,
+ .time = 0,
+ .duration = (f64) duration / (f64) SAMPLE_RATE,
+ .frequency = frequency,
+ .amplitude = pitch_amplitude(pitch) * osc->volume,
+ .phase = {
+ random_f64(-s, s),
+ random_f64(-s, s),
+ },
+ .track = roll->track,
+ };
+ } break;
+
+ case INSTRUMENT_SAMPLER: {
+ Sampler *sam = &track->sampler;
+
+ voices[0] = (Voice) {
+ .enabled = 1,
+ .time = 0,
+ .duration = (f64) duration / (f64) SAMPLE_RATE,
+ .frequency = frequency,
+ .amplitude = pitch_amplitude(pitch) * sam->volume,
+ .phase = { 0., 0., },
+ .track = roll->track,
+ };
+ } break;
+
+ default:;
+ }
+}
+
+f64 oscillator(i32 type, f64 frequency, f64 phase,
+ f64 warp, f64 t) {
+ if (type == WAVE_KICK) {
+ frequency /= 8.;
+ f64 q = t * frequency + phase;
+ frequency /= 8.;
+ f64 f = frequency * (10. + q) / (1. + q);
+ return sin(q * f * (M_PI * 2));
+ }
+
+ t = t * frequency + phase;
+ t = t - floor(t);
+
+ switch (type) {
+ case WAVE_SINE:
+ return sin(t * (M_PI * 2));
+ case WAVE_UP:
+ return -1. + t * 2.;
+ case WAVE_DOWN:
+ return 1. - t * 2.;
+ case WAVE_SQUARE_UP:
+ return t < .5 + warp / 2. ? -1. : 1.;
+ case WAVE_SQUARE_DOWN:
+ return t < .5 + warp / 2. ? 1. : -1.;
+ default:;
+ }
+
+ return 0.;
+}
+
+f64 sampler(Sampler *sam, i32 channel, f64 frequency,
+ i64 t) {
+ i64 i = (i64) floor((t * frequency) / sam->base_frequency + .5) *
+ 2 +
+ channel;
+
+ if (i < 0 || i >= sam->data.size)
+ return 0.;
+
+ return sam->data.values[i];
+}
+
+void audio_render(void) {
+ i64 frame_count = (BUFFER_SIZE / CHANNEL_COUNT);
+
+ if (mtx_lock(&playback_mutex) != thrd_success) {
+ assert(0);
+ return;
+ }
+
+ frame_count -= playback_lookahead;
+ mtx_unlock(&playback_mutex);
+
+ if (frame_count > 0) {
+ memset(playback_temp, 0,
+ frame_count * CHANNEL_COUNT * sizeof *playback_temp);
+
+ for (i64 i = 0; i < frame_count; i++) {
+ if (playback_on) {
+ // Note triggers
+ //
+
+ for (i32 k = 0; k < ROLL_COUNT; k++) {
+ Roll *roll = rolls + k;
+
+ if (!roll->enabled || playback_frame < roll->time ||
+ playback_frame >= roll->time + roll->duration)
+ continue;
+
+ i64 roll_frame = playback_frame - roll->time;
+ if (roll->loop_duration != 0)
+ roll_frame = roll_frame % roll->loop_duration;
+
+ for (i32 i = 0; i < SHEET_SIZE; i++) {
+ Roll_Note *note = roll->notes + i;
+ if (!note->enabled || note->time != roll_frame)
+ continue;
+
+ switch (tracks[roll->track].instrument) {
+ case INSTRUMENT_OSCILLATOR:
+ case INSTRUMENT_SAMPLER:
+ play_voice(tracks + roll->track, roll,
+ note->pitch, note->duration);
+ break;
+
+ default:;
+ }
+ }
+ }
+
+ ++playback_frame;
+ }
+
+ // Sound generation
+ //
+ {
+ b8 regroup_voices = 0;
+
+ for (i32 n = 0; n < VOICE_COUNT; n++) {
+ if (!voices[n].enabled)
+ break;
+
+ Track *track = tracks + voices[n].track;
+
+ switch (track->instrument) {
+ case INSTRUMENT_OSCILLATOR: {
+ Oscillator *osc = &track->oscillator;
+
+ i32 wave_type = osc->wave;
+ f64 warp = osc->warp;
+ f64 frequency = voices[n].frequency;
+ f64 amplitude = voices[n].amplitude;
+ f64 phase_l = osc->phase + voices[n].phase[0];
+ f64 phase_r = osc->phase + voices[n].phase[1];
+
+ f64 attack = osc->envelope.attack;
+ f64 decay = osc->envelope.decay;
+ f64 sustain = osc->envelope.sustain;
+ f64 duration = voices[n].duration;
+ f64 release = osc->envelope.release;
+
+ f64 t = (f64) voices[n].time / (f64) SAMPLE_RATE;
+ f64 a = amplitude * envelope(t, attack, decay,
+ sustain, duration,
+ release);
+
+ playback_temp[i * CHANNEL_COUNT] +=
+ (f32) (oscillator(wave_type, frequency, phase_l,
+ warp, t) *
+ a * GLOBAL_VOLUME);
+ playback_temp[i * CHANNEL_COUNT + 1] +=
+ (f32) (oscillator(wave_type, frequency, phase_r,
+ warp, t) *
+ a * GLOBAL_VOLUME);
+
+ voices[n].time++;
+
+ if (t > duration + release) {
+ voices[n].enabled = 0;
+ regroup_voices = 1;
+ }
+ } break;
+
+ case INSTRUMENT_SAMPLER: {
+ Sampler *sam = &track->sampler;
+
+ f64 frequency = voices[n].frequency;
+ f64 amplitude = voices[n].amplitude;
+
+ f64 attack = sam->envelope.attack;
+ f64 decay = sam->envelope.decay;
+ f64 sustain = sam->envelope.sustain;
+ f64 duration = voices[n].duration;
+ f64 release = sam->envelope.release;
+
+ f64 t = (f64) voices[n].time / (f64) SAMPLE_RATE;
+ f64 a = amplitude * envelope(t, attack, decay,
+ sustain, duration,
+ release);
+
+ if (frequency < EPS)
+ break;
+
+ f64 crossfade = (sam->crossfade * sam->base_frequency) /
+ frequency;
+ f64 sample_begin = (sam->begin * sam->base_frequency) /
+ frequency;
+ f64 sample_end = (sam->end * sam->base_frequency) /
+ frequency;
+ f64 sample_duration = sample_end - sample_begin -
+ crossfade;
+ f64 body_end = duration + release;
+
+ if (t <= body_end) {
+ // Play the body
+ //
+
+ f64 q = t;
+ if (sample_duration > EPS)
+ q -= sample_duration * floor(q / sample_duration);
+ q += sample_begin;
+
+ f64 u0 = 1.;
+
+ if (sample_duration > EPS && crossfade > EPS &&
+ t >= sample_duration && q < crossfade) {
+ // Play the body crossfade
+ //
+
+ f64 u = u0 * (1. - q / crossfade);
+ f64 r = sample_begin + sample_duration + q;
+ i64 k = (i64) floor(r * SAMPLE_RATE + .5);
+
+ playback_temp[i * CHANNEL_COUNT] +=
+ (f32) (sampler(sam, 0, frequency, k) * a *
+ u * GLOBAL_VOLUME);
+ playback_temp[i * CHANNEL_COUNT + 1] +=
+ (f32) (sampler(sam, 1, frequency, k) * a *
+ u * GLOBAL_VOLUME);
+ }
+
+ {
+ // Play the body main part
+ //
+
+ f64 u = u0;
+ if (t >= sample_duration && q < crossfade &&
+ crossfade > EPS)
+ u *= q / crossfade;
+
+ f64 r = sample_begin + q;
+ i64 k = (i64) floor(r * SAMPLE_RATE + .5);
+
+ playback_temp[i * CHANNEL_COUNT] +=
+ (f32) (sampler(sam, 0, frequency, k) * a *
+ u * GLOBAL_VOLUME);
+ playback_temp[i * CHANNEL_COUNT + 1] +=
+ (f32) (sampler(sam, 1, frequency, k) * a *
+ u * GLOBAL_VOLUME);
+ }
+ }
+
+ voices[n].time++;
+
+ if (t >= duration + release) {
+ voices[n].enabled = 0;
+ regroup_voices = 1;
+ }
+ } break;
+
+ default:;
+ }
+ }
+
+ if (regroup_voices)
+ for (i64 i = 0; i < VOICE_COUNT; ++i) {
+ if (voices[i].enabled)
+ continue;
+
+ b8 slot_found = 0;
+
+ for (i64 j = VOICE_COUNT - 1; j > i; --j) {
+ if (!voices[j].enabled)
+ continue;
+
+ memcpy(voices + i, voices + j,
+ sizeof *voices);
+ voices[j].enabled = 0;
+
+ slot_found = 1;
+ break;
+ }
+
+ if (!slot_found)
+ break;
+ }
+ }
+ }
+
+ i64 n0 = frame_count < (BUFFER_SIZE - playback_offset_write) /
+ CHANNEL_COUNT
+ ? frame_count
+ : (BUFFER_SIZE - playback_offset_write) /
+ CHANNEL_COUNT;
+ i64 n1 = frame_count - n0;
+
+ if (mtx_lock(&playback_mutex) != thrd_success) {
+ assert(0);
+ return;
+ }
+
+ if (n0 > 0)
+ memcpy(playback_buffer + playback_offset_write,
+ playback_temp,
+ n0 * CHANNEL_COUNT * sizeof *playback_temp);
+
+ if (n1 > 0)
+ memcpy(playback_buffer,
+ playback_temp + (n0 * CHANNEL_COUNT),
+ n1 * CHANNEL_COUNT * sizeof *playback_temp);
+
+ playback_offset_write = (playback_offset_write +
+ frame_count * CHANNEL_COUNT) %
+ BUFFER_SIZE;
+
+ playback_lookahead += frame_count;
+
+ mtx_unlock(&playback_mutex);
+ }
+
+#ifndef __EMSCRIPTEN__
+ if (frame_count == 0 && !playback_on)
+ // Sleep for 1/5 of the buffer duration
+ thrd_sleep(
+ &(struct timespec) {
+ .tv_nsec = (200000000ll * BUFFER_SIZE / CHANNEL_COUNT) /
+ SAMPLE_RATE },
+ NULL);
+#endif
+}
+
+void audio_callback(
+ ma_device * device,
+ void * void_out_,
+ void const *void_in_,
+ ma_uint32 frame_count
+) {
+ (void) device;
+ (void) void_in_;
+
+ f32 *out = (f32 *) void_out_;
+
+ for (i64 i = 0; i < frame_count; i++) {
+ out[i * 2] = 0.f;
+ out[i * 2 + 1] = 0.f;
+ }
+
+ if (mtx_lock(&playback_mutex) != thrd_success) {
+ assert(0);
+ return;
+ }
+
+ i64 n = frame_count < playback_lookahead
+ ? frame_count
+ : playback_lookahead;
+
+ i64 n0 = n < (BUFFER_SIZE - playback_offset_read) /
+ CHANNEL_COUNT
+ ? n
+ : (BUFFER_SIZE - playback_offset_read) /
+ CHANNEL_COUNT;
+ i64 n1 = n - n0;
+
+ if (n0 > 0)
+ memcpy(out, playback_buffer + playback_offset_read,
+ n0 * CHANNEL_COUNT * sizeof *out);
+
+ if (n1 > 0)
+ memcpy(out + (n0 * CHANNEL_COUNT), playback_buffer,
+ n1 * CHANNEL_COUNT * sizeof *out);
+
+ playback_offset_read = (playback_offset_read +
+ n * CHANNEL_COUNT) %
+ BUFFER_SIZE;
+
+ playback_lookahead -= n;
+
+ mtx_unlock(&playback_mutex);
+}
+
+void sampler_cleanup(Sampler *sampler) {
+ DA_DESTROY(sampler->data);
+ DA_DESTROY(sampler->outline);
+
+ memset(sampler, 0, sizeof *sampler);
+}
+
+#ifdef __GNUC__
+# pragma GCC pop_options
+# pragma GCC diagnostic pop
+#endif
+
+// ================================================================
+//
+// Data
+//
+// ================================================================
+
+ib_token_t parse_sign(ib_token_t tok, i64 *sign) {
+ assert(sign != NULL);
+ if (sign == NULL)
+ return (ib_token_t) {
+ .status = KIT_ERROR_INVALID_ARGUMENT,
+ };
+
+ ib_token_t next = ib_any(tok, SPACES);
+ ib_token_t plus = ib_exact(next, SZ("+"));
+ ib_token_t minus = ib_exact(next, SZ("-"));
+
+ *sign = 1;
+
+ if (plus.status == KIT_OK)
+ return ib_any(plus, SPACES);
+
+ if (minus.status == KIT_OK) {
+ *sign = -1;
+ return ib_any(minus, SPACES);
+ }
+
+ return next;
+}
+
+ib_token_t parse_int(ib_token_t tok, i64 *x) {
+ assert(x != NULL);
+ if (x == NULL)
+ return (ib_token_t) {
+ .status = KIT_ERROR_INVALID_ARGUMENT,
+ };
+
+ i64 sign;
+
+ tok = parse_sign(tok, &sign);
+ tok = ib_any(tok, SZ("0123456789"));
+
+ if (tok.status != KIT_OK)
+ return tok;
+
+ if (tok.size == 0) {
+ tok.status = KIT_PARSING_FAILED;
+ return tok;
+ }
+
+ str_t s = ib_str(tok);
+
+ *x = 0;
+
+ for (i64 i = 0; i < s.size; ++i)
+ *x = *x * 10 + (i64) (s.values[i] - '0');
+
+ *x *= sign;
+ return tok;
+}
+
+ib_token_t parse_float(ib_token_t tok, f64 *x) {
+ assert(x != NULL);
+ if (x == NULL)
+ return (ib_token_t) {
+ .status = KIT_ERROR_INVALID_ARGUMENT,
+ };
+
+ i64 sign;
+
+ tok = parse_sign(tok, &sign);
+ tok = ib_any(tok, SZ("0123456789."));
+
+ if (tok.status != KIT_OK)
+ return tok;
+
+ if (tok.size == 0) {
+ tok.status = KIT_PARSING_FAILED;
+ return tok;
+ }
+
+ str_t s = ib_str(tok);
+
+ i64 n = 0;
+ i64 dot = 0;
+
+ for (i64 i = 0; i < s.size; ++i) {
+ if (s.values[i] == '.')
+ dot = i;
+ else
+ n = n * 10 + (i64) (s.values[i] - '0');
+ }
+
+ *x = (f64) n;
+
+ if (dot < s.size - 1)
+ *x /= pow(10.0, s.size - dot - 1);
+
+ *x *= sign;
+ return tok;
+}
+
+ib_token_t parse_roll(ib_token_t tok, Roll *roll) {
+ assert(roll != NULL);
+ if (roll == NULL)
+ return (ib_token_t) {
+ .status = KIT_ERROR_INVALID_ARGUMENT,
+ };
+
+ // Init defaults
+ //
+ {
+ memset(roll, 0, sizeof *roll);
+
+ tuning_equal_temperament(roll->tuning);
+ roll->tuning_tag = TUNING_EQUAL_TEMPERAMENT;
+ roll->mark_pitch = REFERENCE_PITCH_INDEX;
+ roll->rate = ROLL_DEFAULT_RATE;
+ }
+
+ tok = ib_any(tok, SPACES);
+ tok = ib_exact(tok, SZ("roll"));
+ tok = ib_any(tok, SPACES);
+ tok = ib_exact(tok, SZ("{"));
+
+ while (tok.status == KIT_OK) {
+ tok = ib_any(tok, SPACES);
+
+ // Finish parsing if we reached closing brace
+ //
+
+ ib_token_t close = ib_exact(tok, SZ("}"));
+
+ if (close.status == KIT_OK) {
+ tok = close;
+ break;
+ }
+
+ // Parse property name
+ //
+
+ tok = ib_any(tok, SPACES);
+ tok = ib_none(tok, DELIM);
+
+ if (tok.status != KIT_OK)
+ break;
+
+ if (tok.size == 0) {
+ tok.status = KIT_PARSING_FAILED;
+ break;
+ }
+
+ ib_token_t name = tok;
+
+ // Parse property values
+ //
+
+ if (AR_EQUAL(ib_str(name), SZ("pitch_turned_off")))
+ for (i64 pitch = 0; tok.status == KIT_OK; ++pitch) {
+ i64 x;
+ ib_token_t next = parse_int(tok, &x);
+
+ if (next.status != KIT_OK)
+ break;
+
+ if (pitch >= PITCH_COUNT) {
+ printf("Too many roll pitch_turned_off values\n");
+ tok = ib_any(next, NUMS);
+ break;
+ }
+
+ roll->pitch_turned_off[pitch] = x ? 1 : 0;
+ tok = next;
+ }
+ else if (AR_EQUAL(ib_str(name), SZ("tuning")))
+ for (i64 pitch = 0; tok.status == KIT_OK; ++pitch) {
+ f64 x;
+ ib_token_t next = parse_float(tok, &x);
+
+ if (next.status != KIT_OK)
+ break;
+
+ if (pitch >= PITCH_COUNT) {
+ printf("Too many roll tuning values\n");
+ tok = ib_any(next, NUMS);
+ break;
+ }
+
+ roll->tuning[pitch] = x;
+ tok = next;
+ }
+ else if (AR_EQUAL(ib_str(name), SZ("notes")))
+ for (i64 note = 0; tok.status == KIT_OK; ++note) {
+ i64 note_enabled, note_time, note_duration, note_pitch;
+
+ ib_token_t next = parse_int(tok, &note_enabled);
+ next = parse_int(next, &note_time);
+ next = parse_int(next, &note_duration);
+ next = parse_int(next, &note_pitch);
+
+ if (next.status != KIT_OK)
+ break;
+
+ if (note >= SHEET_SIZE) {
+ printf("Too many roll notes values\n");
+ tok = ib_any(next, NUMS);
+ break;
+ }
+
+ roll->notes[note] = (Roll_Note) {
+ .enabled = note_enabled ? 1 : 0,
+ .time = note_time,
+ .duration = note_duration,
+ .pitch = note_pitch,
+ };
+
+ tok = next;
+ }
+ else if (AR_EQUAL(ib_str(name), SZ("ui_offset"))) {
+ f64 x, y;
+ ib_token_t next = parse_float(tok, &x);
+ next = parse_float(next, &y);
+
+ if (next.status == KIT_OK) {
+ tok = next;
+ roll->ui_offset_x = x;
+ roll->ui_offset_y = y;
+ } else {
+ printf("Ignored unknown roll property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ } else {
+ i64 x;
+ ib_token_t next = parse_int(tok, &x);
+
+ if (next.status == KIT_OK) {
+ tok = next;
+
+ if (AR_EQUAL(ib_str(name), SZ("enabled")))
+ roll->enabled = x ? 1 : 0;
+ else if (AR_EQUAL(ib_str(name), SZ("track")))
+ roll->track = x;
+ else if (AR_EQUAL(ib_str(name), SZ("tuning_tag")))
+ roll->tuning_tag = x;
+ else if (AR_EQUAL(ib_str(name), SZ("mark_pitch")))
+ roll->mark_pitch = x;
+ else if (AR_EQUAL(ib_str(name), SZ("rate")))
+ roll->rate = x;
+ else if (AR_EQUAL(ib_str(name), SZ("time")))
+ roll->time = x;
+ else if (AR_EQUAL(ib_str(name), SZ("duration")))
+ roll->duration = x;
+ else if (AR_EQUAL(ib_str(name), SZ("loop_duration")))
+ roll->loop_duration = x;
+ else {
+ printf("Ignored unknown roll property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ } else {
+ printf("Ignored unknown roll property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ }
+ }
+
+ return tok;
+}
+
+ib_token_t parse_track(ib_token_t tok,
+ Track *track) {
+ assert(track != NULL);
+ if (track == NULL)
+ return (ib_token_t) {
+ .status = KIT_ERROR_INVALID_ARGUMENT,
+ };
+
+ // Init defaults
+ //
+ {
+ memset(track, 0, sizeof *track);
+ track->instrument = INSTRUMENT_OSCILLATOR;
+ }
+
+ tok = ib_any(tok, SPACES);
+ tok = ib_exact(tok, SZ("track"));
+ tok = ib_any(tok, SPACES);
+ tok = ib_exact(tok, SZ("{"));
+
+ while (tok.status == KIT_OK) {
+ tok = ib_any(tok, SPACES);
+
+ // Finish parsing if we reached closing brace
+ //
+
+ ib_token_t close = ib_exact(tok, SZ("}"));
+
+ if (close.status == KIT_OK) {
+ tok = close;
+ break;
+ }
+
+ // Parse property name
+ //
+
+ tok = ib_any(tok, SPACES);
+ tok = ib_none(tok, DELIM);
+
+ if (tok.status != KIT_OK)
+ break;
+
+ if (tok.size == 0) {
+ tok.status = KIT_PARSING_FAILED;
+ break;
+ }
+
+ ib_token_t name = tok;
+
+ // Parse property values
+ //
+
+ if (AR_EQUAL(ib_str(name), SZ("data")))
+ // Array values
+ //
+
+ for (i64 k = 0; tok.status == KIT_OK; ++k) {
+ assert(track->instrument == INSTRUMENT_SAMPLER);
+ if (track->instrument != INSTRUMENT_SAMPLER) {
+ printf("Ignore unexpected track data property\n");
+ tok = ib_any(tok, NUMS);
+ break;
+ }
+
+ f64 x;
+ ib_token_t next = parse_float(tok, &x);
+
+ if (next.status != KIT_OK)
+ break;
+
+ DA_RESIZE(track->sampler.data, k + 1);
+
+ assert(track->sampler.data.size == k + 1);
+ if (track->sampler.data.size != k + 1) {
+ printf("Bad alloc\n");
+ fflush(stdout);
+ tok = ib_any(tok, NUMS);
+ break;
+ }
+
+ track->sampler.data.values[k] = x;
+ tok = next;
+ }
+ if (AR_EQUAL(ib_str(name), SZ("instrument")) ||
+ AR_EQUAL(ib_str(name), SZ("wave"))) {
+ // Integer values
+ //
+
+ i64 x;
+ ib_token_t next = parse_int(tok, &x);
+
+ if (next.status == KIT_OK) {
+ tok = next;
+
+ if (AR_EQUAL(ib_str(name), SZ("instrument"))) {
+ if (track->instrument == INSTRUMENT_SAMPLER)
+ DA_DESTROY(track->sampler.data);
+ if (x == INSTRUMENT_SAMPLER)
+ DA_INIT(track->sampler.data, 0, NULL);
+ track->instrument = (i32) x;
+ } else if (AR_EQUAL(ib_str(name), SZ("wave")) &&
+ track->instrument == INSTRUMENT_OSCILLATOR)
+ track->oscillator.wave = (i32) x;
+ else {
+ printf("Ignored unknown track property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ } else {
+ printf("Ignored unknown track property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ } else {
+ // Float values
+ //
+
+ f64 x;
+ ib_token_t next = parse_float(tok, &x);
+
+ if (next.status == KIT_OK) {
+ tok = next;
+
+ switch (track->instrument) {
+ case INSTRUMENT_OSCILLATOR:
+ if (AR_EQUAL(ib_str(name), SZ("warp")))
+ track->oscillator.warp = x;
+ else if (AR_EQUAL(ib_str(name), SZ("phase")))
+ track->oscillator.phase = x;
+ else if (AR_EQUAL(ib_str(name), SZ("stereo_width")))
+ track->oscillator.stereo_width = x;
+ else if (AR_EQUAL(ib_str(name), SZ("volume")))
+ track->oscillator.volume = x;
+ else if (AR_EQUAL(ib_str(name), SZ("sustain")))
+ track->oscillator.envelope.sustain = x;
+ else if (AR_EQUAL(ib_str(name), SZ("attack")))
+ track->oscillator.envelope.attack = x;
+ else if (AR_EQUAL(ib_str(name), SZ("decay")))
+ track->oscillator.envelope.decay = x;
+ else if (AR_EQUAL(ib_str(name), SZ("release")))
+ track->oscillator.envelope.release = x;
+ else {
+ printf("Ignored unknown track property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ break;
+
+ case INSTRUMENT_SAMPLER:
+ if (AR_EQUAL(ib_str(name), SZ("begin")))
+ track->sampler.begin = x;
+ else if (AR_EQUAL(ib_str(name), SZ("end")))
+ track->sampler.end = x;
+ else if (AR_EQUAL(ib_str(name), SZ("crossfade")))
+ track->sampler.crossfade = x;
+ else if (AR_EQUAL(ib_str(name), SZ("base_frequency")))
+ track->sampler.base_frequency = x;
+ else if (AR_EQUAL(ib_str(name), SZ("volume")))
+ track->sampler.volume = x;
+ else if (AR_EQUAL(ib_str(name), SZ("sustain")))
+ track->sampler.envelope.sustain = x;
+ else if (AR_EQUAL(ib_str(name), SZ("attack")))
+ track->sampler.envelope.attack = x;
+ else if (AR_EQUAL(ib_str(name), SZ("decay")))
+ track->sampler.envelope.decay = x;
+ else if (AR_EQUAL(ib_str(name), SZ("release")))
+ track->sampler.envelope.release = x;
+ else {
+ printf("Ignored unknown track property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ break;
+
+ default:
+ printf("Ignored unknown track property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ } else {
+ printf("Ignored unknown track property `%s`\n",
+ BS(ib_str(name)));
+ tok = ib_any(tok, NUMS);
+ }
+ }
+ }
+
+ return tok;
+}
+
+void project_parse_file(str_t file_name) {
+ FILE *f = fopen(BS(file_name), "rb");
+
+ if (f == NULL) {
+ printf("fopen failed.\n");
+ fflush(stdout);
+ return;
+ }
+
+ is_handle_t in = is_wrap_file(f, NULL);
+ input_buffer_t buf = ib_init(in, NULL);
+
+ ib_token_t last = ib_token(&buf);
+
+ memset(rolls, 0, sizeof rolls);
+ memset(tracks, 0, sizeof tracks);
+
+ current_roll = -1;
+ current_track = 0;
+
+ i64 roll_index = 0;
+ i64 track_index = 0;
+
+ for (;;) {
+ ib_token_t tok;
+
+ // Parse roll
+ //
+ {
+ Roll roll;
+ tok = parse_roll(last, &roll);
+
+ if (tok.status == KIT_OK) {
+ if (roll_index < ROLL_COUNT)
+ rolls[roll_index++] = roll;
+ else {
+ printf("Too many rolls.\n");
+ fflush(stdout);
+ break;
+ }
+
+ last = tok;
+ continue;
+ }
+ }
+
+ // Parse track
+ //
+ {
+ Track track;
+ tok = parse_track(last, &track);
+
+ if (tok.status == KIT_OK) {
+ if (track_index < TRACK_COUNT)
+ tracks[track_index++] = track;
+ else {
+ printf("Too many tracks.\n");
+ fflush(stdout);
+ break;
+ }
+
+ last = tok;
+ continue;
+ }
+ }
+
+ break;
+ }
+
+ ib_destroy(&buf);
+ is_destroy(in);
+
+ for (i64 i = 0; i < ROLL_COUNT; ++i)
+ if (rolls[i].enabled) {
+ current_roll = i;
+ break;
+ }
+}
+
+void project_print_to_file(str_t file_name) {
+ printf("Save project: %s\n", BS(file_name));
+ fflush(stdout);
+
+ FILE *f = fopen(BS(file_name), "wb");
+
+ if (f == NULL) {
+ printf("Failed to write file: %s\n", BS(file_name));
+ fflush(stdout);
+ return;
+ }
+
+ // Save rolls
+ //
+
+ i32 total_rolls = 0;
+
+ for (i64 i = 0; i < ROLL_COUNT; i++)
+ if (rolls[i].enabled)
+ total_rolls = i + 1;
+
+ for (i64 i = 0; i < total_rolls; i++) {
+ Roll *roll = rolls + i;
+
+ fprintf(f, "roll {\n");
+
+ fprintf(f, " enabled %d\n", (i32) roll->enabled);
+
+ if (roll->enabled) {
+ fprintf(f, " track %lld\n", roll->track);
+ fprintf(f, " pitch_turned_off ");
+ for (i64 pitch = 0; pitch < PITCH_COUNT; ++pitch)
+ fprintf(f, " %d", (i32) roll->pitch_turned_off[pitch]);
+ fprintf(f, "\n");
+ fprintf(f, " tuning ");
+ for (i64 pitch = 0; pitch < PITCH_COUNT; ++pitch)
+ fprintf(f, " %f", roll->tuning[pitch]);
+ fprintf(f, "\n");
+ fprintf(f, " tuning_tag %lld\n", roll->tuning_tag);
+ fprintf(f, " mark_pitch %lld\n", roll->mark_pitch);
+ fprintf(f, " rate %lld\n", roll->rate);
+
+ i32 total_notes = 0;
+ for (i32 n = 0; n < SHEET_SIZE; n++)
+ if (roll->notes[n].enabled)
+ total_notes = n + 1;
+
+ fprintf(f, " notes\n");
+ for (i32 n = 0; n < total_notes; n++)
+ fprintf(f, " %d %-6lld %-6lld %-6lld\n",
+ (i32) roll->notes[n].enabled, roll->notes[n].time,
+ roll->notes[n].duration, roll->notes[n].pitch);
+
+ fprintf(f, " time %lld\n", roll->time);
+ fprintf(f, " duration %lld\n", roll->duration);
+ fprintf(f, " loop_duration %lld\n", roll->loop_duration);
+ fprintf(f, " ui_offset %f %f\n\n", roll->ui_offset_x,
+ roll->ui_offset_y);
+ }
+
+ fprintf(f, "}\n");
+ }
+
+ // Save tracks
+ //
+
+ for (i64 i = 0; i < TRACK_COUNT; i++) {
+ Track *track = tracks + i;
+
+ fprintf(f, "track {\n");
+
+ fprintf(f, " instrument %d\n", track->instrument);
+
+ switch (track->instrument) {
+ case INSTRUMENT_OSCILLATOR: {
+ Oscillator *osc = &track->oscillator;
+
+ fprintf(f, " wave %d\n", osc->wave);
+ fprintf(f, " warp %f\n", osc->warp);
+ fprintf(f, " phase %f\n", osc->phase);
+ fprintf(f, " stereo_width %f\n", osc->stereo_width);
+ fprintf(f, " volume %f\n", osc->volume);
+ fprintf(f, " sustain %f\n", osc->envelope.sustain);
+ fprintf(f, " attack %f\n", osc->envelope.attack);
+ fprintf(f, " decay %f\n", osc->envelope.decay);
+ fprintf(f, " release %f\n\n", osc->envelope.release);
+ } break;
+
+ case INSTRUMENT_SAMPLER: {
+ Sampler *sam = &track->sampler;
+
+ fprintf(f, " data ");
+ for (i64 i = 0; i < sam->data.size; i++)
+ fprintf(f, " %f", sam->data.values[i]);
+ fprintf(f, "\n");
+
+ fprintf(f, " begin %f\n", sam->begin);
+ fprintf(f, " end %f\n", sam->end);
+ fprintf(f, " crossfade %f\n", sam->crossfade);
+ fprintf(f, " base_frequency %f\n", sam->base_frequency);
+ fprintf(f, " volume %f\n", sam->volume);
+ fprintf(f, " sustain %f\n", sam->envelope.sustain);
+ fprintf(f, " attack %f\n", sam->envelope.attack);
+ fprintf(f, " decay %f\n", sam->envelope.decay);
+ fprintf(f, " release %f\n\n", sam->envelope.release);
+ } break;
+
+ default:;
+ }
+
+ fprintf(f, "}\n");
+ }
+
+ fclose(f);
+}
+
+// ================================================================
+//
+// UI
+//
+// TODO
+// - UI library and tests.
+// - Grid widget.
+//
+// ================================================================
+
+void ui_begin(void) {
+ ui_input_index = 0;
+}
+
+void ui_end(void) {
+ if (ui_input_active != -1 && !lbutton_down) {
+ assert(0);
+
+ // Make sure to deactivate the input when the mouse button is not
+ // down.
+
+ ui_input_active = -1;
+
+#ifndef __EMSCRIPTEN__
+ sapp_lock_mouse(0);
+#endif
+ }
+}
+
+b8 ui_button(f64 x0, f64 y0, f64 width, f64 height,
+ i64 color_index, str_t icon, str_t label,
+ b8 is_active) {
+ b8 has_cursor = mouse_x >= x0 && mouse_x < x0 + width &&
+ mouse_y >= y0 && mouse_y < y0 + height;
+ UI_Color c = ui_colors[color_index];
+
+ if (has_cursor)
+ nvgFillColor(nvg, nvgRGBAf(c.hover[0], c.hover[1], c.hover[2],
+ c.hover[3]));
+ else if (is_active)
+ nvgFillColor(nvg, nvgRGBAf(c.active[0], c.active[1],
+ c.active[2], c.active[3]));
+ else
+ nvgFillColor(nvg, nvgRGBAf(c.normal[0], c.normal[1],
+ c.normal[2], c.normal[3]));
+
+ if (icon.size > 0) {
+ nvgFontSize(nvg, height * .6);
+ nvgFontFaceId(nvg, font_icons);
+ nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x0 + height * .5, y0 + height * .5, icon.values,
+ icon.values + icon.size);
+ x0 += height;
+ width -= height * 2.;
+ }
+
+ if (label.size > 0) {
+ nvgFontSize(nvg, height * .8);
+ nvgFontFaceId(nvg, font_text);
+ nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x0 + width * .5, y0 + height * .5, label.values,
+ label.values + label.size);
+ }
+
+ return lbutton_click && has_cursor;
+}
+
+void ui_value_float(f64 x0, f64 y0, f64 width, f64 height,
+ i64 color_index, str_t label,
+ f64 scale, f64 min, f64 max,
+ f64 *data) {
+ assert(data != NULL && (scale < -EPS || scale > EPS));
+ if (data == NULL || !(scale < -EPS || scale > EPS))
+ return;
+
+ b8 has_cursor = mouse_x >= x0 && mouse_x < x0 + width &&
+ mouse_y >= y0 && mouse_y < y0 + height;
+ UI_Color c = ui_colors[color_index];
+
+ // Process input
+ //
+ {
+ if (ui_input_active == -1 && has_cursor &&
+ lbutton_click) {
+ ui_input_active = ui_input_index;
+ ui_input_buffer = *data * scale;
+
+#ifndef __EMSCRIPTEN__
+ sapp_lock_mouse(1);
+#endif
+ }
+
+ if (ui_input_active == ui_input_index) {
+ if (lbutton_down) {
+ ui_input_buffer -= shift_on ? mouse_dy * 300.
+ : ctrl_on ? mouse_dy
+ : mouse_dy * 20.;
+ } else {
+ ui_input_active = -1;
+
+#ifndef __EMSCRIPTEN__
+ sapp_lock_mouse(0);
+#endif
+ }
+
+ *data = ui_input_buffer / scale;
+ }
+
+ if (*data < min)
+ *data = min;
+ if (*data > max)
+ *data = max;
+ }
+
+ // Draw UI
+ //
+ {
+ if (ui_input_active == ui_input_index ||
+ (ui_input_active == -1 && has_cursor)) {
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x0 + width * .5, y0, width * .5, height);
+ nvgFillColor(nvg, nvgRGBAf(.9f, .95f, .9f, .5f));
+ nvgFill(nvg);
+ }
+
+ nvgFontSize(nvg, height * .8);
+ nvgFontFaceId(nvg, font_text);
+
+ if (label.size > 0) {
+ nvgFillColor(nvg, nvgRGBAf(c.normal[0], c.normal[1],
+ c.normal[2], c.normal[3]));
+ nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x0, y0 + height * 5. * .125, label.values,
+ label.values + label.size);
+ x0 += width / 2;
+ }
+
+ if (has_cursor)
+ nvgFillColor(nvg, nvgRGBAf(c.hover[0], c.hover[1],
+ c.hover[2], c.hover[3]));
+ else
+ nvgFillColor(nvg, nvgRGBAf(c.active[0], c.active[1],
+ c.active[2], c.active[3]));
+ nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+ c8 buf[256];
+ sprintf(buf, "%.3f", (f32) *data);
+ nvgText(nvg, x0 + width * .25, y0 + height * 5. * .125, buf,
+ NULL);
+ }
+
+ // Increment UI element input index
+ //
+
+ ++ui_input_index;
+}
+
+void ui_value_int(f64 x0, f64 y0, f64 width, f64 height,
+ i64 color_index, str_t label, f64 scale,
+ i64 min, i64 max, i64 *data) {
+ assert(data != NULL && (scale < -EPS || scale > EPS));
+ if (data == NULL || !(scale < -EPS || scale > EPS))
+ return;
+
+ b8 has_cursor = mouse_x >= x0 && mouse_x < x0 + width &&
+ mouse_y >= y0 && mouse_y < y0 + height;
+ UI_Color c = ui_colors[color_index];
+
+ // Process input
+ //
+ {
+ if (ui_input_active == -1 && has_cursor &&
+ lbutton_click) {
+ ui_input_active = ui_input_index;
+ ui_input_buffer = (f64) *data * scale;
+
+#ifndef __EMSCRIPTEN__
+ sapp_lock_mouse(1);
+#endif
+ }
+
+ if (ui_input_active == ui_input_index) {
+ if (lbutton_down) {
+ ui_input_buffer -= shift_on ? mouse_dy * 300.
+ : ctrl_on ? mouse_dy
+ : mouse_dy * 20.;
+ } else {
+ ui_input_active = -1;
+
+#ifndef __EMSCRIPTEN__
+ sapp_lock_mouse(0);
+#endif
+ }
+
+ *data = (i64) floor(ui_input_buffer / scale + .5);
+ }
+
+ if (*data < min)
+ *data = min;
+ if (*data > max)
+ *data = max;
+ }
+
+ // Draw UI
+ //
+ {
+ if (ui_input_active == ui_input_index ||
+ (ui_input_active == -1 && has_cursor)) {
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x0 + width * .5, y0, width * .5, height);
+ nvgFillColor(nvg, nvgRGBAf(.9f, .95f, .9f, .5f));
+ nvgFill(nvg);
+ }
+
+ nvgFontSize(nvg, (height * 4) / 5);
+ nvgFontFaceId(nvg, font_text);
+
+ if (label.size > 0) {
+ nvgFillColor(nvg, nvgRGBAf(c.normal[0], c.normal[1],
+ c.normal[2], c.normal[3]));
+ nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x0, y0 + (height * 5) / 8, label.values,
+ label.values + label.size);
+ x0 += width / 2;
+ }
+
+ if (has_cursor)
+ nvgFillColor(nvg, nvgRGBAf(c.hover[0], c.hover[1],
+ c.hover[2], c.hover[3]));
+ else
+ nvgFillColor(nvg, nvgRGBAf(c.active[0], c.active[1],
+ c.active[2], c.active[3]));
+ nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+ c8 buf[256];
+ sprintf(buf, "%lld", *data);
+ nvgText(nvg, x0 + width * .25, y0 + (height * 5.) * .125, buf,
+ NULL);
+ }
+
+ // Increment UI element input index
+ //
+
+ ++ui_input_index;
+}
+
+void ui_value_list(f64 x0, f64 y0, f64 width, f64 height,
+ i64 color_index, str_t label, f64 scale,
+ i64 size, str_t *names, i32 *data) {
+ assert(data != NULL && names != NULL &&
+ (scale < -EPS || scale > EPS));
+ if (data == NULL || names == NULL || !(scale < -EPS || scale > EPS))
+ return;
+
+ b8 has_cursor = mouse_x >= x0 && mouse_x < x0 + width &&
+ mouse_y >= y0 && mouse_y < y0 + height;
+ UI_Color c = ui_colors[color_index];
+
+ // Process input
+ //
+ {
+ if (ui_input_active == -1 && has_cursor &&
+ lbutton_click) {
+ ui_input_active = ui_input_index;
+ ui_input_buffer = (f64) *data * scale;
+
+#ifndef __EMSCRIPTEN__
+ sapp_lock_mouse(1);
+#endif
+ }
+
+ if (ui_input_active == ui_input_index) {
+ if (lbutton_down) {
+ ui_input_buffer -= shift_on ? mouse_dy * 300.
+ : ctrl_on ? mouse_dy
+ : mouse_dy * 20.;
+ } else {
+ ui_input_active = -1;
+
+#ifndef __EMSCRIPTEN__
+ sapp_lock_mouse(0);
+#endif
+ }
+
+ *data = (i32) floor(ui_input_buffer / scale + .5);
+ }
+
+ if (*data < 0)
+ *data = 0;
+ if (*data >= size)
+ *data = size - 1;
+ }
+
+ // Draw UI
+ //
+ {
+ if (ui_input_active == ui_input_index ||
+ (ui_input_active == -1 && has_cursor)) {
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x0 + width * .5, y0, width * .5, height);
+ nvgFillColor(nvg, nvgRGBAf(.9f, .95f, .9f, .5f));
+ nvgFill(nvg);
+ }
+
+ nvgFontSize(nvg, height * .8);
+ nvgFontFaceId(nvg, font_text);
+
+ if (label.size > 0) {
+ nvgFillColor(nvg, nvgRGBAf(c.normal[0], c.normal[1],
+ c.normal[2], c.normal[3]));
+ nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x0, y0 + height * 5 * .125, label.values,
+ label.values + label.size);
+ x0 += width / 2;
+ }
+
+ if (has_cursor)
+ nvgFillColor(nvg, nvgRGBAf(c.hover[0], c.hover[1],
+ c.hover[2], c.hover[3]));
+ else
+ nvgFillColor(nvg, nvgRGBAf(c.active[0], c.active[1],
+ c.active[2], c.active[3]));
+ nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+ str_t s = names[*data];
+ nvgText(nvg, x0 + width * .25, y0 + height * 5 * .125,
+ s.values, s.values + s.size);
+ }
+
+ // Increment UI element input index
+ //
+
+ ++ui_input_index;
+}
+
+void ui_grid(UI_Grid *grid) {
+ // TODO
+ //
+
+ (void) grid;
+}
+
+void ui_reset_offset(void) {
+ if (current_roll != -1) {
+ rolls[current_roll].ui_offset_x = 0.;
+ rolls[current_roll].ui_offset_y =
+ ROLL_DEFAULT_UI_OFFSET_Y;
+ }
+
+ compose.ui_offset_x = 0.;
+ compose.ui_offset_y = 0.;
+}
+
+void ui_header(f64 x0, f64 y0, f64 width, f64 height) {
+ if (height > 2. * width / 15.)
+ height = 2. * width / 15.;
+
+ f64 x = x0;
+ f64 s = height;
+
+ c8 backward_fast[] = "\uf049";
+ c8 play[] = "\uf04b";
+ c8 stop[] = "\uf04d";
+ c8 anchor[] = "\uf13d";
+ c8 hand_pointer[] = "\uf25a";
+ c8 eraser[] = "\uf12d";
+ c8 panning[] = "\uf047";
+ c8 clone[] = "\uf24d";
+
+ // Global actions
+ //
+
+ if (ui_button(x, y0, s, s, TINT_WHITE, SZ(backward_fast),
+ SZ(""), 1))
+ playback_frame = 0;
+ x += s;
+
+ if (ui_button(x, y0, s, s, TINT_WHITE,
+ playback_on ? SZ(stop) : SZ(play), SZ(""), 1))
+ playback_on = !playback_on;
+ x += s;
+
+ if (ui_button(x, y0, s, s, TINT_WHITE, SZ(anchor), SZ(""), 1))
+ ui_reset_offset();
+ x += s + s / 2;
+
+ // Editing mode
+ //
+
+ if (ui_button(x, y0, s, s, TINT_ORANGE, SZ(hand_pointer),
+ SZ(""), edit_mode == EDIT_MODE_HAND))
+ edit_mode = EDIT_MODE_HAND;
+ x += s;
+
+ if (ui_button(x, y0, s, s, TINT_ORANGE, SZ(eraser), SZ(""),
+ edit_mode == EDIT_MODE_ERASE))
+ edit_mode = EDIT_MODE_ERASE;
+ x += s;
+
+ if (ui_button(x, y0, s, s, TINT_ORANGE, SZ(panning), SZ(""),
+ edit_mode == EDIT_MODE_PAN))
+ edit_mode = EDIT_MODE_PAN;
+ x += s;
+
+ if (ui_button(x, y0, s, s, TINT_ORANGE, SZ(clone), SZ(""),
+ edit_mode == EDIT_MODE_CLONE))
+ edit_mode = EDIT_MODE_CLONE;
+}
+
+void ui_compose(f64 x0, f64 y0, f64 width, f64 height) {
+ f64 track_height = 60.;
+ f64 grid_scale = 50.;
+ f64 grid_rate = 3.;
+ f64 border = 2.;
+
+ assert(track_height > EPS);
+ assert(grid_rate > EPS);
+ assert(grid_scale > EPS);
+
+ // Time bar
+ //
+
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x0, y0 + border, width,
+ track_height * .2 - border * 2.);
+ nvgRect(nvg, x0, y0 + border + track_height * .8, width,
+ track_height * .2 - border * 2.);
+ nvgFillColor(nvg, nvgRGBAf(.7f, .6f, .5f, .65f));
+ nvgFill(nvg);
+
+ // Tracks
+ //
+
+ b8 hover_any = 0;
+
+ for (i64 i = 0; i < ROLL_COUNT; i++) {
+ Roll *roll = rolls + i;
+
+ if (!roll->enabled)
+ continue;
+
+ f64 top = y0 + track_height;
+ f64 bottom = y0 + height;
+ f64 dx = x0 + compose.ui_offset_x;
+ f64 l = dx + (roll->time * grid_scale) / SAMPLE_RATE;
+ f64 r = l + (roll->duration * grid_scale) / SAMPLE_RATE;
+ f64 u = top + compose.ui_offset_y +
+ roll->track * track_height;
+ f64 d = u + track_height;
+
+ f64 s = grid_scale / grid_rate;
+
+ assert(s > EPS);
+
+ if (l < x0)
+ l = x0;
+ if (r >= x0 + width)
+ r = x0 + width;
+ if (u < top)
+ u = top;
+ if (d > bottom)
+ d = bottom;
+
+ if (l >= r || u >= d)
+ continue;
+
+ f64 x = l;
+ f64 w = r - l;
+ f64 y = u;
+ f64 h = d - u;
+
+ b8 is_choosen = (current_roll == i);
+
+ b8 is_playing = playback_on &&
+ playback_frame >= roll->time &&
+ playback_frame < roll->time + roll->duration;
+
+ b8 has_cursor = (compose.grid_input &&
+ compose.grid_roll == i) ||
+ (mouse_x >= x && mouse_x < x + w &&
+ mouse_y >= y && mouse_y < y + h);
+
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x + border, y + border, w - border * 2.,
+ h - border * 2.);
+ nvgFillColor(nvg, is_choosen ? nvgRGBAf(.9f, .8f, .7f, 1.f)
+ : is_playing ? nvgRGBAf(.9f, .8f, .7f, .9f)
+ : has_cursor
+ ? nvgRGBAf(.8f, .8f, 1.f, 1.f)
+ : nvgRGBAf(.7f, .6f, .6f, .8f));
+ nvgFill(nvg);
+
+ if (has_cursor) {
+ if (rbutton_down ||
+ (edit_mode == EDIT_MODE_ERASE && lbutton_down)) {
+ if (current_roll == i)
+ current_roll = -1;
+ roll->enabled = 0;
+ } else {
+ if (edit_mode == EDIT_MODE_HAND && lbutton_click) {
+ if (current_roll == i) {
+ i64 cell = (i64) floor(
+ ((mouse_x - compose.ui_offset_x) *
+ grid_rate) /
+ grid_scale);
+ i64 c0 = (i64) floor((roll->time * grid_rate) /
+ SAMPLE_RATE);
+ i64 c1 = c0 + (i64) floor((roll->duration * grid_rate) /
+ SAMPLE_RATE);
+ compose.grid_input = 1;
+ compose.grid_roll = current_roll;
+ if (cell - c0 > c1 - cell) {
+ compose.grid_cell = c0;
+ roll->duration = (i64) floor(
+ ((cell - c0 + 1) * SAMPLE_RATE) / grid_rate);
+ } else {
+ compose.grid_cell = c1 - 1;
+ roll->duration = (i64) floor(
+ ((c1 - cell + 1) * SAMPLE_RATE) / grid_rate);
+ }
+ } else {
+ current_roll = i;
+ current_track = roll->track;
+ }
+ }
+ hover_any = 1;
+ }
+ }
+ }
+
+ // Placing new sheet
+ //
+
+ if (!hover_any && edit_mode == EDIT_MODE_HAND &&
+ lbutton_down &&
+ mouse_x >= x0 + compose.ui_offset_x &&
+ mouse_x < x0 + width) {
+ if (!compose.grid_input && mouse_y >= y0 &&
+ mouse_y < y0 + track_height)
+ playback_frame = ((mouse_x - compose.ui_offset_x) *
+ SAMPLE_RATE) /
+ grid_scale;
+ else if (edit_mode == EDIT_MODE_HAND && lbutton_click &&
+ mouse_y >= y0 + track_height &&
+ mouse_y < y0 + height) {
+ i64 track = (i64) floor(
+ (mouse_y - compose.ui_offset_y - y0) /
+ track_height) -
+ 1;
+ i64 cell = (i64) floor(
+ ((mouse_x - compose.ui_offset_x) * grid_rate) /
+ grid_scale);
+ i64 frame = (i64) floor((cell * SAMPLE_RATE) / grid_rate);
+
+ i64 n = -1;
+
+ for (i64 i = 0; i < ROLL_COUNT; i++)
+ if (!rolls[i].enabled) {
+ n = i;
+ break;
+ }
+
+ f64 x = x0 + compose.ui_offset_x +
+ (frame * grid_scale) / SAMPLE_RATE;
+ f64 y = y0 + track_height + compose.ui_offset_y +
+ track * track_height;
+
+ if (track < 0 || track >= TRACK_COUNT || x < x0 ||
+ x >= x0 + width || y < y0 ||
+ y + track_height >= y0 + height)
+ n = -1;
+
+ if (n != -1) {
+ compose.grid_input = 1;
+ compose.grid_roll = n;
+ compose.grid_cell = cell;
+
+ rolls[n] = (Roll) {
+ .enabled = 1,
+ .track = track,
+ .pitch_turned_off = { 0 },
+ .tuning = { 0 },
+ .tuning_tag = TUNING_EQUAL_TEMPERAMENT,
+ .mark_pitch = REFERENCE_PITCH_INDEX,
+ .rate = ROLL_DEFAULT_RATE,
+ .notes = { 0 },
+ .time = frame,
+ .duration = (i64) floor((ROLL_DEFAULT_RATE * SAMPLE_RATE) /
+ grid_rate),
+ .loop_duration = 0,
+ .ui_offset_x = 0,
+ .ui_offset_y = ROLL_DEFAULT_UI_OFFSET_Y,
+ };
+
+ tuning_equal_temperament(rolls[n].tuning);
+
+ current_roll = n;
+ current_track = track;
+ }
+ }
+ }
+
+ // Duplicate selected sheet
+ //
+
+ if (compose.duplicate_input) {
+ compose.duplicate_input = 0;
+
+ do {
+ if (current_roll == -1)
+ break;
+
+ i64 track = (i64) floor(
+ (mouse_y - compose.ui_offset_y - y0) /
+ track_height) -
+ 1;
+ i64 cell = (i64) floor(
+ ((mouse_x - compose.ui_offset_x) * grid_rate) /
+ grid_scale);
+
+ if (cell < 0 || track < 0 || track >= TRACK_COUNT)
+ break;
+
+ i64 frame = (i64) floor((cell * SAMPLE_RATE) / grid_rate);
+
+ i64 n = -1;
+
+ Roll *roll = rolls + current_roll;
+
+ b8 collision = 0;
+
+ for (i64 i = 0; i < ROLL_COUNT; i++) {
+ Roll *p = rolls + i;
+
+ if (p->enabled && p->track == track &&
+ ((p->time >= frame && p->time < frame + roll->duration) ||
+ (frame >= p->time && frame < p->time + p->duration))) {
+ collision = 1;
+ break;
+ }
+ }
+
+ if (collision)
+ break;
+
+ for (i64 i = 0; i < ROLL_COUNT; i++)
+ if (!rolls[i].enabled) {
+ n = i;
+ break;
+ }
+
+ if (n == -1)
+ break;
+
+ rolls[n] = *roll;
+ rolls[n].track = track;
+ rolls[n].time = frame;
+ } while (0);
+ }
+
+ // Panning input
+ //
+
+ if (mbutton_click ||
+ (edit_mode == EDIT_MODE_PAN && lbutton_click)) {
+ if (mouse_x >= x0 && mouse_y >= y0 + track_height &&
+ mouse_x < x0 + width && mouse_y < y0 + height)
+ compose.ui_offset_input = 1;
+ }
+
+ if (!(mbutton_down ||
+ (edit_mode == EDIT_MODE_PAN && lbutton_down)))
+ compose.ui_offset_input = 0;
+
+ // Track stretching input
+ //
+
+ if (compose.grid_input) {
+ if (edit_mode == EDIT_MODE_HAND && lbutton_down) {
+ i64 cell = (i64) floor(
+ ((mouse_x - compose.ui_offset_x) * grid_rate) /
+ grid_scale);
+ Roll *p = rolls + compose.grid_roll;
+
+ if (cell >= 0) {
+ if (compose.grid_cell <= cell) {
+ p->time = (compose.grid_cell * SAMPLE_RATE) / grid_rate;
+ p->duration = (i64) floor(
+ ((1 + cell - compose.grid_cell) * SAMPLE_RATE) /
+ grid_rate);
+ } else {
+ p->time = (cell * SAMPLE_RATE) / grid_rate;
+ p->duration = (i64) floor(
+ ((1 + compose.grid_cell - cell) * SAMPLE_RATE) /
+ grid_rate);
+ }
+ }
+
+ for (i64 i = 0; i < ROLL_COUNT; i++) {
+ if (i == compose.grid_roll)
+ continue;
+ Roll *q = rolls + i;
+ if (!q->enabled || p->track != q->track)
+ continue;
+ i64 q_cell = (i64) floor((q->time * grid_rate) / SAMPLE_RATE);
+ i64 q_size = (i64) floor((q->duration * grid_rate) /
+ SAMPLE_RATE);
+ if (compose.grid_cell < q_cell && cell >= q_cell) {
+ cell = q_cell - 1;
+ p->time = (i64) floor(
+ (compose.grid_cell * SAMPLE_RATE) / grid_rate);
+ p->duration = (i64) floor(
+ ((q_cell - compose.grid_cell) * SAMPLE_RATE) /
+ grid_rate);
+ }
+ if (compose.grid_cell > q_cell &&
+ cell < q_cell + q_size) {
+ cell = q_cell + q_size;
+ p->time = (i64) floor(((q_cell + q_size) * SAMPLE_RATE) /
+ grid_rate);
+ p->duration = (i64) floor(
+ ((1 + compose.grid_cell - q_cell - q_size) *
+ SAMPLE_RATE) /
+ grid_rate);
+ }
+ }
+
+ if (p->duration <= 0)
+ p->duration = (i64) floor(SAMPLE_RATE / grid_rate);
+ } else
+ compose.grid_input = 0;
+ }
+
+ // Playback indicator
+ //
+
+ f64 x = x0 + compose.ui_offset_x - border * 2. +
+ (playback_frame * grid_scale) / SAMPLE_RATE;
+ f64 w = border * 4.;
+
+ if (x >= x0 - border * 2 && x < x0 + width) {
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x, y0, w, height);
+ nvgFillColor(nvg, nvgRGBAf(.9f, .9f, .1f, .8f));
+ nvgFill(nvg);
+ }
+
+ // Draw cursor
+ //
+
+ if (mouse_on && !hover_any && !compose.grid_input &&
+ mouse_x >= x0 + compose.ui_offset_x) {
+ i64 track = (mouse_y - compose.ui_offset_y - y0) /
+ track_height -
+ 1;
+ i64 cell = (i64) floor(
+ ((mouse_x - compose.ui_offset_x) * grid_rate) /
+ grid_scale);
+ f64 x = x0 + compose.ui_offset_x +
+ (cell * grid_scale) / grid_rate;
+ f64 y = y0 + track_height + compose.ui_offset_y +
+ track * track_height;
+ f64 w = grid_scale / grid_rate;
+
+ if (track >= 0 && track < TRACK_COUNT && x >= x0 &&
+ x + w < x0 + width && y >= y0 + track_height &&
+ y + track_height < y0 + height) {
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x + border, y + border, w - border * 2,
+ track_height - border * 2);
+ nvgFillColor(nvg, nvgRGBAf(.8f, .7f, .6f, .7f));
+ nvgFill(nvg);
+ }
+ }
+
+ // Cursor indicator
+ //
+
+ if (mouse_on && mouse_x >= x0 + compose.ui_offset_x &&
+ mouse_x < x0 + width && mouse_y >= y0 &&
+ mouse_y < y0 + height) {
+ f64 dx = x0 + compose.ui_offset_x;
+ f64 s = grid_scale / grid_rate;
+ f64 x = dx + ((mouse_x - dx + s / 2) / s) * s;
+ f64 w = border * 4;
+
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x - w / 2, y0, w, height);
+ nvgFillColor(nvg, nvgRGBAf(.2f, .2f, .9f, .6f));
+ nvgFill(nvg);
+ }
+}
+
+void ui_choose_instrument(
+ Track *track,
+ f64 x0,
+ f64 y0,
+ f64 width,
+ f64 height
+) {
+ (void) height;
+
+ f64 text_height = 40.;
+
+ x0 += width * .125;
+ width *= .75;
+
+ if (ui_button(x0, y0, width, text_height, TINT_ORANGE,
+ SZ("\uf83e"), SZ("Oscillator"), 1)) {
+ track->instrument = INSTRUMENT_OSCILLATOR;
+
+ track->oscillator = (Oscillator) {
+ .wave = WAVE_SINE,
+ .warp = .0,
+ .phase = .0,
+ .stereo_width = .2,
+ .volume = 1.,
+ .envelope = {
+ .sustain = .15,
+ .attack = .007,
+ .decay = .3,
+ .release = .4,
+ },
+ };
+ }
+
+ if (ui_button(x0, y0 + text_height, width, text_height,
+ TINT_ORANGE, SZ("\uf1c7"), SZ("Sampler"), 1)) {
+ track->instrument = INSTRUMENT_SAMPLER;
+
+ memset(&track->sampler, 0, sizeof track->sampler);
+
+ DA_INIT(track->sampler.data, 0, NULL);
+ DA_INIT(track->sampler.outline, SAMPLER_OUTLINE_SIZE, NULL);
+
+ if (track->sampler.outline.size != SAMPLER_OUTLINE_SIZE) {
+ printf("Bad alloc\n");
+ fflush(stdout);
+ track->sampler.outline.size = 0;
+ }
+
+ track->sampler.begin = 0.;
+ track->sampler.end = 1.;
+ track->sampler.crossfade = .01;
+ track->sampler.base_frequency = 440.;
+ track->sampler.volume = .5;
+
+ track->sampler.envelope = (Envelope) {
+ .sustain = .15,
+ .attack = .007,
+ .decay = .3,
+ .release = .4,
+ };
+ }
+}
+
+void ui_oscillator(
+ Oscillator *osc,
+ f64 x0,
+ f64 y0,
+ f64 width,
+ f64 height
+) {
+ (void) height;
+
+ f64 text_height = 33.;
+ f64 x = x0 + width / 12.;
+ f64 w = width * 5. / 6.;
+
+ str_t wave_names[] = {
+ SZ("Sine"), SZ("Saw up"), SZ("Saw down"),
+ SZ("Sqr up"), SZ("Sqr down"), SZ("Kick"),
+ };
+
+ ui_value_list(x, y0, w, text_height, TINT_WHITE, SZ("Wave"),
+ 500., sizeof wave_names / sizeof *wave_names,
+ wave_names, &osc->wave);
+ ui_value_float(x, y0 + text_height * 1., w, text_height,
+ TINT_WHITE, SZ("Warp"), 10000, -1., 1.,
+ &osc->warp);
+ // FIXME
+ // Looping phase value.
+ ui_value_float(x, y0 + text_height * 2., w, text_height,
+ TINT_WHITE, SZ("Phase"), 10000, 0., 1.,
+ &osc->phase);
+ ui_value_float(x, y0 + text_height * 3., w, text_height,
+ TINT_WHITE, SZ("Stereo"), 10000, 0., 2.,
+ &osc->stereo_width);
+ ui_value_float(x, y0 + text_height * 4., w, text_height,
+ TINT_WHITE, SZ("Volume"), 10000, 0., 2.,
+ &osc->volume);
+
+ nvgFontSize(nvg, text_height);
+ nvgFontFaceId(nvg, font_text);
+ nvgFillColor(nvg, nvgRGBAf(1.f, 1.f, 1.f, 1.f));
+ nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_BASELINE);
+ nvgText(nvg, x, y0 + text_height * 6.5, "Envelope", 0);
+
+ ui_value_float(x, y0 + text_height * 7., w, text_height,
+ TINT_WHITE, SZ("Sustain"), 10000, 0., 1.,
+ &osc->envelope.sustain);
+ ui_value_float(x, y0 + text_height * 8., w, text_height,
+ TINT_WHITE, SZ("Attack"), 100000, 0., 6.,
+ &osc->envelope.attack);
+ ui_value_float(x, y0 + text_height * 9., w, text_height,
+ TINT_WHITE, SZ("Decay"), 100000, 0., 6.,
+ &osc->envelope.decay);
+ ui_value_float(x, y0 + text_height * 10., w, text_height,
+ TINT_WHITE, SZ("Release"), 100000, 0., 6.,
+ &osc->envelope.release);
+}
+
+void ui_sampler(
+ Sampler *sampler,
+ f64 x0,
+ f64 y0,
+ f64 width,
+ f64 height
+) {
+ (void) height;
+
+ f64 text_height = 33.;
+ f64 x = x0 + width / 12.;
+ f64 w = width * 5. / 6.;
+ f64 sample_height = text_height * 4.;
+
+ if (drop_file_data.size != 0) {
+ // Load the audio sample from memory
+ //
+
+ ma_decoder_config decoder_config = ma_decoder_config_init(
+ ma_format_f32, CHANNEL_COUNT, SAMPLE_RATE);
+
+ ma_decoder decoder;
+
+ if (ma_decoder_init_memory(drop_file_data.values,
+ (size_t) drop_file_data.size,
+ &decoder_config,
+ &decoder) != MA_SUCCESS) {
+ printf("ma_decoder_init_memory failed.\n");
+ fflush(stdout);
+ } else {
+ do {
+ ma_uint64 length;
+
+ if (ma_decoder_get_length_in_pcm_frames(&decoder, &length) !=
+ MA_SUCCESS) {
+ printf("ma_decoder_get_length_in_pcm_frames failed.\n");
+ fflush(stdout);
+ break;
+ }
+
+ DA_RESIZE(sampler->data, length * CHANNEL_COUNT);
+
+ assert(sampler->data.size == (i64) (length * CHANNEL_COUNT));
+ if (sampler->data.size != (i64) (length * CHANNEL_COUNT)) {
+ printf("Bad alloc\n");
+ fflush(stdout);
+ sampler->data.size = 0;
+ break;
+ }
+
+ ma_uint64 frames_read;
+
+ if (ma_decoder_read_pcm_frames(
+ &decoder,
+ sampler->data.values,
+ length,
+ &frames_read
+ ) != MA_SUCCESS) {
+ printf("ma_decoder_read_pcm_frames failed.\n");
+ fflush(stdout);
+ sampler->data.size = 0;
+ break;
+ }
+
+ assert(sampler->data.size >= (i64) (frames_read * CHANNEL_COUNT));
+ sampler->data.size = frames_read * CHANNEL_COUNT;
+
+ if (sampler->outline.size == SAMPLER_OUTLINE_SIZE)
+ for (i64 i = 0; i < SAMPLER_OUTLINE_SIZE; ++i) {
+ f32 *v = sampler->data.values;
+ i64 k = (i * sampler->data.size) / SAMPLER_OUTLINE_SIZE;
+ assert(k >= 0 && k + 1 < sampler->data.size);
+ sampler->outline.values[i] = fabs(v[k] + v[k + 1]) * .5;
+ }
+ } while (0);
+
+ ma_decoder_uninit(&decoder);
+ }
+ }
+
+ if (sampler->data.size > 0) {
+ // Draw the sample outline
+ //
+
+ if (sampler->outline.size > 0) {
+ f64 dw = (f64) w / (f64) sampler->outline.size;
+ f64 h = sample_height * .5;
+ f64 y = y0 + h;
+
+ if (dw > .5) {
+ nvgBeginPath(nvg);
+
+ for (i64 i = 0; i < sampler->outline.size; i++)
+ nvgRect(nvg, x + dw * i,
+ y - h * sampler->outline.values[i], dw,
+ h * sampler->outline.values[i] * 2.);
+
+ nvgFillColor(nvg, nvgRGBAf(.8f, .4f, .0f, .7f));
+ nvgFill(nvg);
+ }
+ }
+ } else {
+ nvgFontSize(nvg, text_height * .5);
+ nvgFontFaceId(nvg, font_text);
+ nvgFillColor(nvg, nvgRGBAf(1.f, .7f, .2f, .5f));
+ nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x0 + width * .5, y0 + sample_height * .5,
+ "Drop a WAV file here", NULL);
+ }
+
+ ui_value_float(x, y0 + sample_height, w, text_height,
+ TINT_WHITE, SZ("Begin"), 100000, 0., 60.,
+ &sampler->begin);
+ ui_value_float(x, y0 + sample_height + text_height * 1., w,
+ text_height, TINT_WHITE, SZ("End"), 100000, 0.,
+ 60., &sampler->end);
+ ui_value_float(x, y0 + sample_height + text_height * 2., w,
+ text_height, TINT_WHITE, SZ("Crossfade"), 100000,
+ 0., 60., &sampler->crossfade);
+ ui_value_float(x, y0 + sample_height + text_height * 3., w,
+ text_height, TINT_WHITE, SZ("Base freq."), 500,
+ 1., 44100., &sampler->base_frequency);
+ ui_value_float(x, y0 + sample_height + text_height * 4., w,
+ text_height, TINT_WHITE, SZ("Volume."), 10000,
+ 0., 2., &sampler->volume);
+
+ nvgFontSize(nvg, text_height);
+ nvgFontFaceId(nvg, font_text);
+ nvgFillColor(nvg, nvgRGBAf(1.f, 1.f, 1.f, 1.f));
+ nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_BASELINE);
+ nvgText(nvg, x, y0 + sample_height + text_height * 6.5,
+ "Envelope", NULL);
+
+ ui_value_float(x, y0 + sample_height + text_height * 7., w,
+ text_height, TINT_WHITE, SZ("Sustain"), 10000,
+ 0., 1., &sampler->envelope.sustain);
+ ui_value_float(x, y0 + sample_height + text_height * 8., w,
+ text_height, TINT_WHITE, SZ("Attack"), 100000,
+ 0., 6., &sampler->envelope.attack);
+ ui_value_float(x, y0 + sample_height + text_height * 9., w,
+ text_height, TINT_WHITE, SZ("Decay"), 100000, 0.,
+ 6., &sampler->envelope.decay);
+ ui_value_float(x, y0 + sample_height + text_height * 10., w,
+ text_height, TINT_WHITE, SZ("Release"), 100000,
+ 0., 6., &sampler->envelope.release);
+}
+
+void ui_track(Track *track, f64 x0, f64 y0,
+ f64 width, f64 height, str_t title) {
+ f64 text_height = 33.;
+ f64 header_offset = 60.;
+ f64 border = 2.;
+
+ nvgFontSize(nvg, text_height - border);
+ nvgFontFaceId(nvg, font_text);
+ nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_BASELINE);
+ nvgFillColor(nvg, nvgRGBAf(1.f, 1.f, 1.f, 1.f));
+
+ nvgText(nvg, x0 + border * 2., y0 + text_height - border * 2.,
+ title.values, title.values + title.size);
+
+ if (track->instrument != INSTRUMENT_NONE) {
+ f64 x = x0 + width - text_height * 1.5;
+ f64 s = text_height;
+
+ b8 has_cursor = mouse_x >= x && mouse_y >= y0 &&
+ mouse_x < x + s && mouse_y < y0 + s;
+
+ c8 xmark[] = "\uf00d";
+
+ nvgFontSize(nvg, text_height);
+ nvgFontFaceId(nvg, font_icons);
+
+ if (has_cursor)
+ nvgFillColor(nvg, nvgRGBAf(.9f, .8f, .3f, 1.f));
+ else
+ nvgFillColor(nvg, nvgRGBAf(.9f, .8f, .3f, .6f));
+
+ nvgText(nvg, x + border, y0 + s - border, xmark,
+ xmark + (sizeof xmark - 1));
+
+ if (has_cursor && lbutton_click) {
+ if (track->instrument == INSTRUMENT_SAMPLER)
+ sampler_cleanup(&track->sampler);
+
+ track->instrument = INSTRUMENT_NONE;
+ }
+ }
+
+ switch (track->instrument) {
+ case INSTRUMENT_OSCILLATOR:
+ ui_oscillator(&track->oscillator, x0, y0 + header_offset,
+ width, height - header_offset);
+ break;
+
+ case INSTRUMENT_SAMPLER:
+ ui_sampler(&track->sampler, x0, y0 + header_offset, width,
+ height - header_offset);
+ break;
+
+ default:
+ ui_choose_instrument(track, x0, y0 + header_offset, width,
+ height - header_offset);
+ }
+}
+
+void ui_roll(Roll *roll, f64 x0, f64 y0, f64 width,
+ f64 height, str_t title) {
+ f64 text_height = 35.;
+ f64 header_height = 35.;
+ f64 pianokey_height = 35.;
+ f64 pianokey_width = 100.;
+ f64 border = 2.;
+
+ f64 sheet_offset = 40.;
+ f64 sheet_scale = (40. * SAMPLE_RATE) / (10000. * roll->rate);
+
+ assert(sheet_scale > EPS);
+
+ // Title text
+ //
+
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x0, y0, width, text_height);
+ nvgFillColor(nvg, nvgRGBAf(.3f, .2f, .25f, .6f));
+ nvgFill(nvg);
+
+ nvgBeginPath(nvg);
+ nvgFontSize(nvg, text_height);
+ nvgFontFaceId(nvg, font_text);
+ nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_BASELINE);
+ nvgFillColor(nvg, nvgRGBAf(1.f, 1.f, 1.f, 1.f));
+ nvgText(nvg, x0 + border * 2., y0 + text_height - border * 2,
+ title.values, title.values + title.size);
+ nvgFill(nvg);
+
+ // Tuning control
+ //
+ {
+ f64 x = x0 + border;
+ f64 y = y0 + height - text_height - header_height;
+ f64 w = pianokey_width;
+ f64 h = header_height;
+
+ if (ui_button(x, y, w * .5, h, TINT_PINK, SZ("\uf52d"),
+ SZ(""),
+ roll->tuning_tag == TUNING_PYTHAGOREAN)) {
+ tuning_pythagorean(roll->tuning, roll->mark_pitch);
+ roll->tuning_tag = TUNING_PYTHAGOREAN;
+ }
+
+ if (ui_button(x + w * .5, y, w * .5, h, TINT_PINK,
+ SZ("\uf5ac"), SZ(""),
+ roll->tuning_tag == TUNING_EQUAL_TEMPERAMENT)) {
+ tuning_equal_temperament(roll->tuning);
+ roll->tuning_tag = TUNING_EQUAL_TEMPERAMENT;
+ }
+ }
+
+ // Loop control
+ //
+ {
+ f64 x = x0 + pianokey_width + sheet_offset;
+ f64 y = y0 + text_height;
+ f64 w = width - pianokey_width - sheet_offset;
+ f64 h = header_height * .2;
+ f64 border = 5.;
+
+ c8 repeat[] = "\uf363";
+
+ nvgFontSize(nvg, header_height - border * 2.);
+ nvgFontFaceId(nvg, font_icons);
+ if (roll->loop_duration == 0)
+ nvgFillColor(nvg, nvgRGBAf(.3f, .3f, .3f, .5f));
+ else
+ nvgFillColor(nvg, nvgRGBAf(.7f, .3f, .35f, .8f));
+ nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x - header_height / 2 - border,
+ y + header_height / 2, repeat,
+ repeat + (sizeof repeat - 1));
+
+ i64 rw = (roll->loop_duration * roll->rate * sheet_scale) /
+ SAMPLE_RATE;
+ i64 rx = roll->ui_offset_x;
+
+ if (rx < 0) {
+ rw += rx;
+ rx = 0;
+ }
+
+ if (rw > w - rx)
+ rw = w - rx;
+
+ if (rw > 0) {
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x + rx, y, rw, h);
+ nvgRect(nvg, x + rx, y + h * 4., rw, h);
+ nvgFillColor(nvg, nvgRGBAf(.7f, .4f, .3f, .6f));
+ nvgFill(nvg);
+ }
+
+ nvgBeginPath(nvg);
+ if (rx > 0) {
+ nvgRect(nvg, x, y, rx, h);
+ nvgRect(nvg, x, y + h * 4., rx, h);
+ }
+ nvgRect(nvg, x + rx + rw, y, w - rx - rw, h);
+ nvgRect(nvg, x + rx + rw, y + h * 4., w - rx - rw, h);
+ nvgFillColor(nvg, nvgRGBAf(.3f, .3f, .3f, .6f));
+ nvgFill(nvg);
+
+ if (mouse_x >= x && mouse_y >= y && mouse_x < x + w &&
+ mouse_y < y + header_height && !roll->loop_input &&
+ lbutton_click)
+ roll->loop_input = 1;
+
+ if (roll->loop_input && lbutton_down) {
+ f64 t = (mouse_x - x0 - pianokey_width - sheet_offset -
+ roll->ui_offset_x) /
+ sheet_scale;
+
+ if (t <= 0)
+ roll->loop_duration = 0;
+ else
+ roll->loop_duration = (i64) floor(
+ (t * SAMPLE_RATE) / roll->rate + .5);
+ }
+ }
+
+ if (!lbutton_down)
+ roll->loop_input = 0;
+
+ // Piano roll
+ //
+ {
+ f64 w = pianokey_width - border * 2.;
+ f64 h = pianokey_height - border * 2.;
+
+ b8 hover_any = 0;
+
+ for (i64 pitch = 0; pitch < PITCH_COUNT; pitch++) {
+ f64 x = x0 + border;
+ f64 y = y0 + height - (pitch + 1) * pianokey_height + border +
+ roll->ui_offset_y;
+ if (y > y0 + height - pianokey_height)
+ continue;
+ if (y < y0 + text_height + header_height)
+ break;
+
+ b8 has_cursor = mouse_x >= x && mouse_x < x + w &&
+ mouse_y >= y && mouse_y < y + h;
+
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x, y, w, h);
+ nvgFillColor(nvg, roll->pitch_turned_off[pitch]
+ ? nvgRGBAf(.8f, .8f, .8f, .6f)
+ : has_cursor
+ ? nvgRGBAf(.7f, .7f, 1.f, 1.f)
+ : nvgRGBAf(.8f, .8f, .8f, 1.f));
+ nvgFill(nvg);
+
+ nvgFontSize(nvg, h * .5);
+
+ if (pitch == roll->mark_pitch) {
+ nvgFontFaceId(nvg, font_icons);
+ nvgFillColor(nvg, nvgRGBAf(.1f, .1f, .1f, 1.f));
+ nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x + w / 3, y + h / 2, "\uf52d", NULL);
+ }
+
+ c8 buf[64];
+ c8 const *note_names[12] = {
+ "A", "Bb", "H", "C", "Db", "D",
+ "Eb", "E", "F", "Gb", "G", "Ab",
+ };
+
+ sprintf(buf, "%s",
+ note_names[pitch %
+ (sizeof note_names / sizeof *note_names)]);
+
+ nvgFontFaceId(nvg, font_text);
+ nvgFillColor(nvg, nvgRGBAf(.1f, .1f, .1f, 1.f));
+ nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x + border, y + h / 2, buf, NULL);
+
+ memset(buf, 0, sizeof buf);
+ sprintf(buf, "%.1f", (f32) roll->tuning[pitch]);
+
+ nvgFontSize(nvg, h * 2. / 3.);
+ nvgFillColor(nvg, nvgRGBAf(.1f, .1f, .1f, 1.f));
+ nvgTextAlign(nvg, NVG_ALIGN_RIGHT | NVG_ALIGN_MIDDLE);
+ nvgText(nvg, x + w, y + h * .5, buf, NULL);
+
+ // Piano roll input
+ //
+
+ if (has_cursor) {
+ hover_any = 1;
+
+ if (!roll->pitch_turned_off[pitch] &&
+ ((edit_mode == EDIT_MODE_HAND && lbutton_click) ||
+ (edit_mode == EDIT_MODE_HAND && lbutton_down &&
+ roll->last_index != pitch))) {
+ play_voice(tracks + roll->track, roll, pitch,
+ SAMPLE_RATE / roll->rate);
+ roll->mark_pitch = pitch;
+ }
+
+ if (rbutton_click ||
+ (edit_mode == EDIT_MODE_ERASE && lbutton_click))
+ roll->pitch_turned_off[pitch] =
+ !roll->pitch_turned_off[pitch];
+
+ roll->last_index = pitch;
+ }
+ }
+
+ if (!hover_any)
+ roll->last_index = -1;
+ }
+
+ // Panning input
+ //
+
+ if (mbutton_click || (edit_mode == EDIT_MODE_PAN &&
+ lbutton_click && !roll->loop_input)) {
+ if (mouse_x >= x0 + pianokey_width + sheet_offset &&
+ mouse_y >= y0 + text_height && mouse_x < x0 + width &&
+ mouse_y < y0 + height)
+ roll->ui_offset_x_input = 1;
+ if (mouse_x >= x0 && mouse_y >= y0 + text_height &&
+ mouse_x < x0 + width && mouse_y < y0 + height)
+ roll->ui_offset_y_input = 1;
+ }
+
+ if (!(mbutton_down ||
+ (edit_mode == EDIT_MODE_PAN && lbutton_down &&
+ !roll->loop_input))) {
+ roll->ui_offset_x_input = 0;
+ roll->ui_offset_y_input = 0;
+ }
+
+ // Draw music sheet
+ //
+
+ for (i64 pitch = 0; pitch < PITCH_COUNT; pitch++) {
+ f64 y = y0 + height - (pitch + 1) * pianokey_height +
+ roll->ui_offset_y;
+
+ if (y > y0 + height - pianokey_height)
+ continue;
+ if (y < y0 + text_height + header_height)
+ break;
+
+ f64 h = pianokey_height;
+
+ for (i64 t = 0; t < (roll->duration * roll->rate) / SAMPLE_RATE;
+ t++) {
+ f64 x = x0 + pianokey_width + sheet_offset + t * sheet_scale +
+ roll->ui_offset_x;
+
+ if (x >= x0 + width - sheet_scale)
+ break;
+
+ i64 note = -1;
+
+ for (i64 n = 0; n < SHEET_SIZE; n++) {
+ Roll_Note *p = roll->notes + n;
+ if (p->enabled && p->pitch == pitch &&
+ t >= (p->time * roll->rate + SAMPLE_RATE / 2) /
+ SAMPLE_RATE &&
+ t < ((p->time + p->duration) * roll->rate +
+ SAMPLE_RATE / 2) /
+ SAMPLE_RATE) {
+ note = n;
+ break;
+ }
+ }
+
+ if (note != -1)
+ continue;
+
+ // Draw empty cell
+ //
+
+ if (x < x0 + pianokey_width + sheet_offset)
+ continue;
+
+ f64 w = sheet_scale;
+
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x + border, y + border, w - border * 2.,
+ h - border * 2.);
+
+ b8 turned_off = roll->pitch_turned_off[pitch] ||
+ (roll->loop_duration > 0 &&
+ t >= (roll->loop_duration * roll->rate) /
+ SAMPLE_RATE);
+
+ b8 has_cursor = !roll->grid_input && mouse_x >= x &&
+ mouse_x < x + w && mouse_y >= y &&
+ mouse_y < y + h;
+
+ nvgFillColor(nvg, turned_off ? nvgRGBAf(.5f, .4f, .3f, .4f)
+ : has_cursor
+ ? nvgRGBAf(.7f, .7f, .8f, .6f)
+ : nvgRGBAf(.65f, .6f, .6f, .5f));
+ nvgFill(nvg);
+
+ // Empty cell input
+ //
+
+ if (!roll->grid_input && !turned_off && has_cursor &&
+ edit_mode == EDIT_MODE_HAND && lbutton_click)
+ for (i64 n = 0; n < SHEET_SIZE; n++)
+ if (!roll->notes[n].enabled) {
+ roll->notes[n] = (Roll_Note) {
+ .enabled = 1,
+ .time = (t * SAMPLE_RATE) / roll->rate,
+ .duration = SAMPLE_RATE / roll->rate,
+ .pitch = pitch
+ };
+ roll->grid_input = 1;
+ roll->grid_note = n;
+ roll->grid_time = t;
+ play_voice(tracks + roll->track, roll, pitch,
+ SAMPLE_RATE / roll->rate);
+ break;
+ }
+ }
+ }
+
+ // Draw notes
+ //
+
+ for (i64 n = 0; n < SHEET_SIZE; n++) {
+ Roll_Note *note = roll->notes + n;
+ if (!note->enabled)
+ continue;
+
+ f64 y = y0 + height - (note->pitch + 1) * pianokey_height +
+ roll->ui_offset_y;
+
+ if (y + pianokey_height > y0 + height)
+ continue;
+ if (y < y0 + text_height + header_height)
+ continue;
+
+ f64 x = x0 + pianokey_width + sheet_offset + roll->ui_offset_x +
+ (note->time * roll->rate * sheet_scale) / SAMPLE_RATE;
+ f64 w = (note->duration * roll->rate * sheet_scale) / SAMPLE_RATE;
+ f64 h = pianokey_height;
+
+ b8 has_cursor = (roll->grid_input && roll->grid_note == n) ||
+ (mouse_x >= x && mouse_x < x + w &&
+ mouse_y >= y && mouse_y < y + h);
+
+ if (x >= x0 + width)
+ continue;
+ if (x + w - sheet_scale < x0 + pianokey_width + sheet_offset)
+ continue;
+
+ // Draw note
+ //
+
+ i64 frame = playback_frame;
+
+ if (frame >= roll->time && frame < roll->time + roll->duration &&
+ roll->loop_duration > 0)
+ frame -= ((frame - roll->time) / roll->loop_duration) *
+ roll->loop_duration;
+
+ b8 is_playing = playback_on &&
+ frame >= roll->time + note->time &&
+ frame < roll->time + note->time + note->duration;
+
+ f64 underflow = ceil((x0 + pianokey_width + sheet_offset - x) /
+ sheet_scale);
+ f64 overflow = floor((x + w + sheet_scale - x0 - width) /
+ sheet_scale);
+
+ if (underflow > 0) {
+ x += underflow * sheet_scale;
+ w -= underflow * sheet_scale;
+ }
+
+ if (overflow > 0)
+ w -= overflow * sheet_scale;
+
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x + border, y + border, w - border * 2.,
+ h - border * 2.);
+
+ nvgFillColor(nvg, is_playing ? nvgRGBAf(1.f, .9f, .8f, 1.f)
+ : has_cursor
+ ? nvgRGBAf(.7f, .7f, .9f, 1.f)
+ : nvgRGBAf(.65f, .65f, .65f, 1.f));
+ nvgFill(nvg);
+
+ // Note input
+ //
+
+ if (has_cursor &&
+ (rbutton_down ||
+ (edit_mode == EDIT_MODE_ERASE && lbutton_down)))
+ note->enabled = 0;
+ }
+
+ // Note stretching input
+ //
+
+ if (roll->grid_input) {
+ if (edit_mode == EDIT_MODE_HAND && lbutton_down) {
+ i64 t = (i64) floor((mouse_x - x0 - pianokey_width -
+ sheet_offset - roll->ui_offset_x) /
+ sheet_scale +
+ .5);
+
+ Roll_Note *p = roll->notes + roll->grid_note;
+
+ if (t >= 0) {
+ if (roll->grid_time <= t) {
+ p->time = (roll->grid_time * SAMPLE_RATE) / roll->rate;
+ p->duration = ((1 + t - roll->grid_time) * SAMPLE_RATE) /
+ roll->rate;
+ } else {
+ p->time = (t * SAMPLE_RATE) / roll->rate;
+ p->duration = ((1 + roll->grid_time - t) * SAMPLE_RATE) /
+ roll->rate;
+ }
+ }
+
+ for (i32 n = 0; n < SHEET_SIZE; n++) {
+ if (n == roll->grid_note)
+ continue;
+ Roll_Note *q = roll->notes + n;
+ if (!q->enabled || q->pitch != p->pitch)
+ continue;
+ if (q->time < (roll->grid_time * SAMPLE_RATE) / roll->rate &&
+ q->time + q->duration > p->time) {
+ p->time = q->time + q->duration;
+ p->duration = (roll->grid_time * SAMPLE_RATE) / roll->rate >
+ p->time
+ ? ((roll->grid_time + 1) * SAMPLE_RATE) /
+ roll->rate -
+ p->time
+ : SAMPLE_RATE / roll->rate;
+ }
+ if (q->time > (roll->grid_time * SAMPLE_RATE) / roll->rate &&
+ q->time < p->time + p->duration) {
+ p->time = (roll->grid_time * SAMPLE_RATE) / roll->rate;
+ p->duration = q->time -
+ (roll->grid_time * SAMPLE_RATE) / roll->rate;
+ assert(p->duration > 0);
+ }
+ }
+ } else
+ roll->grid_input = 0;
+ }
+
+ // Playback indicator
+ //
+ {
+ i64 frame = playback_frame;
+
+ if (frame >= roll->time && frame < roll->time + roll->duration &&
+ roll->loop_duration > 0)
+ frame -= ((frame - roll->time) / roll->loop_duration) *
+ roll->loop_duration;
+
+ f64 x = x0 + pianokey_width + sheet_offset + roll->ui_offset_x -
+ border * 2. +
+ ((frame - roll->time) * roll->rate * sheet_scale) /
+ SAMPLE_RATE;
+ f64 w = border * 4;
+
+ if (x >= x0 + pianokey_width + sheet_offset - border * 2. &&
+ x < x0 + width) {
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x, y0 + text_height, w, height - text_height);
+ nvgFillColor(nvg, nvgRGBAf(.9f, .9f, .2f, .7f));
+ nvgFill(nvg);
+ }
+ }
+
+ // Cursor indicator
+ //
+ if (mouse_on &&
+ mouse_x >= x0 + pianokey_width + sheet_offset &&
+ mouse_x < x0 + width && mouse_y >= y0 &&
+ mouse_y < y0 + height) {
+ f64 dx = x0 + pianokey_width + sheet_offset + roll->ui_offset_x;
+ f64 x = dx + floor((mouse_x - dx) / sheet_scale + .5) *
+ sheet_scale;
+ f64 w = border * 4.;
+
+ nvgBeginPath(nvg);
+ nvgRect(nvg, x - w * .5, y0 + text_height, w,
+ height - text_height);
+ nvgFillColor(nvg, nvgRGBAf(.2f, .2f, .8f, .7f));
+ nvgFill(nvg);
+ }
+}
+
+// ================================================================
+//
+// Event handling
+//
+// ================================================================
+
+void init_audio(void) {
+ ma_device_config config = ma_device_config_init(
+ ma_device_type_playback);
+
+ config.playback.format = ma_format_f32;
+ config.playback.channels = CHANNEL_COUNT;
+ config.sampleRate = SAMPLE_RATE;
+ config.dataCallback = audio_callback;
+ config.pUserData = NULL;
+
+ if (ma_device_init(NULL, &config, &audio_device) !=
+ MA_SUCCESS) {
+ printf("ma_device_init failed.\n");
+ fflush(stdout);
+ return;
+ }
+
+ ma_device_start(&audio_device);
+}
+
+void init(void) {
+ // Init globals
+ //
+
+ memset(key_pressed, 0, sizeof key_pressed);
+ memset(drop_file_name, 0, sizeof drop_file_name);
+ memset(&drop_file_data, 0, sizeof drop_file_data);
+ memset(playback_buffer, 0, sizeof playback_buffer);
+ memset(playback_temp, 0, sizeof playback_temp);
+
+ // Init RNG
+ //
+
+ u64 rng_seed;
+ secure_random(sizeof rng_seed, &rng_seed);
+ mt64_init(&rng_mt64, rng_seed);
+ mt64_rotate(&rng_mt64);
+
+ // Init NanoVG
+ //
+
+#ifdef SOKOL_GLCORE33
+ nvg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES);
+#else
+ nvg = nvgCreateGLES3(NVG_ANTIALIAS | NVG_STENCIL_STROKES);
+#endif
+
+ // Init playback
+ //
+
+ if (mtx_init(&playback_mutex, mtx_plain) != thrd_success) {
+ printf("mtx_init failed.\n");
+ fflush(stdout);
+ }
+
+ // Load fonts
+ //
+
+ font_text = nvgCreateFontMem(nvg, "", (u8 *) ttf_text,
+ TTF_TEXT_SIZE, 0);
+
+ if (font_text == -1) {
+ printf("nvgCreateFontMem failed.\n");
+ fflush(stdout);
+ }
+
+ font_icons = nvgCreateFontMem(nvg, "", (u8 *) ttf_icons,
+ TTF_ICONS_SIZE, 0);
+
+ if (font_icons == -1) {
+ printf("nvgCreateFontMem failed.\n");
+ fflush(stdout);
+ }
+
+ // Init Saw state
+ //
+
+ // FIXME
+ // Add init routines
+
+ static f64 tuning[PITCH_COUNT];
+
+ tuning_equal_temperament(tuning);
+
+ for (i32 i = 0; i < ROLL_COUNT; i++) {
+ rolls[i] = (Roll) {
+ .enabled = (i == 0),
+ .track = 0,
+ .pitch_turned_off = { 0 },
+ .tuning = { 0 },
+ .tuning_tag = TUNING_EQUAL_TEMPERAMENT,
+ .mark_pitch = REFERENCE_PITCH_INDEX,
+ .rate = ROLL_DEFAULT_RATE,
+ .notes = { 0 },
+ .time = 0,
+ .duration = (48 * SAMPLE_RATE) / ROLL_DEFAULT_RATE,
+ .loop_duration = 0,
+ .ui_offset_x = 0,
+ .ui_offset_y = ROLL_DEFAULT_UI_OFFSET_Y,
+ };
+
+ memcpy(rolls[i].tuning, tuning, sizeof tuning);
+ }
+
+ for (i32 i = 0; i < TRACK_COUNT; i++)
+ tracks[i] = (Track) {
+ .instrument = INSTRUMENT_OSCILLATOR,
+ .oscillator = {
+ .wave = WAVE_SINE,
+ .warp = .0,
+ .phase = .0,
+ .stereo_width = .2,
+ .volume = 1.,
+ .envelope = {
+ .sustain = .15,
+ .attack = .007,
+ .decay = .3,
+ .release = .4,
+ },
+ }
+ };
+
+ // Determine the project file name
+ //
+
+ if (project_file.size == 0) {
+ c8 arena_buf[10000];
+ kit_allocator_t arena = kit_alloc_buffer(sizeof arena_buf,
+ arena_buf);
+
+ // No need to deallocate memory with arena.
+ str_builder_t cache = path_join(WRAP_STR(path_cache(&arena)),
+ SZ("saw"), &arena);
+
+ s32 s = folder_create_recursive(WRAP_STR(cache));
+
+ if (s != KIT_OK) {
+ printf("Failed to create cache folder: %s\n (code %d)",
+ BS(cache), (i32) s);
+ fflush(stdout);
+ } else {
+ c8 project_name[] = "quick.saw";
+
+ assert(cache.size + 1 + sizeof project_name <
+ sizeof project_file_buf);
+ if (cache.size + 1 + sizeof project_name >=
+ sizeof project_file_buf) {
+ printf("File name too big\n");
+ fflush(stdout);
+ return;
+ }
+
+ memcpy(project_file_buf, cache.values, cache.size);
+ project_file_buf[cache.size] = PATH_DELIM_C;
+ memcpy(project_file_buf + cache.size + 1, project_name,
+ sizeof project_name);
+
+ project_file.size = strlen(project_file_buf);
+ project_file.values = project_file_buf;
+ }
+ }
+
+ printf("Project file: %s\n", BS(project_file));
+ fflush(stdout);
+
+ // Load the project from a file
+ //
+
+ project_parse_file(project_file);
+}
+
+void frame(void) {
+ // TODO
+ // - Check how much time passed to see if we need to adjust the
+ // buffer size.
+
+ (void) ui_value_int;
+
+ audio_render();
+
+ i64 frame_width = sapp_width();
+ i64 frame_height = sapp_height();
+
+ glViewport(0, 0, frame_width, frame_height);
+ glClearColor(.11f, .09f, .08f, 1.f);
+ glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+ // Process input
+ //
+ {
+ // Playback
+ //
+ if (key_pressed[SAPP_KEYCODE_SPACE])
+ playback_on = !playback_on;
+ if (key_pressed[SAPP_KEYCODE_ENTER])
+ playback_frame = 0;
+
+ // Duplicate
+ //
+ if (key_pressed[SAPP_KEYCODE_D] ||
+ (edit_mode == EDIT_MODE_CLONE && lbutton_click))
+ compose.duplicate_input = 1;
+
+ // Panning control
+ //
+ if (key_pressed[SAPP_KEYCODE_ESCAPE])
+ ui_reset_offset();
+ for (i64 i = 0; i < ROLL_COUNT; i++) {
+ if (rolls[i].ui_offset_x_input)
+ rolls[i].ui_offset_x += mouse_dx;
+ if (rolls[i].ui_offset_y_input)
+ rolls[i].ui_offset_y += mouse_dy;
+ }
+ if (compose.ui_offset_input) {
+ compose.ui_offset_x += mouse_dx;
+ compose.ui_offset_y += mouse_dy;
+ }
+
+ // Tabs
+ //
+ if (key_pressed[SAPP_KEYCODE_TAB])
+ ui_tab = (ui_tab + 1) % UI_TAB_COUNT;
+ }
+
+ // Render UI
+ //
+
+ nvgBeginFrame(nvg, frame_width, frame_height, sapp_dpi_scale());
+ {
+ // We have to reset intermediate state for UI input to work
+ // correctly.
+ ui_begin();
+
+ switch (ui_tab) {
+ case UI_MAIN: {
+ // Adjust UI layout
+ //
+ i64 track_width = frame_width / 5;
+ if (track_width < 330)
+ track_width = 330;
+ if (track_width > frame_width / 2)
+ track_width = frame_width / 2;
+
+ i64 header_height = 80;
+ i64 roll_height = (frame_height * 3) / 5;
+ i64 compose_height = frame_height - roll_height -
+ header_height;
+ i64 track_height = frame_height - header_height;
+
+ // Render header
+ //
+
+ ui_header(0, // x0
+ 0, // y0
+ frame_width, // width
+ header_height // height
+ );
+
+ // Render compose view
+ //
+ ui_compose(0, // x0
+ header_height, // y0
+ frame_width - track_width, // width
+ compose_height // height
+ );
+
+ if (current_track != -1) {
+ // Render track view
+ //
+
+ c8 buf[64];
+ sprintf(buf, "Track %lld", current_track + 1);
+
+ ui_track(tracks + current_track, // track
+ frame_width - track_width, // x0
+ header_height, // y0
+ track_width, // width
+ track_height, // height
+ kit_str(strlen(buf), buf) // label
+ );
+ }
+
+ if (current_roll != -1) {
+ // Render roll view
+ //
+
+ c8 buf[64];
+ sprintf(buf, "Sheet %lld", current_roll + 1);
+
+ ui_roll(rolls + current_roll, // roll
+ 0, // x0
+ header_height + compose_height, // y0
+ frame_width - track_width, // width
+ roll_height, // height
+ kit_str(strlen(buf), buf) // label
+ );
+ }
+
+ } break;
+
+ case UI_DEV: {
+ // Grid widget testing
+ //
+
+ static const i64 time_rate = 256;
+ static UI_Grid_Item items[100] = { 0 };
+
+ static UI_Grid grid = {
+ .x0 = 0.,
+ .y0 = 0.,
+ .width = 0.,
+ .height = 0.,
+ .offset_y = 0.,
+ .scale_x = 10.,
+ .scale_y = 10.,
+ .time_begin = 0,
+ .time_end = time_rate * 10,
+ .time_cursor = 0,
+ .time_offset = 0,
+ .time_rate = time_rate,
+ .meter_num = 4,
+ .meter_den = 4,
+ .items_size = sizeof items / sizeof *items,
+ .items = items,
+ };
+
+ grid.x0 = 20.;
+ grid.y0 = 20.;
+ grid.width = frame_width - 40.;
+ grid.height = frame_height - 40.;
+ grid.time_cursor = (playback_frame * time_rate) /
+ SAMPLE_RATE;
+
+ ui_grid(&grid);
+ } break;
+
+ default:;
+ }
+
+ ui_end();
+ }
+ nvgEndFrame(nvg);
+
+ // Cleanup input state.
+ //
+ {
+ mouse_dx = 0;
+ mouse_dy = 0;
+ lbutton_click = 0;
+ rbutton_click = 0;
+ mbutton_click = 0;
+ shift_on = 0;
+ ctrl_on = 0;
+
+ memset(key_pressed, 0, sizeof key_pressed);
+
+ if (drop_file_data.size != 0) {
+ memset(drop_file_name, 0, sizeof drop_file_name);
+ DA_DESTROY(drop_file_data);
+ }
+ }
+}
+
+void cleanup(void) {
+ ma_device_uninit(&audio_device);
+
+ mtx_destroy(&playback_mutex);
+
+#ifdef SOKOL_GLCORE33
+ nvgDeleteGL3(nvg);
+#else
+ nvgDeleteGLES3(nvg);
+#endif
+
+ // Save the project to a file
+ //
+
+ if (project_file.size != 0)
+ project_print_to_file(project_file);
+
+ // Cleanup samplers
+ //
+ for (i64 i = 0; i < TRACK_COUNT; i++)
+ if (tracks[i].instrument == INSTRUMENT_SAMPLER)
+ sampler_cleanup(&tracks[i].sampler);
+
+ // Cleanup buffers
+ //
+ if (drop_file_data.size != 0)
+ DA_DESTROY(drop_file_data);
+}
+
+#ifdef __EMSCRIPTEN__
+void fetch_drop(
+ sapp_html5_fetch_response const *response) {
+ assert(response != NULL);
+
+ if (response == NULL || !response->succeeded) {
+ printf("Unable to fetch the dropped file\n");
+ fflush(stdout);
+ return;
+ }
+
+ assert(drop_file_data.size >= response->data.size);
+
+ DA_RESIZE(drop_file_data, response->data.size);
+}
+#endif
+
+void event(sapp_event const *event) {
+ // Resume the audio only after a user action. This is required
+ // for the browser compatibility.
+ //
+ {
+ if (playback_suspended &&
+ (event->type == SAPP_EVENTTYPE_MOUSE_DOWN ||
+ event->type == SAPP_EVENTTYPE_TOUCHES_BEGAN ||
+ event->type == SAPP_EVENTTYPE_KEY_DOWN)) {
+ init_audio();
+ playback_suspended = 0;
+ }
+ }
+
+ switch (event->type) {
+ case SAPP_EVENTTYPE_MOUSE_MOVE:
+ mouse_on = 1;
+ shift_on = (event->modifiers & SAPP_MODIFIER_SHIFT) != 0;
+ ctrl_on = (event->modifiers & SAPP_MODIFIER_CTRL) != 0;
+ mouse_dx += event->mouse_dx;
+ mouse_dy += event->mouse_dy;
+ mouse_x = event->mouse_x;
+ mouse_y = event->mouse_y;
+ break;
+
+ case SAPP_EVENTTYPE_MOUSE_DOWN:
+ shift_on = (event->modifiers & SAPP_MODIFIER_SHIFT) != 0;
+ ctrl_on = (event->modifiers & SAPP_MODIFIER_CTRL) != 0;
+ switch (event->mouse_button) {
+ case SAPP_MOUSEBUTTON_LEFT:
+ lbutton_down = 1;
+ lbutton_click = 1;
+ break;
+ case SAPP_MOUSEBUTTON_RIGHT:
+ rbutton_down = 1;
+ rbutton_click = 1;
+ break;
+ case SAPP_MOUSEBUTTON_MIDDLE:
+ mbutton_down = 1;
+ mbutton_click = 1;
+ break;
+ default:;
+ }
+ break;
+
+ case SAPP_EVENTTYPE_MOUSE_UP:
+ shift_on = (event->modifiers & SAPP_MODIFIER_SHIFT) != 0;
+ ctrl_on = (event->modifiers & SAPP_MODIFIER_CTRL) != 0;
+ switch (event->mouse_button) {
+ case SAPP_MOUSEBUTTON_LEFT:
+ lbutton_down = 0;
+ break;
+ case SAPP_MOUSEBUTTON_RIGHT:
+ rbutton_down = 0;
+ break;
+ case SAPP_MOUSEBUTTON_MIDDLE:
+ mbutton_down = 0;
+ break;
+ default:;
+ }
+ break;
+
+ case SAPP_EVENTTYPE_MOUSE_LEAVE:
+ mouse_on = 0;
+ shift_on = (event->modifiers & SAPP_MODIFIER_SHIFT) != 0;
+ ctrl_on = (event->modifiers & SAPP_MODIFIER_CTRL) != 0;
+ lbutton_down = 0;
+ rbutton_down = 0;
+ mbutton_down = 0;
+ break;
+
+ case SAPP_EVENTTYPE_KEY_DOWN:
+ shift_on = (event->modifiers & SAPP_MODIFIER_SHIFT) != 0;
+ ctrl_on = (event->modifiers & SAPP_MODIFIER_CTRL) != 0;
+ if (!event->key_repeat && event->key_code >= 0 &&
+ event->key_code <
+ sizeof key_pressed / sizeof *key_pressed)
+ key_pressed[event->key_code] = 1;
+ break;
+
+ // Touch events.
+ // We treat touch as left mouse button and cursor.
+ //
+
+ case SAPP_EVENTTYPE_TOUCHES_BEGAN:
+ if (event->num_touches >= 1) {
+ mouse_x = event->touches[0].pos_x;
+ mouse_y = event->touches[0].pos_y;
+ lbutton_down = 1;
+ lbutton_click = 1;
+ mouse_on = 1;
+ }
+ break;
+
+ case SAPP_EVENTTYPE_TOUCHES_MOVED:
+ if (event->num_touches >= 1) {
+ i64 x = event->touches[0].pos_x;
+ i64 y = event->touches[0].pos_y;
+ mouse_dx += x - mouse_x;
+ mouse_dy += y - mouse_y;
+ mouse_x = x;
+ mouse_y = y;
+ }
+ break;
+
+ case SAPP_EVENTTYPE_TOUCHES_ENDED:
+ if (event->num_touches >= 1) {
+ i64 x = event->touches[0].pos_x;
+ i64 y = event->touches[0].pos_y;
+ mouse_dx += x - mouse_x;
+ mouse_dy += y - mouse_y;
+ mouse_x = x;
+ mouse_y = y;
+ }
+ lbutton_down = 0;
+ mouse_on = 0;
+ break;
+
+ case SAPP_EVENTTYPE_TOUCHES_CANCELLED:
+ lbutton_down = 0;
+ mouse_on = 0;
+ break;
+
+ case SAPP_EVENTTYPE_FILES_DROPPED: {
+ // Get the drop cursor position
+ //
+
+ mouse_x = event->mouse_x;
+ mouse_y = event->mouse_y;
+
+ // Get the dropped file name
+ //
+
+ i32 drop_count = sapp_get_num_dropped_files();
+ if (drop_count <= 0)
+ break;
+
+ c8 const *file_name = sapp_get_dropped_file_path(0);
+
+ i64 len = strlen(file_name);
+
+ assert(len > 0);
+ if (len <= 0)
+ break;
+
+ if (len >= (i64) sizeof drop_file_name)
+ len = sizeof drop_file_name - 1;
+
+ memcpy(drop_file_name, file_name, len);
+ drop_file_name[len] = '\0';
+
+ // Read the file data into the buffer
+ //
+
+#ifdef __EMSCRIPTEN__
+ i64 size = sapp_html5_get_dropped_file_size(0);
+#else
+ i64 size = file_info(str(len, file_name)).size;
+#endif
+
+ assert(size > 0);
+ if (size <= 0)
+ break;
+
+ if (drop_file_data.size > 0)
+ DA_DESTROY(drop_file_data);
+
+ DA_INIT(drop_file_data, size, NULL);
+
+ assert(drop_file_data.size == size);
+ if (drop_file_data.size != size) {
+ printf("Bad alloc\n");
+ fflush(stdout);
+ break;
+ }
+
+#ifdef __EMSCRIPTEN__
+ sapp_html5_fetch_dropped_file(&(sapp_html5_fetch_request) {
+ .dropped_file_index = 0,
+ .callback = fetch_drop,
+ .buffer = { .ptr = drop_file_data.values,
+ .size = size },
+ });
+#else
+ FILE *f = fopen(file_name, "rb");
+
+ assert(f != NULL);
+ if (f == NULL) {
+ printf("Unable to open file `%s`\n", file_name);
+ fflush(stdout);
+ break;
+ }
+
+ size = fread(drop_file_data.values, 1, size, f);
+ fclose(f);
+
+ assert(size > 0);
+ if (size <= 0) {
+ printf("Unable to read file `%s`\n", file_name);
+ fflush(stdout);
+ break;
+ }
+
+ DA_RESIZE(drop_file_data, size);
+#endif
+ } break;
+
+ default:;
+ }
+}
+
+c8 const *__lsan_default_suppressions(void) {
+ // There is leaks in NVidia driver on Linux.
+ return "leak:nvidia";
+}
+
+void logger(
+ c8 const *tag,
+ u32 log_level,
+ u32 log_item_id,
+ c8 const *message_or_null,
+ u32 line_nr,
+ c8 const *filename_or_null,
+ void * user_data
+) {
+ (void) tag;
+ (void) log_level;
+ (void) log_item_id;
+ (void) line_nr;
+ (void) filename_or_null;
+ (void) user_data;
+
+ if (message_or_null != NULL)
+ printf("%s", message_or_null);
+ printf("\n");
+ fflush(stdout);
+}
+
+sapp_desc sokol_main(i32 argc, c8 **argv) {
+ b8 print_version = 0;
+ b8 print_help = 0;
+
+ for (i32 i = 0; i < argc; i++)
+ if (strcmp(argv[i], "--version") == 0)
+ print_version = 1;
+ else if (strcmp(argv[i], "--help") == 0)
+ print_help = 1;
+ else if (argv[i][0] == '-' && argv[i][1] != '-' &&
+ argv[i][1] != '\0') {
+ for (i32 k = 1; argv[i][k] != '\0'; k++)
+ if (argv[i][k] == 'V')
+ print_version = 1;
+ else if (argv[i][k] == 'H')
+ print_help = 1;
+ else
+ printf("Unknown command line argument: \"-%c\"\n",
+ argv[i][k]);
+ } else if (i > 0 && project_file.size == 0)
+ project_file = kit_str(strlen(argv[i]), argv[i]);
+ else if (i > 0)
+ printf("Unknown command line argument: \"%s\"\n", argv[i]);
+
+ if (print_version)
+ printf("Saw v%d.%d.%d"
+#if VERSION_DEV
+ "_dev"
+#endif
+#ifndef NDEBUG
+ " (Debug)"
+#endif
+ " - Music sequencer standalone application.\n",
+ VERSION_MAJOR, VERSION_MINOR, VERSION_BABY);
+
+ if (print_help)
+ printf("Usage:\n%s [PROJECT_FILE]\n", argv[0]);
+
+ fflush(stdout);
+
+ if (print_version || print_help)
+ exit(0);
+
+ return (sapp_desc) {
+ .window_title = "Saw",
+ .width = 1280,
+ .height = 720,
+ .enable_dragndrop = 1,
+ .max_dropped_file_path_length = sizeof drop_file_name,
+ .init_cb = init,
+ .frame_cb = frame,
+ .cleanup_cb = cleanup,
+ .event_cb = event,
+ .logger.func = logger,
+ };
+}
+
+// ================================================================
+//
+// TESTS
+//
+// ================================================================
+
+#elif TESTS
+
+#include "kit/types.h"
+
+#define KIT_TEST_IMPLEMENTATION
+#include "kit/test.h"
+
+i32 main(i32 argc, char **argv) {
+ return run_tests(argc, argv);
+}
+
+// ================================================================
+
+#else
+#error Define either of: BUILDME=1, DEPENDENCIES=1, TESTS=1, EXE=1
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-22 22:25:37 +0000