lots of fixes to get this working in wasm

.ignore

@@ -1,5 +1,3 @@
 .git
 build
 test
-external/cglm
-external/xxhash

alloc.d

@@ -5,9 +5,11 @@ import dlib.math;
 import dlib.platform;
 import dlib.util;
 
+import core.stdc.string;
+
 version(WebAssembly)
 {
-
+	import dlib.externdecl;
 }
 else
 {
@@ -15,7 +17,7 @@ else
 }
 
 static Scratch g_scratch;
-static u64     g_scratch_index;
+static usize   g_scratch_index;
 
 const DEFAULT_ALIGNMENT = (void *).sizeof * 2;
 
@@ -28,29 +30,55 @@ struct Scratch
 struct ArenaPool
 {
 	u8*        mem;
-	u64        pos;
+	usize      pos;
-	u64        length;
+	usize      length;
 	ArenaPool* next;
 }
 
 struct Arena
 {
 	ArenaPool* first, last;
-	u64        def_size;
+	usize      def_size;
 }
 
 struct TempArena
 {
 	Arena*     arena;
-	u64        start_pos;
+	usize      start_pos;
 	ArenaPool* start_pool;
 }
 
+/*
 extern(C)
 {
 	void gc_setProxy(void* p);
 	void gc_clrProxy();
 }
+*/
+
+version(WebAssembly)
+{
+
+pragma(LDC_intrinsic, "llvm.wasm.memory.grow.i32")
+extern(C) size_t grow(size_t index, size_t size);
+
+pragma(LDC_intrinsic, "llvm.wasm.memory.size.i32")
+extern(C) size_t size(size_t index);
+
+
+extern(C) u32
+WasmGrow(u32 size)
+{
+	return grow(0, size);
+}
+
+extern(C) u32
+WasmSize()
+{
+	return size(0);
+}
+
+}
 
 T*
 MAlloc(T)()
@@ -60,7 +88,7 @@ MAlloc(T)()
 }
 
 T[]
-MAlloc(T)(u64 count)
+MAlloc(T)(usize count)
 {
 	void* mem = MemAlloc(T.sizeof * count);
 	return (cast(T*)mem)[0 .. count];
@@ -75,14 +103,14 @@ MFree(T)(T* ptr)
 void
 MFree(T)(T[] slice)
 {
-	MemFree(slice.ptr, cast(u64)slice.length * T.sizeof);
+	MemFree(slice.ptr, cast(usize)slice.length * T.sizeof);
 }
 
 T*
 Alloc(T)()
 {
 	void* mem = malloc(T.sizeof);
-	MemSet(mem, 0, T.sizeof);
+	memset(mem, 0, T.sizeof);
 	return (cast(T*)mem);
 }
 
@@ -90,7 +118,7 @@ T[]
 Alloc(T)(usize count)
 {
 	void* mem = malloc(T.sizeof * count);
-	MemSet(mem, 0, T.sizeof * count);
+	memset(mem, 0, T.sizeof * count);
 	return (cast(T*)mem)[0 .. count];
 }
 
@@ -111,7 +139,7 @@ Alloc(string target)
 }
 
 T[]
-Alloc(T)(T[] target, u64 start, u64 len)
+Alloc(T)(T[] target, usize start, usize len)
 {
 	T[] arr = Alloc!(T)(len);
 	arr[0 .. $] = target[start .. start+len];
@@ -119,7 +147,7 @@ Alloc(T)(T[] target, u64 start, u64 len)
 }
 
 string
-Alloc(string target, u64 start, u64 len)
+Alloc(string target, usize start, usize len)
 {
 	u8[] str    = Alloc!(u8)(len);
 	str[0 .. $] = cast(u8[])target[start .. start+len];
@@ -127,7 +155,7 @@ Alloc(string target, u64 start, u64 len)
 }
 
 T[]
-Alloc(T)(u64 count, T set)
+Alloc(T)(usize count, T set)
 {
 	T[] arr = Alloc!(T)(count);
 	arr[] = set;
@@ -135,9 +163,19 @@ Alloc(T)(u64 count, T set)
 }
 
 T[]
-Realloc(T)(T[] arr, u64 count)
+Realloc(T)(T[] arr, usize count)
 {
-	void* mem = realloc(arr.ptr, T.sizeof * count);
+	static if(NativeTarget)
+	{
+		void* mem = realloc(arr.ptr, T.sizeof * count);
+	}
+	else
+	{
+		void* mem = alloc(T.sizeof*count);
+		memcpy(mem, arr.ptr, T.sizeof*arr.length);
+		Free(arr);
+	}
+
 	return (cast(T*)mem)[0 .. count];
 }
 
@@ -154,7 +192,7 @@ Free(T)(T* ptr)
 }
 
 Arena 
-CreateArena(u64 size)
+CreateArena(usize size)
 {
 	Arena arena = { 
 		def_size: size,
@@ -213,13 +251,13 @@ Alloc(T)(TempArena* t, T[] target)
 }
 
 T[]
-Alloc(T)(TempArena* t, u64 count, T set)
+Alloc(T)(TempArena* t, usize count, T set)
 {
 	return Alloc!(T)(t.arena, count, set);
 }
 
 T[]
-Alloc(T)(TempArena* t, u64 count)
+Alloc(T)(TempArena* t, usize count)
 {
 	return Alloc!(T)(t.arena, count);
 }
@@ -231,7 +269,7 @@ Alloc(T)(TempArena* t, T[] target)
 }
 
 T[]
-Alloc(T)(TempArena* t, T[] target, u64 start, u64 len)
+Alloc(T)(TempArena* t, T[] target, usize start, usize len)
 {
 	return Alloc!(T)(t.arena, target, start, len);
 }
@@ -243,7 +281,7 @@ Alloc(T)(TempArena* t)
 }
 
 void
-AddArenaPool(Arena* arena, u64 size)
+AddArenaPool(Arena* arena, usize size)
 {
 	u8* mem = Alloc!(u8)(size + ArenaPool.sizeof).ptr;
 
@@ -259,10 +297,10 @@ AddArenaPool(Arena* arena, u64 size)
 }
 
 T[]
-Alloc(T)(Arena* arena, u64 count)
+Alloc(T)(Arena* arena, usize count)
 {
 	void* mem = AllocAlign(arena, T.sizeof * count, DEFAULT_ALIGNMENT);
-	MemSet(mem, 0, T.sizeof * count);
+	memset(mem, 0, T.sizeof * count);
 	return (cast(T*)mem)[0 .. cast(usize)count];
 }
 
@@ -283,7 +321,7 @@ Alloc(Arena* arena, string target)
 }
 
 T[]
-Alloc(T)(Arena* arena, T[] target, u64 start, u64 len)
+Alloc(T)(Arena* arena, T[] target, usize start, usize len)
 {
 	T[] arr     = Alloc!(T)(arena, len);
 	arr[0 .. $] = target[start .. start+len];
@@ -291,7 +329,7 @@ Alloc(T)(Arena* arena, T[] target, u64 start, u64 len)
 }
 
 string
-Alloc(Arena* arena, string target, u64 start, u64 len)
+Alloc(Arena* arena, string target, usize start, usize len)
 {
 	u8[] str    = Alloc!(u8)(arena, len);
 	str[0 .. $] = cast(u8[])target[start .. start+len];
@@ -299,7 +337,7 @@ Alloc(Arena* arena, string target, u64 start, u64 len)
 }
 
 T[]
-Alloc(T)(Arena* arena, u64 count, T set)
+Alloc(T)(Arena* arena, usize count, T set)
 {
 	T[] arr = Alloc!(T)(arena, count);
 	arr[]   = set;
@@ -310,22 +348,22 @@ T*
 Alloc(T)(Arena* arena)
 {
 	void* mem = AllocAlign(arena, T.sizeof, DEFAULT_ALIGNMENT);
-	MemSet(mem, 0, T.sizeof);
+	memset(mem, 0, T.sizeof);
 	return cast(T*)mem;
 };
 
 void* 
-AllocAlign(Arena* arena, u64 size, u64 alignment)
+AllocAlign(Arena* arena, usize size, usize alignment)
 {
 	void* ptr = null;
 
-	u64 pool_alloc_size = size;
+	usize pool_alloc_size = size;
 	if(pool_alloc_size > arena.def_size)
 	{
 		pool_alloc_size += arena.def_size;
 	}
 
-	uintptr mem_pos, current, offset;
+	usize mem_pos, current, offset;
 	ArenaPool* node = arena.first;
 	while (true)
 	{
@@ -335,7 +373,7 @@ AllocAlign(Arena* arena, u64 size, u64 alignment)
 			node = arena.first;
 		}
 
-		mem_pos = cast(uintptr)node.mem;
+		mem_pos = cast(usize)node.mem;
 		current = mem_pos + node.pos;
 		offset  = AlignPow2(current, alignment) - mem_pos;
 
@@ -378,7 +416,7 @@ Free(Arena* arena)
 }
 
 void
-ResetScratch(u64 size)
+ResetScratch(usize size)
 {
 	if(!g_scratch.init)
 	{
@@ -396,7 +434,7 @@ ScratchAlloc(T)()
 }
 
 T[]
-ScratchAlloc(T)(u64 count)
+ScratchAlloc(T)(usize count)
 {
 	return Alloc!(T)(&g_scratch.arena, count);
 }
@@ -434,7 +472,7 @@ ScratchAlloc(string target, usize start, usize len)
 }
 
 T[]
-ScratchAlloc(T)(u64 count, T set)
+ScratchAlloc(T)(usize count, T set)
 {
 	T[] arr = ScratchAlloc!(T)(count);
 	arr[] = set;

build.sh

@@ -6,80 +6,91 @@ if [ -z "$1" ]; then
 	exit 1
 fi
 
+wasm=""
+if [[ $# -eq 2 ]]; then
+	if [[ "$2" -eq "wasm" ]]; then
+		wasm="1"
+	fi
+fi
+
 script_dir=$(cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd)
 build="$1"
 	
-mkdir -p $build
+if [ -n "$wasm" ]; then
+	ext_path="${script_dir}/external"
 
-if 	 [ -x "$(command -v g++)" ]; 		then cpp_compiler="g++"; c_compiler="gcc";
+	cpp_compiler="clang++"
-elif [ -x "$(command -v clang++)" ]; then cpp_compiler="clang++"; c_compiler="clang";
+	c_compiler="clang"
-else echo "Unable to find c++ cpp_compiler"; exit -1; fi;
+	flags="-target wasm32 -nostdlib -Wl,--no-entry -c -static -mbulk-memory -mbulk-memory-opt -matomics -msimd128 -mno-gc"
+	files="${ext_path}/tinyalloc/tinyalloc.c"
+	includes="-I${ext_path}/tinyalloc"
+	out=""
 
-if 	 [ -x "$(command -v mold)" ]; then linker_cmd="-fuse-ld=mold"; 
+	$c_compiler $flags $includes $files $out
-elif [ -x "$(command -v lld)"  ]; then linker_cmd="-fuse-ld=lld";
+else
-elif [ -x "$(command -v ld)"   ]; then linker_cmd="-fuse-ld=ld"; 
+	if   [ -x "$(command -v g++)"     ]; then cpp_compiler="g++";     c_compiler="gcc";
-else echo "Unable to find c/c++ linker"; exit -1; fi;
+	elif [ -x "$(command -v clang++)" ]; then cpp_compiler="clang++"; c_compiler="clang";
+	else                                 echo "Unable to find c++ cpp_compiler"; exit -1; fi;
 
-# COMPILER FLAGS
+	if   [ -x "$(command -v mold)" ]; then linker_cmd="-fuse-ld=mold"; 
-out="-o"
+	elif [ -x "$(command -v lld)"  ]; then linker_cmd="-fuse-ld=lld";
+	elif [ -x "$(command -v ld)"   ]; then linker_cmd="-fuse-ld=ld"; 
+	else                              echo "Unable to find c/c++ linker"; exit -1; fi;
 
-# STB_IMAGE
+	shared_flags="-c -static -msse4.2 -Wno-everything $linker_cmd"
-src="${script_dir}/external/stb/stb.c"
-flags="-std=c99 -Wno-everything -Iexternal/stb -c -static"
-obj="${build}/stb.o"
-lib="${build}/libstb.a"
 
-if ! [ -f "${build}/libstb.a" ]; then
+	mkdir -p $build
-	$c_compiler $flags $src $out $obj
+
-	ar rcs $lib $obj
+	# COMPILER FLAGS
-	rm $obj
+	out="-o"
+
+	# STB_IMAGE
+	src="${script_dir}/external/stb/stb.c"
+	flags="-std=c99 -Iexternal/stb $shared_flags"
+	obj="${build}/stb.o"
+	lib="${build}/libstb.a"
+
+	if ! [ -f "${build}/libstb.a" ]; then
+		$c_compiler $flags $src $out $obj
+		ar rcs $lib $obj
+		rm $obj
+	fi
+
+	# M3D
+	#src="${script_dir}/external/m3d/m3d.c"
+	#flags="-std=c99 -Wno-everything -Iexternal/m3d -c -static"
+	#obj="${build}/m3d.o"
+	#lib="${build}/libm3d.a"
+	#
+	#if ! [ -f "${build}/libm3d.a" ]; then
+	#	$c_compiler $flags $src $out $obj
+	#	ar rcs $lib $obj
+	#	rm $obj
+	#fi
+
+	# CGLTF
+	src="${script_dir}/external/cgltf/cgltf.c"
+	flags="-std=c99 -Iexternal/cgltf $shared_flags"
+	obj="${build}/cgltf.o"
+	lib="${build}/libcgltf.a"
+
+	if ! [ -f "${build}/libcgltf.a" ]; then
+		$c_compiler $flags $src $out $obj
+		ar rcs $lib $obj
+		rm $obj
+	fi
+
+
+	# XXHASH
+	#src="${script_dir}/external/xxhash/xxhash.c"
+	#flags="-std=c99 -Iexternal/xxhash $shared_flags"
+	#obj="${build}/xxhash.o"
+	#lib="${build}/libxxhash.a"
+
+	#if ! [ -f $lib ]; then
+	#	$c_compiler $flags $src $out $obj
+	#	ar rcs $lib $obj
+	#	rm $obj
+	#fi
 fi
 
-# M3D
-#src="${script_dir}/external/m3d/m3d.c"
-#flags="-std=c99 -Wno-everything -Iexternal/m3d -c -static"
-#obj="${build}/m3d.o"
-#lib="${build}/libm3d.a"
-#
-#if ! [ -f "${build}/libm3d.a" ]; then
-#	$c_compiler $flags $src $out $obj
-#	ar rcs $lib $obj
-#	rm $obj
-#fi
-
-# CGLM
-src="${script_dir}/external/cglm/cglm.c"
-flags="-std=c99 -Wno-everything -Iexternal/cglm -c -static"
-obj="${build}/cglm.o"
-lib="${build}/libcglm.a"
-
-if ! [ -f "${build}/libcglm.a" ]; then
-	$c_compiler $flags $src $out $obj
-	ar rcs $lib $obj
-	rm $obj
-fi
-
-# CGLTF
-src="${script_dir}/external/cgltf/cgltf.c"
-flags="-std=c99 -Wno-everything -Iexternal/cgltf -c -static"
-obj="${build}/cgltf.o"
-lib="${build}/libcgltf.a"
-
-if ! [ -f "${build}/libcgltf.a" ]; then
-	$c_compiler $flags $src $out $obj
-	ar rcs $lib $obj
-	rm $obj
-fi
-
-
-# XXHASH
-src="${script_dir}/external/xxhash/xxhash.c"
-flags="-std=c99 -Wno-everything -Iexternal/xxhash -c -static"
-obj="${build}/xxhash.o"
-lib="${build}/libxxhash.a"
-
-if ! [ -f $lib ]; then
-	$c_compiler $flags $src $out $obj
-	ar rcs $lib $obj
-	rm $obj
-fi

dlibincludes.c

@@ -22,9 +22,8 @@
 # include "external/stb/stb_image_write.h"
 #endif
 
-#ifndef BUILD_WASM
+#ifdef BUILD_WASM
-# define CGLM_FORCE_DEPTH_ZERO_TO_ONE
+# include "external/tinyalloc/tinyalloc.c"
-# include "external/cglm/cglm.h"
 #endif
 
 #ifndef NO_STBI
@@ -35,12 +34,9 @@
 # include "../VulkanRenderer/vulkan_includes.c"
 #endif
 
-
+#ifndef BUILD_WASM
-#include "external/cgltf/cgltf.h"
+# include "external/cgltf/cgltf.h"
-
+#endif
-#define PRINTF_SUPPORT_FLOAT
-#include "external/printf/printf.c"
 
 #define XXH_NO_STDLIB 1
-#define XXH_STATIC_LINKING_ONLY 1
+#include "external/xxhash/xxhash.c"
-#include "external/xxhash/xxhash.h"

external.d

@@ -0,0 +1,101 @@
+module dlib.externdecl;
+
+import dlib.aliases;
+
+enum stbtt_curvetype : u8
+{
+	none,
+	vmove,
+	vline,
+	vcurve,
+	vcubic,
+}
+
+alias stbtt_vertex_type = short;
+
+struct stbtt__buf
+{
+	u8* data;
+	i32 cursor;
+	i32 size;
+}
+
+struct stbtt_vertex
+{
+	stbtt_vertex_type x, y, cx, cy, cx1, cy1;
+	stbtt_curvetype   type;
+  u8	              padding;
+}
+
+struct stbtt_fontinfo
+{
+	void* userdata;
+	u8*   data;
+	i32   fontstart;
+
+	i32   numGlyphs;
+
+	i32 loca, head, glyf, hhea, hmtx, kern, gpos, svg;
+	i32 index_map;
+	i32 indexToLocFormat;
+
+	stbtt__buf cff;
+	stbtt__buf charstrings;
+	stbtt__buf gsubrs;
+	stbtt__buf subrs;
+	stbtt__buf fontdicts;
+	stbtt__buf fdselect;
+}
+
+extern(C):
+
+// stb_truetype
+
+i32
+stbtt_FindGlyphIndex(const stbtt_fontinfo* info, i32 unicode_codepoint);
+
+void
+stbtt_GetGlyphHMetrics(const stbtt_fontinfo* info, i32 glyph_index, i32* advanceWidth, i32* leftSideBearing);
+
+i32
+stbtt_GetGlyphShape(const stbtt_fontinfo* info, i32 glyph_index, stbtt_vertex** pvertices);
+
+void
+stbtt_FreeShape(const stbtt_fontinfo* info, stbtt_vertex* v);
+
+f32
+stbtt_ScaleForPixelHeight(const stbtt_fontinfo* info, f32 height);
+
+void
+stbtt_GetFontVMetrics(const stbtt_fontinfo* info, i32* ascent, i32* descent, i32* lineGap);
+
+i32
+stbtt_InitFont(stbtt_fontinfo* info, const(u8*) data, i32 offset);
+
+i32
+stbtt_GetGlyphBox(const stbtt_fontinfo* info, i32 glyph_index, i32* x0, i32* y0, i32* x1, i32* y1);
+
+i32
+stbtt_GetFontOffsetForIndex(const(u8*) data, i32 index);
+
+// tinyalloc
+
+version(WebAssembly)
+{
+	void
+	ta_init(const usize heap_blocks, const usize split_thresh, const usize alignment);
+
+	void*
+	malloc(usize size) nothrow @nogc;
+
+	void*
+	calloc(usize size, usize count);
+
+	void
+	free(void *ptr);
+
+	void*
+	realloc(void *ptr, usize size);
+}
+
+

external/arsd-webassembly/core/arsd/aa.d

@@ -12,7 +12,6 @@ module core.arsd.aa;
 extern (C) immutable int _aaVersion = 1;
 
 import core.internal.hash;
-import core.arsd.memory_allocation;
 
 uint min(uint a, uint b) { return a < b ? a : b; }
 uint max(uint a, uint b) { return a > b ? a : b; }

external/arsd-webassembly/core/arsd/memory_allocation.d

@@ -1,7 +1,5 @@
 module core.arsd.memory_allocation;
 
-
-
 private __gshared ubyte* nextFree;
 private __gshared size_t memorySize; // in units of 64 KB pages
 

external/arsd-webassembly/core/arsd/objectutils.d

@@ -52,7 +52,7 @@ void __doPostblit(void *ptr, size_t len, const TypeInfo ti)
             return;
 
         // optimized for struct, call xpostblit directly for each element
-        immutable size = ti.size;
+        immutable size = ti.tsize;
         const eptr = ptr + len;
         for (;ptr < eptr;ptr += size)
             pblit(ptr);
@@ -60,7 +60,7 @@ void __doPostblit(void *ptr, size_t len, const TypeInfo ti)
     else
     {
         // generic case, call the typeinfo's postblit function
-        immutable size = ti.size;
+        immutable size = ti.tsize;
         const eptr = ptr + len;
         for (;ptr < eptr;ptr += size)
             ti.postblit(ptr);

external/arsd-webassembly/core/arsd/utf_decoding.d

@@ -64,7 +64,7 @@ Params:
 Returns:
     non-zero when the loop was exited through a `break`
 */
-extern (C) int _aApplycd1(in char[] aa, dg_t dg)
+extern (C) int _aApplycd1(char[] aa, dg_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -87,7 +87,7 @@ extern (C) int _aApplycd1(in char[] aa, dg_t dg)
 
 
 /// ditto
-extern (C) int _aApplywd1(in wchar[] aa, dg_t dg)
+extern (C) int _aApplywd1(wchar[] aa, dg_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -109,7 +109,7 @@ extern (C) int _aApplywd1(in wchar[] aa, dg_t dg)
 
 
 /// ditto
-extern (C) int _aApplycw1(in char[] aa, dg_t dg)
+extern (C) int _aApplycw1(char[] aa, dg_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -143,7 +143,7 @@ extern (C) int _aApplycw1(in char[] aa, dg_t dg)
 
 
 /// ditto
-extern (C) int _aApplywc1(in wchar[] aa, dg_t dg)
+extern (C) int _aApplywc1(wchar[] aa, dg_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -179,7 +179,7 @@ extern (C) int _aApplywc1(in wchar[] aa, dg_t dg)
 
 
 /// ditto
-extern (C) int _aApplydc1(in dchar[] aa, dg_t dg)
+extern (C) int _aApplydc1(dchar[] aa, dg_t dg)
 {
     int result;
 
@@ -211,7 +211,7 @@ extern (C) int _aApplydc1(in dchar[] aa, dg_t dg)
 
 
 /// ditto
-extern (C) int _aApplydw1(in dchar[] aa, dg_t dg)
+extern (C) int _aApplydw1(dchar[] aa, dg_t dg)
 {
     int result;
 
@@ -255,7 +255,7 @@ extern (D) alias dg2_t = int delegate(void* i, void* c);
 /**
 Variants of _aApplyXXX that include a loop index.
 */
-extern (C) int _aApplycd2(in char[] aa, dg2_t dg)
+extern (C) int _aApplycd2(char[] aa, dg2_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -281,7 +281,7 @@ extern (C) int _aApplycd2(in char[] aa, dg2_t dg)
 }
 
 /// ditto
-extern (C) int _aApplywd2(in wchar[] aa, dg2_t dg)
+extern (C) int _aApplywd2(wchar[] aa, dg2_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -307,7 +307,7 @@ extern (C) int _aApplywd2(in wchar[] aa, dg2_t dg)
 }
 
 /// ditto
-extern (C) int _aApplycw2(in char[] aa, dg2_t dg)
+extern (C) int _aApplycw2(char[] aa, dg2_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -344,7 +344,7 @@ extern (C) int _aApplycw2(in char[] aa, dg2_t dg)
 
 
 /// ditto
-extern (C) int _aApplywc2(in wchar[] aa, dg2_t dg)
+extern (C) int _aApplywc2(wchar[] aa, dg2_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -383,7 +383,7 @@ extern (C) int _aApplywc2(in wchar[] aa, dg2_t dg)
 
 
 /// ditto
-extern (C) int _aApplydc2(in dchar[] aa, dg2_t dg)
+extern (C) int _aApplydc2(dchar[] aa, dg2_t dg)
 {
     int result;
     size_t len = aa.length;
@@ -417,7 +417,7 @@ extern (C) int _aApplydc2(in dchar[] aa, dg2_t dg)
 
 
 /// ditto
-extern (C) int _aApplydw2(in dchar[] aa, dg2_t dg)
+extern (C) int _aApplydw2(dchar[] aa, dg2_t dg)
 {   int result;
 
     debug(apply) printf("_aApplydw2(), len = %d\n", aa.length);

external/arsd-webassembly/core/internal/cast_.d

@@ -0,0 +1,206 @@
+module core.internal.cast_;
+
+// Needed because ClassInfo.opEquals(Object) does a dynamic cast,
+// but we are trying to implement dynamic cast.
+bool areClassInfosEqual(scope const ClassInfo a, scope const ClassInfo b) pure nothrow @safe @nogc
+{
+    // same class if signatures match, works with potential duplicates across binaries
+    if (a is b)
+        return true;
+
+    // new fast way
+    if (a.m_flags & TypeInfo_Class.ClassFlags.hasNameSig)
+        return a.nameSig[0] == b.nameSig[0]
+            && a.nameSig[1] == b.nameSig[1]
+            && a.nameSig[2] == b.nameSig[2]
+            && a.nameSig[3] == b.nameSig[3];
+
+    // old slow way for temporary binary compatibility
+    return a.name == b.name;
+}
+
+
+/*****
+ * Dynamic cast from a class object `o` to class or interface `To`, where `To` is a subtype of `o`.
+ * Params:
+ *      o = instance of class
+ *      To = class or interface that is a subtype of `o`
+ * Returns:
+ *      null if `o` is null or `To` is not a subclass type of `o`. Otherwise, return `o`.
+ */
+private void* _d_dynamic_cast(To)(const return scope Object o) @trusted
+{
+    void* res = null;
+    size_t offset = 0;
+
+    if (o && _d_isbaseof2!To(typeid(o), offset))
+    {
+        res = cast(void*) o + offset;
+    }
+    return res;
+}
+
+/**
+ * Dynamic cast `o` to final class `To` only one level down
+ * Params:
+ *      o = object that is instance of a class
+ *      To = final class that is a subclass type of `o`
+ * Returns:
+ *      o if it succeeds, null if it fails
+ */
+private void* _d_paint_cast(To)(const return scope Object o)
+{
+    /* If o is really an instance of c, just do a paint
+     */
+    auto p = o && cast(void*)(areClassInfosEqual(typeid(o), typeid(To).info)) ? o : null;
+    debug assert(cast(void*)p is cast(void*)_d_dynamic_cast!To(o));
+    return cast(void*)p;
+}
+
+private void* _d_class_cast_impl(const return scope Object o, const ClassInfo c) pure nothrow @safe @nogc
+{
+    if (!o)
+        return null;
+
+    ClassInfo oc = typeid(o);
+    int delta = oc.depth;
+
+    if (delta && c.depth)
+    {
+        delta -= c.depth;
+        if (delta < 0)
+            return null;
+
+        while (delta--)
+            oc = oc.base;
+        if (areClassInfosEqual(oc, c))
+            return cast(void*)o;
+        return null;
+    }
+
+    // no depth data - support the old way
+    do
+    {
+        if (areClassInfosEqual(oc, c))
+            return cast(void*)o;
+        oc = oc.base;
+    } while (oc);
+    return null;
+}
+
+/*****
+ * Dynamic cast from a class object o to class type `To`, where `To` is a subclass type of `o`.
+ * Params:
+ *      o = instance of class
+ *      To = a subclass type of o
+ * Returns:
+ *      null if `o` is null or `To` is not a subclass type of `o`. Otherwise, return `o`.
+ */
+private void* _d_class_cast(To)(const return scope Object o)
+{
+    return _d_class_cast_impl(o, typeid(To));
+}
+
+/*************************************
+ * Attempts to cast interface Object o to class type `To`.
+ * Returns o if successful, null if not.
+ */
+private void* _d_interface_cast(To)(void* p) @trusted
+{
+    if (!p)
+        return null;
+
+    Interface* pi = **cast(Interface***) p;
+
+    Object o2 = cast(Object)(p - pi.offset);
+    void* res = null;
+    size_t offset = 0;
+    if (o2 && _d_isbaseof2!To(typeid(o2), offset))
+    {
+        res = cast(void*) o2 + offset;
+    }
+    return res;
+}
+
+/**
+* Hook that detects the type of cast performed and calls the appropriate function.
+* Params:
+*      o = object that is being casted
+*      To = type to which the object is being casted
+* Returns:
+*      null if the cast fails, otherwise returns the object casted to the type `To`.
+*/
+void* _d_cast(To, From)(From o) @trusted
+{
+    static if (is(From == To))
+    {
+        return *cast(void**) &o;
+    }
+    else static if (is(From == class) && is(To == interface))
+    {
+        return _d_dynamic_cast!To(o);
+    }
+    else static if (is(From == class) && is(To == class))
+    {
+
+        /* Check for:
+        *  class A { }
+        *  final class B : A { }
+        *  ... cast(B) A ...
+        */
+        /* Multiple inheritance is not allowed, so we can safely assume
+         * that the second super can only be an interface.
+         */
+        static if (is(From FromSupers == super) && is(To ToSupers == super) &&
+            __traits(isFinalClass, To) && is(ToSupers[0] == From) &&
+            ToSupers.length == 1 && FromSupers.length <= 1)
+        {
+            return _d_paint_cast!To(o);
+        }
+        else static if (is (To : From))
+        {
+            return _d_class_cast!To(o);
+        }
+        else
+        {
+            return null;
+        }
+    }
+    else static if (is(From == interface))
+    {
+        return _d_interface_cast!To(cast(void*)o);
+    }
+    else
+    {
+        return null;
+    }
+}
+
+private bool _d_isbaseof2(To)(scope ClassInfo oc, scope ref size_t offset)
+{
+    auto c = typeid(To).info;
+
+    if (areClassInfosEqual(oc, c))
+        return true;
+
+    do
+    {
+        if (oc.base && areClassInfosEqual(oc.base, c))
+            return true;
+
+        // Bugzilla 2013: Use depth-first search to calculate offset
+        // from the derived (oc) to the base (c).
+        foreach (iface; oc.interfaces)
+        {
+            if (areClassInfosEqual(iface.classinfo, c) || _d_isbaseof2!To(iface.classinfo, offset))
+            {
+                offset += iface.offset;
+                return true;
+            }
+        }
+
+        oc = oc.base;
+    } while (oc);
+
+    return false;
+}

external/arsd-webassembly/core/internal/lifetime.d

@@ -0,0 +1,31 @@
+module core.internal.lifetime;
+
+void emplaceInitializer(T)(scope ref T chunk) nothrow pure @trusted
+if (!is(T == const) && !is(T == immutable) && !is(T == inout))
+{
+	import core.internal.traits : hasElaborateAssign;
+
+	static if (__traits(isZeroInit, T))
+	{
+		import core.stdc.string : memset;
+		memset(cast(void*) &chunk, 0, T.sizeof);
+	}
+	else static if (__traits(isScalar, T) || T.sizeof <= 16 && !hasElaborateAssign!T && __traits(compiles, (){ T chunk; chunk = T.init; }))
+	{
+		chunk = T.init;
+	}
+	else static if (__traits(isStaticArray, T))
+	{
+		// For static arrays there is no initializer symbol created. Instead, we emplace elements one-by-one.
+		foreach (i; 0 .. T.length)
+		{
+			emplaceInitializer(chunk[i]);
+		}
+	}
+	else
+	{
+		import core.stdc.string : memcpy;
+		const initializer = __traits(initSymbol, T);
+		memcpy(cast(void*)&chunk, initializer.ptr, initializer.length);
+	}
+}

external/arsd-webassembly/core/internal/string.d

@@ -0,0 +1,53 @@
+module core.internal.string;
+
+alias UnsignedStringBuf = char[64];
+
+T[] unsignedToTempString(uint radix = 10, bool upperCase = false, T)(ulong value, return scope T[] buf)
+if (radix >= 2 && radix <= 36 &&
+    (is(T == char) || is(T == wchar) || is(T == dchar)))
+{
+    enum baseChar = upperCase ? 'A' : 'a';
+    size_t i = buf.length;
+
+    static if (size_t.sizeof == 4) // 32 bit CPU
+    {
+        if (value <= uint.max)
+        {
+            // use faster 32 bit arithmetic
+            uint val = cast(uint) value;
+            do
+            {
+                uint x = void;
+                if (val < radix)
+                {
+                    x = cast(uint)val;
+                    val = 0;
+                }
+                else
+                {
+                    x = cast(uint)(val % radix);
+                    val /= radix;
+                }
+                buf[--i] = cast(char)((radix <= 10 || x < 10) ? x + '0' : x - 10 + baseChar);
+            } while (val);
+            return buf[i .. $];
+        }
+    }
+
+    do
+    {
+        uint x = void;
+        if (value < radix)
+        {
+            x = cast(uint)value;
+            value = 0;
+        }
+        else
+        {
+            x = cast(uint)(value % radix);
+            value /= radix;
+        }
+        buf[--i] = cast(char)((radix <= 10 || x < 10) ? x + '0' : x - 10 + baseChar);
+    } while (value);
+    return buf[i .. $];
+}

external/arsd-webassembly/core/lifetime.d

@@ -0,0 +1,73 @@
+module core.lifetime;
+
+void copyEmplace(S, T)(ref S source, ref T target) @system
+    if (is(immutable S == immutable T))
+{
+    import core.internal.traits : BaseElemOf, hasElaborateCopyConstructor, Unconst, Unqual;
+
+    // cannot have the following as simple template constraint due to nested-struct special case...
+    static if (!__traits(compiles, (ref S src) { T tgt = src; }))
+    {
+        alias B = BaseElemOf!T;
+        enum isNestedStruct = is(B == struct) && __traits(isNested, B);
+        static assert(isNestedStruct, "cannot copy-construct " ~ T.stringof ~ " from " ~ S.stringof);
+    }
+
+    void blit()
+    {
+        import core.stdc.string : memcpy;
+        memcpy(cast(Unqual!(T)*) &target, cast(Unqual!(T)*) &source, T.sizeof);
+    }
+
+    static if (is(T == struct))
+    {
+        static if (__traits(hasPostblit, T))
+        {
+            blit();
+            (cast() target).__xpostblit();
+        }
+        else static if (__traits(hasCopyConstructor, T))
+        {
+            // https://issues.dlang.org/show_bug.cgi?id=22766
+            import core.internal.lifetime : emplaceInitializer;
+            emplaceInitializer(*(cast(Unqual!T*)&target));
+            static if (__traits(isNested, T))
+            {
+                 // copy context pointer
+                *(cast(void**) &target.tupleof[$-1]) = cast(void*) source.tupleof[$-1];
+            }
+            target.__ctor(source); // invoke copy ctor
+        }
+        else
+        {
+            blit(); // no opAssign
+        }
+    }
+    else static if (is(T == E[n], E, size_t n))
+    {
+        static if (hasElaborateCopyConstructor!E)
+        {
+            size_t i;
+            try
+            {
+                for (i = 0; i < n; i++)
+                    copyEmplace(source[i], target[i]);
+            }
+            catch (Exception e)
+            {
+                // destroy, in reverse order, what we've constructed so far
+                while (i--)
+                    destroy(*cast(Unconst!(E)*) &target[i]);
+                throw e;
+            }
+        }
+        else // trivial copy
+        {
+            blit(); // all elements at once
+        }
+    }
+    else
+    {
+        *cast(Unconst!(T)*) &target = *cast(Unconst!(T)*) &source;
+    }
+}

external/arsd-webassembly/core/stdc/string.d

@@ -0,0 +1,61 @@
+module core.stdc.string;
+
+pragma(LDC_intrinsic, "llvm.memcpy.p0.p0.i#")
+void llvm_memcpy(T)(void* dst, const(void)* src, T length, bool volatile_ = false) pure @nogc nothrow @trusted
+if(__traits(isIntegral, T));
+
+extern(C) void*
+memcpy(scope return void* dst, scope const(void*) src, ulong length) pure @nogc nothrow @trusted
+{
+	llvm_memcpy!(long)(dst, src, cast(long)length);
+	return dst;
+}
+
+pragma(LDC_intrinsic, "llvm.memset.p0.i#")
+void llvm_memset(T)(void* dst, ubyte value, T length, bool volatile_ = false) pure @nogc nothrow @trusted
+if(__traits(isIntegral, T));
+
+extern(C) void*
+memset(scope return void* s, int c, ulong n) pure nothrow @nogc
+{
+	ubyte value = cast(ubyte)(c & 0xFF);
+	llvm_memset!(long)(s, value, cast(long)n);
+	return s;
+}
+
+extern(C) int memcmp(const(void)* s1, const(void)* s2, size_t n) pure @nogc nothrow @trusted
+{
+	auto b = cast(ubyte*) s1;
+	auto b2 = cast(ubyte*) s2;
+	foreach(i; 0 .. n) {
+		if(auto diff = *b -  *b2)
+			return diff;
+		b++;
+		b2++;
+	}
+	return 0;
+}
+
+extern(C) ulong strlen(scope const(char)* s) pure nothrow @nogc
+{
+	const(char)* a = s;
+	size_t*      w;
+
+	size_t Ones()            => (cast(size_t)-1/ubyte.max);
+	size_t Highs()           => (Ones() * (ubyte.max/2+1));
+	size_t HasZero(size_t x) => ((x)-Ones() & ~(x) & Highs());
+
+	for(; cast(size_t)s % size_t.sizeof; s += 1) 
+	{
+		if(!*s)
+		{
+			return s-a;
+		}
+	}
+
+	for(w = cast(size_t*)s; !HasZero(*w); w += 1) {}
+
+	for(s = cast(char*)w; *s; s += 1) {}
+
+	return s-a;
+}

external/arsd-webassembly/math/package.d

@@ -0,0 +1,10 @@
+module core.math;
+
+pragma(LDC_intrinsic, "llvm.sqrt.f32")
+float llvm_sqrt(float x) pure nothrow @nogc @safe;
+
+pragma(LDC_intrinsic, "llvm.sqrt.f64")
+double llvm_sqrt(double x) pure nothrow @nogc @safe;
+
+float  sqrt(float x )  => x < 0 ? float.nan  : llvm_sqrt(x);
+double sqrt(double x)  => x < 0 ? double.nan : llvm_sqrt(x);

external/arsd-webassembly/std/math/rounding.d

@@ -0,0 +1,8 @@
+module std.math.rounding;
+
+pragma(LDC_intrinsic, "llvm.round.f#")
+T llvm_round(T)(T val)
+if (__traits(isFloating, T));
+
+float  round(float x)  => llvm_round(x);
+double round(double x) => llvm_round(x);

external/cglm/aabb2d.h

@@ -1,270 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_aabb2d_h
-#define cglm_aabb2d_h
-
-#include "common.h"
-#include "vec2.h"
-#include "util.h"
-
-/* DEPRECATED! use _diag */
-#define glm_aabb2d_size(aabb)         glm_aabb2d_diag(aabb)
-
-/*!
- * @brief make [aabb] zero
- *
- * @param[in, out]  aabb aabb
- */
-CGLM_INLINE
-void
-glm_aabb2d_zero(vec2 aabb[2]) {
-  glm_vec2_zero(aabb[0]);
-  glm_vec2_zero(aabb[1]);
-}
-
-/*!
- * @brief copy all members of [aabb] to [dest]
- *
- * @param[in]  aabb source
- * @param[out] dest destination
- */
-CGLM_INLINE
-void
-glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
-  glm_vec2_copy(aabb[0], dest[0]);
-  glm_vec2_copy(aabb[1], dest[1]);
-}
-
-/*!
- * @brief apply transform to Axis-Aligned Bounding aabb
- *
- * @param[in]  aabb  bounding aabb
- * @param[in]  m    transform matrix
- * @param[out] dest transformed bounding aabb
- */
-CGLM_INLINE
-void
-glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
-  vec2 v[2], xa, xb, ya, yb;
-
-  glm_vec2_scale(m[0], aabb[0][0], xa);
-  glm_vec2_scale(m[0], aabb[1][0], xb);
-
-  glm_vec2_scale(m[1], aabb[0][1], ya);
-  glm_vec2_scale(m[1], aabb[1][1], yb);
-
-  /* translation + min(xa, xb) + min(ya, yb) */
-  glm_vec2(m[2], v[0]);
-  glm_vec2_minadd(xa, xb, v[0]);
-  glm_vec2_minadd(ya, yb, v[0]);
-
-  /* translation + max(xa, xb) + max(ya, yb) */
-  glm_vec2(m[2], v[1]);
-  glm_vec2_maxadd(xa, xb, v[1]);
-  glm_vec2_maxadd(ya, yb, v[1]);
-
-  glm_vec2_copy(v[0], dest[0]);
-  glm_vec2_copy(v[1], dest[1]);
-}
-
-/*!
- * @brief merges two AABB bounding aabb and creates new one
- *
- * two aabb must be in same space, if one of aabb is in different space then
- * you should consider to convert it's space by glm_aabb_space
- *
- * @param[in]  aabb1 bounding aabb 1
- * @param[in]  aabb2 bounding aabb 2
- * @param[out] dest merged bounding aabb
- */
-CGLM_INLINE
-void
-glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
-  dest[0][0] = glm_min(aabb1[0][0], aabb2[0][0]);
-  dest[0][1] = glm_min(aabb1[0][1], aabb2[0][1]);
-
-  dest[1][0] = glm_max(aabb1[1][0], aabb2[1][0]);
-  dest[1][1] = glm_max(aabb1[1][1], aabb2[1][1]);
-}
-
-/*!
- * @brief crops a bounding aabb with another one.
- *
- * this could be useful for getting a baabb which fits with view frustum and
- * object bounding aabbes. In this case you crop view frustum aabb with objects
- * aabb
- *
- * @param[in]  aabb     bounding aabb 1
- * @param[in]  cropAabb crop aabb
- * @param[out] dest     cropped bounding aabb
- */
-CGLM_INLINE
-void
-glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
-  dest[0][0] = glm_max(aabb[0][0], cropAabb[0][0]);
-  dest[0][1] = glm_max(aabb[0][1], cropAabb[0][1]);
-
-  dest[1][0] = glm_min(aabb[1][0], cropAabb[1][0]);
-  dest[1][1] = glm_min(aabb[1][1], cropAabb[1][1]);
-}
-
-/*!
- * @brief crops a bounding aabb with another one.
- *
- * this could be useful for getting a baabb which fits with view frustum and
- * object bounding aabbes. In this case you crop view frustum aabb with objects
- * aabb
- *
- * @param[in]  aabb      bounding aabb
- * @param[in]  cropAabb  crop aabb
- * @param[in]  clampAabb minimum aabb
- * @param[out] dest      cropped bounding aabb
- */
-CGLM_INLINE
-void
-glm_aabb2d_crop_until(vec2 aabb[2],
-                      vec2 cropAabb[2],
-                      vec2 clampAabb[2],
-                      vec2 dest[2]) {
-  glm_aabb2d_crop(aabb, cropAabb, dest);
-  glm_aabb2d_merge(clampAabb, dest, dest);
-}
-
-/*!
- * @brief invalidate AABB min and max values
- *
- * @param[in, out]  aabb bounding aabb
- */
-CGLM_INLINE
-void
-glm_aabb2d_invalidate(vec2 aabb[2]) {
-  glm_vec2_fill(aabb[0], FLT_MAX);
-  glm_vec2_fill(aabb[1], -FLT_MAX);
-}
-
-/*!
- * @brief check if AABB is valid or not
- *
- * @param[in]  aabb bounding aabb
- */
-CGLM_INLINE
-bool
-glm_aabb2d_isvalid(vec2 aabb[2]) {
-  return glm_vec2_max(aabb[0]) != FLT_MAX
-         && glm_vec2_min(aabb[1]) != -FLT_MAX;
-}
-
-/*!
- * @brief distance between of min and max
- *
- * @param[in]  aabb bounding aabb
- */
-CGLM_INLINE
-float
-glm_aabb2d_diag(vec2 aabb[2]) {
-  return glm_vec2_distance(aabb[0], aabb[1]);
-}
-
-/*!
- * @brief size of aabb
- *
- * @param[in]  aabb bounding aabb
- * @param[out]  dest size
- */
-CGLM_INLINE
-void
-glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
-  glm_vec2_sub(aabb[1], aabb[0], dest); 
-}
-
-/*!
- * @brief radius of sphere which surrounds AABB
- *
- * @param[in]  aabb bounding aabb
- */
-CGLM_INLINE
-float
-glm_aabb2d_radius(vec2 aabb[2]) {
-  return glm_aabb2d_diag(aabb) * 0.5f;
-}
-
-/*!
- * @brief computes center point of AABB
- *
- * @param[in]   aabb  bounding aabb
- * @param[out]  dest center of bounding aabb
- */
-CGLM_INLINE
-void
-glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
-  glm_vec2_center(aabb[0], aabb[1], dest);
-}
-
-/*!
- * @brief check if two AABB intersects
- *
- * @param[in]   aabb    bounding aabb
- * @param[in]   other  other bounding aabb
- */
-CGLM_INLINE
-bool
-glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
-  return (aabb[0][0] <= other[1][0] && aabb[1][0] >= other[0][0])
-      && (aabb[0][1] <= other[1][1] && aabb[1][1] >= other[0][1]);
-}
-
-/*!
- * @brief check if AABB intersects with a circle
- *
- * Circle Representation in cglm: [center.x, center.y, radii]
- *
- * @param[in]   aabb   solid bounding aabb
- * @param[in]   c      solid circle
- */
-CGLM_INLINE
-bool
-glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
-  float dmin;
-  int   a, b;
-
-  a = (c[0] < aabb[0][0]) + (c[0] > aabb[1][0]);
-  b = (c[1] < aabb[0][1]) + (c[1] > aabb[1][1]);
-
-  dmin  = glm_pow2((c[0] - aabb[!(a - 1)][0]) * (a != 0))
-        + glm_pow2((c[1] - aabb[!(b - 1)][1]) * (b != 0));
-
-  return dmin <= glm_pow2(c[2]);
-}
-
-/*!
- * @brief check if point is inside of AABB
- *
- * @param[in]   aabb    bounding aabb
- * @param[in]   point  point
- */
-CGLM_INLINE
-bool
-glm_aabb2d_point(vec2 aabb[2], vec2 point) {
-  return (point[0] >= aabb[0][0] && point[0] <= aabb[1][0])
-      && (point[1] >= aabb[0][1] && point[1] <= aabb[1][1]);
-}
-
-/*!
- * @brief check if AABB contains other AABB
- *
- * @param[in]   aabb    bounding aabb
- * @param[in]   other  other bounding aabb
- */
-CGLM_INLINE
-bool
-glm_aabb2d_contains(vec2 aabb[2], vec2 other[2]) {
-  return (aabb[0][0] <= other[0][0] && aabb[1][0] >= other[1][0])
-      && (aabb[0][1] <= other[0][1] && aabb[1][1] >= other[1][1]);
-}
-
-#endif /* cglm_aabb2d_h */

external/cglm/affine-mat.h

@@ -1,189 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_mul(mat4 m1, mat4 m2, mat4 dest);
-   CGLM_INLINE void glm_mul_rot(mat4 m1, mat4 m2, mat4 dest);
-   CGLM_INLINE void glm_inv_tr(mat4 mat);
- */
-
-#ifndef cglm_affine_mat_h
-#define cglm_affine_mat_h
-
-#include "common.h"
-#include "mat4.h"
-#include "mat3.h"
-
-#ifdef CGLM_SSE_FP
-#  include "simd/sse2/affine.h"
-#endif
-
-#ifdef CGLM_AVX_FP
-#  include "simd/avx/affine.h"
-#endif
-
-#ifdef CGLM_NEON_FP
-#  include "simd/neon/affine.h"
-#endif
-
-#ifdef CGLM_SIMD_WASM
-#  include "simd/wasm/affine.h"
-#endif
-
-/*!
- * @brief this is similar to glm_mat4_mul but specialized to affine transform
- *
- * Matrix format should be:
- *   R  R  R  X
- *   R  R  R  Y
- *   R  R  R  Z
- *   0  0  0  W
- *
- * this reduces some multiplications. It should be faster than mat4_mul.
- * if you are not sure about matrix format then DON'T use this! use mat4_mul
- *
- * @param[in]   m1    affine matrix 1
- * @param[in]   m2    affine matrix 2
- * @param[out]  dest  result matrix
- */
-CGLM_INLINE
-void
-glm_mul(mat4 m1, mat4 m2, mat4 dest) {
-#if defined(__wasm__) && defined(__wasm_simd128__)
-  glm_mul_wasm(m1, m2, dest);
-#elif defined(__AVX__)
-  glm_mul_avx(m1, m2, dest);
-#elif defined( __SSE__ ) || defined( __SSE2__ )
-  glm_mul_sse2(m1, m2, dest);
-#elif defined(CGLM_NEON_FP)
-  glm_mul_neon(m1, m2, dest);
-#else
-  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
-        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
-        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
-        a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][3],
-
-        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
-        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
-        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2],
-        b30 = m2[3][0], b31 = m2[3][1], b32 = m2[3][2], b33 = m2[3][3];
-
-  dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02;
-  dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02;
-  dest[0][2] = a02 * b00 + a12 * b01 + a22 * b02;
-  dest[0][3] = a03 * b00 + a13 * b01 + a23 * b02;
-
-  dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12;
-  dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12;
-  dest[1][2] = a02 * b10 + a12 * b11 + a22 * b12;
-  dest[1][3] = a03 * b10 + a13 * b11 + a23 * b12;
-
-  dest[2][0] = a00 * b20 + a10 * b21 + a20 * b22;
-  dest[2][1] = a01 * b20 + a11 * b21 + a21 * b22;
-  dest[2][2] = a02 * b20 + a12 * b21 + a22 * b22;
-  dest[2][3] = a03 * b20 + a13 * b21 + a23 * b22;
-
-  dest[3][0] = a00 * b30 + a10 * b31 + a20 * b32 + a30 * b33;
-  dest[3][1] = a01 * b30 + a11 * b31 + a21 * b32 + a31 * b33;
-  dest[3][2] = a02 * b30 + a12 * b31 + a22 * b32 + a32 * b33;
-  dest[3][3] = a03 * b30 + a13 * b31 + a23 * b32 + a33 * b33;
-#endif
-}
-
-/*!
- * @brief this is similar to glm_mat4_mul but specialized to affine transform
- *
- * Right Matrix format should be:
- *   R  R  R  0
- *   R  R  R  0
- *   R  R  R  0
- *   0  0  0  1
- *
- * this reduces some multiplications. It should be faster than mat4_mul.
- * if you are not sure about matrix format then DON'T use this! use mat4_mul
- *
- * @param[in]   m1    affine matrix 1
- * @param[in]   m2    affine matrix 2
- * @param[out]  dest  result matrix
- */
-CGLM_INLINE
-void
-glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
-#if defined(__wasm__) && defined(__wasm_simd128__)
-  glm_mul_rot_wasm(m1, m2, dest);
-#elif defined( __SSE__ ) || defined( __SSE2__ )
-  glm_mul_rot_sse2(m1, m2, dest);
-#elif defined(CGLM_NEON_FP)
-  glm_mul_rot_neon(m1, m2, dest);
-#else
-  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
-        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
-        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
-        a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][3],
-
-        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
-        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
-        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2];
-
-  dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02;
-  dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02;
-  dest[0][2] = a02 * b00 + a12 * b01 + a22 * b02;
-  dest[0][3] = a03 * b00 + a13 * b01 + a23 * b02;
-
-  dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12;
-  dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12;
-  dest[1][2] = a02 * b10 + a12 * b11 + a22 * b12;
-  dest[1][3] = a03 * b10 + a13 * b11 + a23 * b12;
-
-  dest[2][0] = a00 * b20 + a10 * b21 + a20 * b22;
-  dest[2][1] = a01 * b20 + a11 * b21 + a21 * b22;
-  dest[2][2] = a02 * b20 + a12 * b21 + a22 * b22;
-  dest[2][3] = a03 * b20 + a13 * b21 + a23 * b22;
-
-  dest[3][0] = a30;
-  dest[3][1] = a31;
-  dest[3][2] = a32;
-  dest[3][3] = a33;
-#endif
-}
-
-/*!
- * @brief inverse orthonormal rotation + translation matrix (ridig-body)
- *
- * @code
- * X = | R  T |   X' = | R' -R'T |
- *     | 0  1 |        | 0     1 |
- * @endcode
- *
- * @param[in,out]  mat  matrix
- */
-CGLM_INLINE
-void
-glm_inv_tr(mat4 mat) {
-#if defined(__wasm__) && defined(__wasm_simd128__)
-  glm_inv_tr_wasm(mat);
-#elif defined( __SSE__ ) || defined( __SSE2__ )
-  glm_inv_tr_sse2(mat);
-#elif defined(CGLM_NEON_FP)
-  glm_inv_tr_neon(mat);
-#else
-  CGLM_ALIGN_MAT mat3 r;
-  CGLM_ALIGN(8)  vec3 t;
-
-  /* rotate */
-  glm_mat4_pick3t(mat, r);
-  glm_mat4_ins3(r, mat);
-
-  /* translate */
-  glm_mat3_mulv(r, mat[3], t);
-  glm_vec3_negate(t);
-  glm_vec3_copy(t, mat[3]);
-#endif
-}
-
-#endif /* cglm_affine_mat_h */

external/cglm/affine-post.h

@@ -1,247 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_affine_post_h
-#define cglm_affine_post_h
-
-/*
- Functions:
-   CGLM_INLINE void glm_translated_to(mat4 m, vec3 v, mat4 dest);
-   CGLM_INLINE void glm_translated(mat4 m, vec3 v);
-   CGLM_INLINE void glm_translated_x(mat4 m, float to);
-   CGLM_INLINE void glm_translated_y(mat4 m, float to);
-   CGLM_INLINE void glm_translated_z(mat4 m, float to);
-   CGLM_INLINE void glm_rotated_x(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotated_y(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotated_z(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotated(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_spinned(mat4 m, float angle, vec3 axis);
- */
-
-#include "common.h"
-#include "util.h"
-#include "vec3.h"
-#include "vec4.h"
-#include "mat4.h"
-#include "affine-mat.h"
-
-/*!
- * @brief translate existing transform matrix by v vector
- *        and stores result in same matrix
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m  affine transform
- * @param[in]       v  translate vector [x, y, z]
- */
-CGLM_INLINE
-void
-glm_translated(mat4 m, vec3 v) {
-  glm_vec3_add(m[3], v, m[3]);
-}
-
-/*!
- * @brief translate existing transform matrix by v vector
- *        and store result in dest
- *
- * source matrix will remain same
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in]  m    affine transform
- * @param[in]  v    translate vector [x, y, z]
- * @param[out] dest translated matrix
- */
-CGLM_INLINE
-void
-glm_translated_to(mat4 m, vec3 v, mat4 dest) {
-  glm_mat4_copy(m, dest);
-  glm_translated(dest, v);
-}
-
-/*!
- * @brief translate existing transform matrix by x factor
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m  affine transform
- * @param[in]       x  x factor
- */
-CGLM_INLINE
-void
-glm_translated_x(mat4 m, float x) {
-  m[3][0] += x;
-}
-
-/*!
- * @brief translate existing transform matrix by y factor
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m  affine transform
- * @param[in]       y  y factor
- */
-CGLM_INLINE
-void
-glm_translated_y(mat4 m, float y) {
-  m[3][1] += y;
-}
-
-/*!
- * @brief translate existing transform matrix by z factor
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m  affine transform
- * @param[in]       z  z factor
- */
-CGLM_INLINE
-void
-glm_translated_z(mat4 m, float z) {
-  m[3][2] += z;
-}
-
-/*!
- * @brief rotate existing transform matrix around X axis by angle
- *        and store result in dest
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in]   m      affine transform
- * @param[in]   angle  angle (radians)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotated_x(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[1][1] =  c;
-  t[1][2] =  s;
-  t[2][1] = -s;
-  t[2][2] =  c;
-
-  glm_mul_rot(t, m, dest);
-}
-
-/*!
- * @brief rotate existing transform matrix around Y axis by angle
- *        and store result in dest
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in]   m      affine transform
- * @param[in]   angle  angle (radians)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotated_y(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[0][0] =  c;
-  t[0][2] = -s;
-  t[2][0] =  s;
-  t[2][2] =  c;
-
-  glm_mul_rot(t, m, dest);
-}
-
-/*!
- * @brief rotate existing transform matrix around Z axis by angle
- *        and store result in dest
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in]   m      affine transform
- * @param[in]   angle  angle (radians)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotated_z(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[0][0] =  c;
-  t[0][1] =  s;
-  t[1][0] = -s;
-  t[1][1] =  c;
-
-  glm_mul_rot(t, m, dest);
-}
-
-/*!
- * @brief rotate existing transform matrix around given axis by angle
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m      affine transform
- * @param[in]       angle  angle (radians)
- * @param[in]       axis   axis
- */
-CGLM_INLINE
-void
-glm_rotated(mat4 m, float angle, vec3 axis) {
-  CGLM_ALIGN_MAT mat4 rot;
-  glm_rotate_make(rot, angle, axis);
-  glm_mul_rot(rot, m, m);
-}
-
-/*!
- * @brief rotate existing transform
- *        around given axis by angle at given pivot point (rotation center)
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m      affine transform
- * @param[in]       pivot  rotation center
- * @param[in]       angle  angle (radians)
- * @param[in]       axis   axis
- */
-CGLM_INLINE
-void
-glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
-  CGLM_ALIGN(8) vec3 pivotInv;
-
-  glm_vec3_negate_to(pivot, pivotInv);
-
-  glm_translated(m, pivot);
-  glm_rotated(m, angle, axis);
-  glm_translated(m, pivotInv);
-}
-
-/*!
- * @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m      affine transform
- * @param[in]       angle  angle (radians)
- * @param[in]       axis   axis
- */
-CGLM_INLINE
-void
-glm_spinned(mat4 m, float angle, vec3 axis) {
-  CGLM_ALIGN_MAT mat4 rot;
-  glm_rotate_atm(rot, m[3], angle, axis);
-  glm_mat4_mul(rot, m, m);
-}
-
-#endif /* cglm_affine_post_h */

external/cglm/affine-pre.h

@@ -1,304 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_affine_pre_h
-#define cglm_affine_pre_h
-
-/*
- Functions:
-   CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
-   CGLM_INLINE void glm_translate(mat4 m, vec3 v);
-   CGLM_INLINE void glm_translate_x(mat4 m, float to);
-   CGLM_INLINE void glm_translate_y(mat4 m, float to);
-   CGLM_INLINE void glm_translate_z(mat4 m, float to);
-   CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
- */
-
-#include "common.h"
-#include "util.h"
-#include "vec3.h"
-#include "vec4.h"
-#include "mat4.h"
-#include "affine-mat.h"
-
-/*!
- * @brief translate existing transform matrix by v vector
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transform
- * @param[in]       v  translate vector [x, y, z]
- */
-CGLM_INLINE
-void
-glm_translate(mat4 m, vec3 v) {
-#if defined(CGLM_SIMD)
-  glmm_128 m0, m1, m2, m3;
-
-  m0 = glmm_load(m[0]);
-  m1 = glmm_load(m[1]);
-  m2 = glmm_load(m[2]);
-  m3 = glmm_load(m[3]);
-
-  glmm_store(m[3],
-             glmm_fmadd(m0, glmm_set1(v[0]),
-                        glmm_fmadd(m1, glmm_set1(v[1]),
-                                   glmm_fmadd(m2, glmm_set1(v[2]), m3))));
-#else
-  glm_vec4_muladds(m[0], v[0], m[3]);
-  glm_vec4_muladds(m[1], v[1], m[3]);
-  glm_vec4_muladds(m[2], v[2], m[3]);
-#endif
-}
-
-/*!
- * @brief translate existing transform matrix by v vector
- *        and store result in dest
- *
- * source matrix will remain same
- *
- * @param[in]  m    affine transform
- * @param[in]  v    translate vector [x, y, z]
- * @param[out] dest translated matrix
- */
-CGLM_INLINE
-void
-glm_translate_to(mat4 m, vec3 v, mat4 dest) {
-  glm_mat4_copy(m, dest);
-  glm_translate(dest, v);
-}
-
-/*!
- * @brief translate existing transform matrix by x factor
- *
- * @param[in, out]  m  affine transform
- * @param[in]       x  x factor
- */
-CGLM_INLINE
-void
-glm_translate_x(mat4 m, float x) {
-#if defined(CGLM_SIMD)
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[0]), glmm_set1(x), glmm_load(m[3])));
-#else
-  vec4 v1;
-  glm_vec4_scale(m[0], x, v1);
-  glm_vec4_add(v1, m[3], m[3]);
-#endif
-}
-
-/*!
- * @brief translate existing transform matrix by y factor
- *
- * @param[in, out]  m  affine transform
- * @param[in]       y  y factor
- */
-CGLM_INLINE
-void
-glm_translate_y(mat4 m, float y) {
-#if defined(CGLM_SIMD)
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[1]), glmm_set1(y), glmm_load(m[3])));
-#else
-  vec4 v1;
-  glm_vec4_scale(m[1], y, v1);
-  glm_vec4_add(v1, m[3], m[3]);
-#endif
-}
-
-/*!
- * @brief translate existing transform matrix by z factor
- *
- * @param[in, out]  m  affine transform
- * @param[in]       z  z factor
- */
-CGLM_INLINE
-void
-glm_translate_z(mat4 m, float z) {
-#if defined(CGLM_SIMD)
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[2]), glmm_set1(z), glmm_load(m[3])));
-#else
-  vec4 v1;
-  glm_vec4_scale(m[2], z, v1);
-  glm_vec4_add(v1, m[3], m[3]);
-#endif
-}
-
-/*!
- * @brief rotate existing transform matrix around X axis by angle
- *        and store result in dest
- *
- * @param[in]   m      affine transform
- * @param[in]   angle  angle (radians)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotate_x(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[1][1] =  c;
-  t[1][2] =  s;
-  t[2][1] = -s;
-  t[2][2] =  c;
-
-  glm_mul_rot(m, t, dest);
-}
-
-/*!
- * @brief rotate existing transform matrix around Y axis by angle
- *        and store result in dest
- *
- * @param[in]   m      affine transform
- * @param[in]   angle  angle (radians)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotate_y(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[0][0] =  c;
-  t[0][2] = -s;
-  t[2][0] =  s;
-  t[2][2] =  c;
-
-  glm_mul_rot(m, t, dest);
-}
-
-/*!
- * @brief rotate existing transform matrix around Z axis by angle
- *        and store result in dest
- *
- * @param[in]   m      affine transform
- * @param[in]   angle  angle (radians)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotate_z(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[0][0] =  c;
-  t[0][1] =  s;
-  t[1][0] = -s;
-  t[1][1] =  c;
-
-  glm_mul_rot(m, t, dest);
-}
-
-/*!
- * @brief rotate existing transform matrix 
- *        around given axis by angle at ORIGIN (0,0,0)
- *
- *   **❗️IMPORTANT ❗️**
- *
- *   If you need to rotate object around itself e.g. center of object or at
- *   some point [of object] then `glm_rotate_at()` would be better choice to do so.
- *
- *   Even if object's model transform is identity, rotation may not be around
- *   center of object if object does not lay out at ORIGIN perfectly.
- *
- *   Using `glm_rotate_at()` with center of bounding shape ( AABB, Sphere ... )
- *   would be an easy option to rotate around object if object is not at origin.
- *
- *   One another option to rotate around itself at any point is `glm_spin()`
- *   which is perfect if only rotating around model position is desired e.g. not
- *   specific point on model for instance center of geometry or center of mass,
- *   again if geometry is not perfectly centered at origin at identity transform,
- *   rotation may not be around geometry.
- *
- * @param[in, out]  m      affine transform
- * @param[in]       angle  angle (radians)
- * @param[in]       axis   axis
- */
-CGLM_INLINE
-void
-glm_rotate(mat4 m, float angle, vec3 axis) {
-  CGLM_ALIGN_MAT mat4 rot;
-  glm_rotate_make(rot, angle, axis);
-  glm_mul_rot(m, rot, m);
-}
-
-/*!
- * @brief rotate existing transform
- *        around given axis by angle at given pivot point (rotation center)
- *
- * @param[in, out]  m      affine transform
- * @param[in]       pivot  rotation center
- * @param[in]       angle  angle (radians)
- * @param[in]       axis   axis
- */
-CGLM_INLINE
-void
-glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
-  CGLM_ALIGN(8) vec3 pivotInv;
-
-  glm_vec3_negate_to(pivot, pivotInv);
-
-  glm_translate(m, pivot);
-  glm_rotate(m, angle, axis);
-  glm_translate(m, pivotInv);
-}
-
-/*!
- * @brief creates NEW rotation matrix by angle and axis at given point
- *
- * this creates rotation matrix, it assumes you don't have a matrix
- *
- * this should work faster than glm_rotate_at because it reduces
- * one glm_translate.
- *
- * @param[out] m      affine transform
- * @param[in]  pivot  rotation center
- * @param[in]  angle  angle (radians)
- * @param[in]  axis   axis
- */
-CGLM_INLINE
-void
-glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
-  CGLM_ALIGN(8) vec3 pivotInv;
-
-  glm_vec3_negate_to(pivot, pivotInv);
-
-  glm_translate_make(m, pivot);
-  glm_rotate(m, angle, axis);
-  glm_translate(m, pivotInv);
-}
-
-/*!
- * @brief rotate existing transform matrix 
- *        around given axis by angle around self (doesn't affected by position)
- *
- * @param[in, out]  m      affine transform
- * @param[in]       angle  angle (radians)
- * @param[in]       axis   axis
- */
-CGLM_INLINE
-void
-glm_spin(mat4 m, float angle, vec3 axis) {
-  CGLM_ALIGN_MAT mat4 rot;
-  glm_rotate_atm(rot, m[3], angle, axis);
-  glm_mat4_mul(m, rot, m);
-}
-
-#endif /* cglm_affine_pre_h */

external/cglm/affine.h

@@ -1,238 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
-   CGLM_INLINE void glm_translate(mat4 m, vec3 v);
-   CGLM_INLINE void glm_translate_x(mat4 m, float to);
-   CGLM_INLINE void glm_translate_y(mat4 m, float to);
-   CGLM_INLINE void glm_translate_z(mat4 m, float to);
-   CGLM_INLINE void glm_translate_make(mat4 m, vec3 v);
-   CGLM_INLINE void glm_scale_to(mat4 m, vec3 v, mat4 dest);
-   CGLM_INLINE void glm_scale_make(mat4 m, vec3 v);
-   CGLM_INLINE void glm_scale(mat4 m, vec3 v);
-   CGLM_INLINE void glm_scale_uni(mat4 m, float s);
-   CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate_make(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_decompose_scalev(mat4 m, vec3 s);
-   CGLM_INLINE bool glm_uniscaled(mat4 m);
-   CGLM_INLINE void glm_decompose_rs(mat4 m, mat4 r, vec3 s);
-   CGLM_INLINE void glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
- */
-
-#ifndef cglm_affine_h
-#define cglm_affine_h
-
-#include "common.h"
-#include "util.h"
-#include "vec3.h"
-#include "vec4.h"
-#include "mat4.h"
-#include "affine-mat.h"
-
-/*!
- * @brief creates NEW translate transform matrix by v vector
- *
- * @param[out]  m  affine transform
- * @param[in]   v  translate vector [x, y, z]
- */
-CGLM_INLINE
-void
-glm_translate_make(mat4 m, vec3 v) {
-  glm_mat4_identity(m);
-  glm_vec3_copy(v, m[3]);
-}
-
-/*!
- * @brief scale existing transform matrix by v vector
- *        and store result in dest
- *
- * @param[in]  m    affine transform
- * @param[in]  v    scale vector [x, y, z]
- * @param[out] dest scaled matrix
- */
-CGLM_INLINE
-void
-glm_scale_to(mat4 m, vec3 v, mat4 dest) {
-  glm_vec4_scale(m[0], v[0], dest[0]);
-  glm_vec4_scale(m[1], v[1], dest[1]);
-  glm_vec4_scale(m[2], v[2], dest[2]);
-
-  glm_vec4_copy(m[3], dest[3]);
-}
-
-/*!
- * @brief creates NEW scale matrix by v vector
- *
- * @param[out]  m  affine transform
- * @param[in]   v  scale vector [x, y, z]
- */
-CGLM_INLINE
-void
-glm_scale_make(mat4 m, vec3 v) {
-  glm_mat4_identity(m);
-  m[0][0] = v[0];
-  m[1][1] = v[1];
-  m[2][2] = v[2];
-}
-
-/*!
- * @brief scales existing transform matrix by v vector
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transform
- * @param[in]       v  scale vector [x, y, z]
- */
-CGLM_INLINE
-void
-glm_scale(mat4 m, vec3 v) {
-  glm_scale_to(m, v, m);
-}
-
-/*!
- * @brief applies uniform scale to existing transform matrix v = [s, s, s]
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transform
- * @param[in]       s  scale factor
- */
-CGLM_INLINE
-void
-glm_scale_uni(mat4 m, float s) {
-  CGLM_ALIGN(8) vec3 v = { s, s, s };
-  glm_scale_to(m, v, m);
-}
-
-/*!
- * @brief creates NEW rotation matrix by angle and axis
- *
- * axis will be normalized so you don't need to normalize it
- *
- * @param[out] m     affine transform
- * @param[in]  angle angle (radians)
- * @param[in]  axis  axis
- */
-CGLM_INLINE
-void
-glm_rotate_make(mat4 m, float angle, vec3 axis) {
-  CGLM_ALIGN(8) vec3 axisn, v, vs;
-  float c;
-
-  c = cosf(angle);
-
-  glm_vec3_normalize_to(axis, axisn);
-  glm_vec3_scale(axisn, 1.0f - c, v);
-  glm_vec3_scale(axisn, sinf(angle), vs);
-
-  glm_vec3_scale(axisn, v[0], m[0]);
-  glm_vec3_scale(axisn, v[1], m[1]);
-  glm_vec3_scale(axisn, v[2], m[2]);
-
-  m[0][0] += c;       m[1][0] -= vs[2];   m[2][0] += vs[1];
-  m[0][1] += vs[2];   m[1][1] += c;       m[2][1] -= vs[0];
-  m[0][2] -= vs[1];   m[1][2] += vs[0];   m[2][2] += c;
-
-  m[0][3] = m[1][3] = m[2][3] = m[3][0] = m[3][1] = m[3][2] = 0.0f;
-  m[3][3] = 1.0f;
-}
-
-/*!
- * @brief decompose scale vector
- *
- * @param[in]  m  affine transform
- * @param[out] s  scale vector (Sx, Sy, Sz)
- */
-CGLM_INLINE
-void
-glm_decompose_scalev(mat4 m, vec3 s) {
-  s[0] = glm_vec3_norm(m[0]);
-  s[1] = glm_vec3_norm(m[1]);
-  s[2] = glm_vec3_norm(m[2]);
-}
-
-/*!
- * @brief returns true if matrix is uniform scaled. This is helpful for
- *        creating normal matrix.
- *
- * @param[in] m m
- *
- * @return boolean
- */
-CGLM_INLINE
-bool
-glm_uniscaled(mat4 m) {
-  CGLM_ALIGN(8) vec3 s;
-  glm_decompose_scalev(m, s);
-  return glm_vec3_eq_all(s);
-}
-
-/*!
- * @brief decompose rotation matrix (mat4) and scale vector [Sx, Sy, Sz]
- *        DON'T pass projected matrix here
- *
- * @param[in]  m affine transform
- * @param[out] r rotation matrix
- * @param[out] s scale matrix
- */
-CGLM_INLINE
-void
-glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
-  CGLM_ALIGN(16) vec4 t = {0.0f, 0.0f, 0.0f, 1.0f};
-  CGLM_ALIGN(8)  vec3 v;
-
-  glm_vec4_copy(m[0], r[0]);
-  glm_vec4_copy(m[1], r[1]);
-  glm_vec4_copy(m[2], r[2]);
-  glm_vec4_copy(t,    r[3]);
-
-  s[0] = glm_vec3_norm(m[0]);
-  s[1] = glm_vec3_norm(m[1]);
-  s[2] = glm_vec3_norm(m[2]);
-
-  glm_vec4_scale(r[0], 1.0f/s[0], r[0]);
-  glm_vec4_scale(r[1], 1.0f/s[1], r[1]);
-  glm_vec4_scale(r[2], 1.0f/s[2], r[2]);
-
-  /* Note from Apple Open Source (assume that the matrix is orthonormal):
-     check for a coordinate system flip.  If the determinant
-     is -1, then negate the matrix and the scaling factors. */
-  glm_vec3_cross(m[0], m[1], v);
-  if (glm_vec3_dot(v, m[2]) < 0.0f) {
-    glm_vec4_negate(r[0]);
-    glm_vec4_negate(r[1]);
-    glm_vec4_negate(r[2]);
-    glm_vec3_negate(s);
-  }
-}
-
-/*!
- * @brief decompose affine transform, TODO: extract shear factors.
- *        DON'T pass projected matrix here
- *
- * @param[in]  m affine transform
- * @param[out] t translation vector
- * @param[out] r rotation matrix (mat4)
- * @param[out] s scaling vector [X, Y, Z]
- */
-CGLM_INLINE
-void
-glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
-  glm_vec4_copy(m[3], t);
-  glm_decompose_rs(m, r, s);
-}
-
-#include "affine-pre.h"
-#include "affine-post.h"
-
-#endif /* cglm_affine_h */

external/cglm/affine2d-post.h

@@ -1,132 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_affine2d_post_h
-#define cglm_affine2d_post_h
-
-/*
- Functions:
-   CGLM_INLINE void glm_translated2d(mat3 m, vec2 v);
-   CGLM_INLINE void glm_translated2d_x(mat3 m, float to);
-   CGLM_INLINE void glm_translated2d_y(mat3 m, float to);
-   CGLM_INLINE void glm_rotated2d(mat3 m, float angle);
-   CGLM_INLINE void glm_scaled2d(mat3 m, vec2 v);
-   CGLM_INLINE void glm_scaled2d_uni(mat3 m, float s);
- */
-
-#include "vec2.h"
-
-/*!
- * @brief translate existing transform matrix by v vector
- *        and store result in same matrix
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m  affine transform
- * @param[in]       v  translate vector [x, y]
- */
-CGLM_INLINE
-void
-glm_translated2d(mat3 m, vec2 v) {
-  glm_vec2_add(m[2], v, m[2]);
-}
-
-/*!
- * @brief translate existing transform matrix by x factor
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m  affine transform
- * @param[in]       x  x factor
- */
-CGLM_INLINE
-void
-glm_translated2d_x(mat3 m, float x) {
-  m[2][0] += x;
-}
-
-/*!
- * @brief translate existing transform matrix by y factor
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m  affine transform
- * @param[in]       y  y factor
- */
-CGLM_INLINE
-void
-glm_translated2d_y(mat3 m, float y) {
-  m[2][1] += y;
-}
-
-/*!
- * @brief rotate existing transform matrix by angle
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]   m      affine transform
- * @param[in]   angle  angle (radians)
- */
-CGLM_INLINE
-void
-glm_rotated2d(mat3 m, float angle) {
-  float c = cosf(angle),
-        s = sinf(angle),
-
-        m00 = m[0][0], m10 = m[1][0], m20 = m[2][0],
-        m01 = m[0][1], m11 = m[1][1], m21 = m[2][1];
-
-  m[0][0] = c * m00 - s * m01;
-  m[1][0] = c * m10 - s * m11;
-  m[2][0] = c * m20 - s * m21;
-
-  m[0][1] = s * m00 + c * m01;
-  m[1][1] = s * m10 + c * m11;
-  m[2][1] = s * m20 + c * m21;
-}
-
-/*!
- * @brief scale existing 2d transform matrix by v vector
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]   m      affine transform
- * @param[in]   v  scale vector [x, y]
- */
-CGLM_INLINE
-void
-glm_scaled2d(mat3 m, vec2 v) {
-  m[0][0] *= v[0];
-  m[1][0] *= v[0];
-  m[2][0] *= v[0];
-
-  m[0][1] *= v[1];
-  m[1][1] *= v[1];
-  m[2][1] *= v[1];
-}
-
-/*!
- * @brief applies uniform scale to existing 2d transform matrix v = [s, s]
- *
- *  this is POST transform, applies to existing transform as last transform
- *
- * @param[in, out]  m  affine transform
- * @param[in]       s  scale factor
- */
-CGLM_INLINE
-void
-glm_scaled2d_uni(mat3 m, float s) {
-  m[0][0] *= s;
-  m[1][0] *= s;
-  m[2][0] *= s;
-
-  m[0][1] *= s;
-  m[1][1] *= s;
-  m[2][1] *= s;
-}
-
-#endif /* cglm_affine2d_post_h */

external/cglm/affine2d.h

@@ -1,268 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_translate2d(mat3 m, vec2 v)
-   CGLM_INLINE void glm_translate2d_to(mat3 m, vec2 v, mat3 dest)
-   CGLM_INLINE void glm_translate2d_x(mat3 m, float x)
-   CGLM_INLINE void glm_translate2d_y(mat3 m, float y)
-   CGLM_INLINE void glm_translate2d_make(mat3 m, vec2 v)
-   CGLM_INLINE void glm_scale2d_to(mat3 m, vec2 v, mat3 dest)
-   CGLM_INLINE void glm_scale2d_make(mat3 m, vec2 v)
-   CGLM_INLINE void glm_scale2d(mat3 m, vec2 v)
-   CGLM_INLINE void glm_scale2d_uni(mat3 m, float s)
-   CGLM_INLINE void glm_rotate2d_make(mat3 m, float angle)
-   CGLM_INLINE void glm_rotate2d(mat3 m, float angle)
-   CGLM_INLINE void glm_rotate2d_to(mat3 m, float angle, mat3 dest)
- */
-
-#ifndef cglm_affine2d_h
-#define cglm_affine2d_h
-
-#include "common.h"
-#include "util.h"
-#include "vec2.h"
-#include "mat3.h"
-
-/*!
- * @brief translate existing 2d transform matrix by v vector
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transform
- * @param[in]       v  translate vector [x, y]
- */
-CGLM_INLINE
-void
-glm_translate2d(mat3 m, vec2 v) {
-  m[2][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0];
-  m[2][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1];
-  m[2][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2];
-}
-
-/*!
- * @brief translate existing 2d transform matrix by v vector
- *        and store result in dest
- *
- * source matrix will remain same
- *
- * @param[in]  m    affine transform
- * @param[in]  v    translate vector [x, y]
- * @param[out] dest translated matrix
- */
-CGLM_INLINE
-void
-glm_translate2d_to(mat3 m, vec2 v, mat3 dest) {
-  glm_mat3_copy(m, dest);
-  glm_translate2d(dest, v);
-}
-
-/*!
- * @brief translate existing 2d transform matrix by x factor
- *
- * @param[in, out]  m  affine transform
- * @param[in]       x  x factor
- */
-CGLM_INLINE
-void
-glm_translate2d_x(mat3 m, float x) {
-  m[2][0] = m[0][0] * x + m[2][0];
-  m[2][1] = m[0][1] * x + m[2][1];
-  m[2][2] = m[0][2] * x + m[2][2];
-}
-
-/*!
- * @brief translate existing 2d transform matrix by y factor
- *
- * @param[in, out]  m  affine transform
- * @param[in]       y  y factor
- */
-CGLM_INLINE
-void
-glm_translate2d_y(mat3 m, float y) {
-  m[2][0] = m[1][0] * y + m[2][0];
-  m[2][1] = m[1][1] * y + m[2][1];
-  m[2][2] = m[1][2] * y + m[2][2];
-}
-
-/*!
- * @brief creates NEW translate 2d transform matrix by v vector
- *
- * @param[out]  m  affine transform
- * @param[in]   v  translate vector [x, y]
- */
-CGLM_INLINE
-void
-glm_translate2d_make(mat3 m, vec2 v) {
-  glm_mat3_identity(m);
-  m[2][0] = v[0];
-  m[2][1] = v[1];
-}
-
-/*!
- * @brief scale existing 2d transform matrix by v vector
- *        and store result in dest
- *
- * @param[in]  m    affine transform
- * @param[in]  v    scale vector [x, y]
- * @param[out] dest scaled matrix
- */
-CGLM_INLINE
-void
-glm_scale2d_to(mat3 m, vec2 v, mat3 dest) {
-  dest[0][0] = m[0][0] * v[0];
-  dest[0][1] = m[0][1] * v[0];
-  dest[0][2] = m[0][2] * v[0];
-  
-  dest[1][0] = m[1][0] * v[1];
-  dest[1][1] = m[1][1] * v[1];
-  dest[1][2] = m[1][2] * v[1];
-  
-  dest[2][0] = m[2][0];
-  dest[2][1] = m[2][1];
-  dest[2][2] = m[2][2];
-}
-
-/*!
- * @brief creates NEW 2d scale matrix by v vector
- *
- * @param[out]  m  affine transform
- * @param[in]   v  scale vector [x, y]
- */
-CGLM_INLINE
-void
-glm_scale2d_make(mat3 m, vec2 v) {
-  glm_mat3_identity(m);
-  m[0][0] = v[0];
-  m[1][1] = v[1];
-}
-
-/*!
- * @brief scales existing 2d transform matrix by v vector
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transform
- * @param[in]       v  scale vector [x, y]
- */
-CGLM_INLINE
-void
-glm_scale2d(mat3 m, vec2 v) {
-  m[0][0] = m[0][0] * v[0];
-  m[0][1] = m[0][1] * v[0];
-  m[0][2] = m[0][2] * v[0];
-
-  m[1][0] = m[1][0] * v[1];
-  m[1][1] = m[1][1] * v[1];
-  m[1][2] = m[1][2] * v[1];
-}
-
-/*!
- * @brief applies uniform scale to existing 2d transform matrix v = [s, s]
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transform
- * @param[in]       s  scale factor
- */
-CGLM_INLINE
-void
-glm_scale2d_uni(mat3 m, float s) {
-  m[0][0] = m[0][0] * s;
-  m[0][1] = m[0][1] * s;
-  m[0][2] = m[0][2] * s;
-
-  m[1][0] = m[1][0] * s;
-  m[1][1] = m[1][1] * s;
-  m[1][2] = m[1][2] * s;
-}
-
-/*!
- * @brief creates NEW rotation matrix by angle around Z axis
- *
- * @param[out] m     affine transform
- * @param[in]  angle angle (radians)
- */
-CGLM_INLINE
-void
-glm_rotate2d_make(mat3 m, float angle) {
-  float c, s;
-
-  s = sinf(angle);
-  c = cosf(angle);
-  
-  m[0][0] = c;
-  m[0][1] = s;
-  m[0][2] = 0;
-
-  m[1][0] = -s;
-  m[1][1] = c;
-  m[1][2] = 0;
-  
-  m[2][0] = 0.0f;
-  m[2][1] = 0.0f;
-  m[2][2] = 1.0f;
-}
-
-/*!
- * @brief rotate existing 2d transform matrix around Z axis by angle
- *         and store result in same matrix
- *
- * @param[in, out]  m      affine transform
- * @param[in]       angle  angle (radians)
- */
-CGLM_INLINE
-void
-glm_rotate2d(mat3 m, float angle) {
-  float m00 = m[0][0],  m10 = m[1][0],
-        m01 = m[0][1],  m11 = m[1][1],
-        m02 = m[0][2],  m12 = m[1][2];
-  float c, s;
-
-  s = sinf(angle);
-  c = cosf(angle);
-  
-  m[0][0] = m00 * c + m10 * s;
-  m[0][1] = m01 * c + m11 * s;
-  m[0][2] = m02 * c + m12 * s;
-
-  m[1][0] = m00 * -s + m10 * c;
-  m[1][1] = m01 * -s + m11 * c;
-  m[1][2] = m02 * -s + m12 * c;
-}
-
-/*!
- * @brief rotate existing 2d transform matrix around Z axis by angle
- *        and store result in dest
- *
- * @param[in]  m      affine transform
- * @param[in]  angle  angle (radians)
- * @param[out] dest   destination
- */
-CGLM_INLINE
-void
-glm_rotate2d_to(mat3 m, float angle, mat3 dest) {
-  float m00 = m[0][0],  m10 = m[1][0],
-        m01 = m[0][1],  m11 = m[1][1],
-        m02 = m[0][2],  m12 = m[1][2];
-  float c, s;
-
-  s = sinf(angle);
-  c = cosf(angle);
-  
-  dest[0][0] = m00 * c + m10 * s;
-  dest[0][1] = m01 * c + m11 * s;
-  dest[0][2] = m02 * c + m12 * s;
-
-  dest[1][0] = m00 * -s + m10 * c;
-  dest[1][1] = m01 * -s + m11 * c;
-  dest[1][2] = m02 * -s + m12 * c;
-  
-  dest[2][0] = m[2][0];
-  dest[2][1] = m[2][1];
-  dest[2][2] = m[2][2];
-}
-
-#endif /* cglm_affine2d_h */

external/cglm/applesimd.h

@@ -1,136 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_applesimd_h
-#define cglm_applesimd_h
-#if defined(__APPLE__)                                                        \
-    && defined(SIMD_COMPILER_HAS_REQUIRED_FEATURES)                           \
-    && defined(SIMD_BASE)                                                     \
-    && defined(SIMD_TYPES)                                                    \
-    && defined(SIMD_VECTOR_TYPES)
-
-#include "common.h"
-#include "struct.h"
-
-/*!
- * @brief converts mat4 to Apple's simd type simd_float4x4
- * @return simd_float4x4
- */
-CGLM_INLINE
-simd_float4x4
-glm_mat4_applesimd(mat4 m) {
-  simd_float4x4 t;
-
-  t.columns[0][0] = m[0][0];
-  t.columns[0][1] = m[0][1];
-  t.columns[0][2] = m[0][2];
-  t.columns[0][3] = m[0][3];
-
-  t.columns[1][0] = m[1][0];
-  t.columns[1][1] = m[1][1];
-  t.columns[1][2] = m[1][2];
-  t.columns[1][3] = m[1][3];
-
-  t.columns[2][0] = m[2][0];
-  t.columns[2][1] = m[2][1];
-  t.columns[2][2] = m[2][2];
-  t.columns[2][3] = m[2][3];
-
-  t.columns[3][0] = m[3][0];
-  t.columns[3][1] = m[3][1];
-  t.columns[3][2] = m[3][2];
-  t.columns[3][3] = m[3][3];
-
-  return t;
-}
-
-/*!
-* @brief converts mat3 to Apple's simd type simd_float3x3
-* @return simd_float3x3
-*/
-CGLM_INLINE
-simd_float3x3
-glm_mat3_applesimd(mat3 m) {
-  simd_float3x3 t;
-
-  t.columns[0][0] = m[0][0];
-  t.columns[0][1] = m[0][1];
-  t.columns[0][2] = m[0][2];
-
-  t.columns[1][0] = m[1][0];
-  t.columns[1][1] = m[1][1];
-  t.columns[1][2] = m[1][2];
-
-  t.columns[2][0] = m[2][0];
-  t.columns[2][1] = m[2][1];
-  t.columns[2][2] = m[2][2];
-
-  return t;
-}
-
-/*!
-* @brief converts vec4 to Apple's simd type simd_float4
-* @return simd_float4
-*/
-CGLM_INLINE
-simd_float4
-glm_vec4_applesimd(vec4 v) {
-  return (simd_float4){v[0], v[1], v[2], v[3]};
-}
-
-/*!
-* @brief converts vec3 to Apple's simd type simd_float3
-* @return simd_float3
-*/
-CGLM_INLINE
-simd_float3
-glm_vec3_applesimd(vec3 v) {
-  return (simd_float3){v[0], v[1], v[2]};
-}
-
-/*!
- * @brief generic function to convert cglm types to Apple's simd types
- *
- * Example usage:
- *   simd_float4x4 m = applesimd(mat4_value);
- *   simd_float3   v = applesimd(vec3_value);
- *
- * @param x cglm type (mat4, mat3, vec4, vec3)
- * @return corresponding Apple simd type
- */
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
-#  define applesimd(x) _Generic((x),                    \
-                         mat4:  glm_mat4_applesimd,     \
-                         mat3:  glm_mat3_applesimd,     \
-                         vec4:  glm_vec4_applesimd,     \
-                         vec3:  glm_vec3_applesimd      \
-                       )((x))
-#endif
-
-#ifdef cglm_types_struct_h
-CGLM_INLINE simd_float4x4 glms_mat4_(applesimd)(mat4s m) { return glm_mat4_applesimd(m.raw); }
-CGLM_INLINE simd_float3x3 glms_mat3_(applesimd)(mat3s m) { return glm_mat3_applesimd(m.raw); }
-CGLM_INLINE simd_float4   glms_vec4_(applesimd)(vec4s v) { return glm_vec4_applesimd(v.raw); }
-CGLM_INLINE simd_float3   glms_vec3_(applesimd)(vec3s v) { return glm_vec3_applesimd(v.raw); }
-
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
-#  undef applesimd
-#  define applesimd(x) _Generic((x),                       \
-                         mat4:  glm_mat4_applesimd,        \
-                         mat3:  glm_mat3_applesimd,        \
-                         vec4:  glm_vec4_applesimd,        \
-                         vec3:  glm_vec3_applesimd,        \
-                         mat4s: glms_mat4_(applesimd),     \
-                         mat3s: glms_mat3_(applesimd),     \
-                         vec4s: glms_vec4_(applesimd),     \
-                         vec3s: glms_vec3_(applesimd)      \
-                       )((x))
-#endif
-#endif
-
-#endif
-#endif /* cglm_applesimd_h */

external/cglm/bezier.h

@@ -1,154 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_bezier_h
-#define cglm_bezier_h
-
-#include "common.h"
-
-#define GLM_BEZIER_MAT_INIT  {{-1.0f,  3.0f, -3.0f,  1.0f},                   \
-                              { 3.0f, -6.0f,  3.0f,  0.0f},                   \
-                              {-3.0f,  3.0f,  0.0f,  0.0f},                   \
-                              { 1.0f,  0.0f,  0.0f,  0.0f}}
-#define GLM_HERMITE_MAT_INIT {{ 2.0f, -3.0f,  0.0f,  1.0f},                   \
-                              {-2.0f,  3.0f,  0.0f,  0.0f},                   \
-                              { 1.0f, -2.0f,  1.0f,  0.0f},                   \
-                              { 1.0f, -1.0f,  0.0f,  0.0f}}
-/* for C only */
-#define GLM_BEZIER_MAT  ((mat4)GLM_BEZIER_MAT_INIT)
-#define GLM_HERMITE_MAT ((mat4)GLM_HERMITE_MAT_INIT)
-
-#define CGLM_DECASTEL_EPS   1e-9f
-#define CGLM_DECASTEL_MAX   1000
-#define CGLM_DECASTEL_SMALL 1e-20f
-
-/*!
- * @brief cubic bezier interpolation
- *
- * Formula:
- *  B(s) = P0*(1-s)^3 + 3*C0*s*(1-s)^2 + 3*C1*s^2*(1-s) + P1*s^3
- *
- * similar result using matrix:
- *  B(s) = glm_smc(t, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
- *
- * glm_eq(glm_smc(...), glm_bezier(...)) should return TRUE
- *
- * @param[in]  s    parameter between 0 and 1
- * @param[in]  p0   begin point
- * @param[in]  c0   control point 1
- * @param[in]  c1   control point 2
- * @param[in]  p1   end point
- *
- * @return B(s)
- */
-CGLM_INLINE
-float
-glm_bezier(float s, float p0, float c0, float c1, float p1) {
-  float x, xx, ss, xs3, a;
-
-  x   = 1.0f - s;
-  xx  = x * x;
-  ss  = s * s;
-  xs3 = (s - ss) * 3.0f;
-  a   = p0 * xx + c0 * xs3;
-
-  return a + s * (c1 * xs3 + p1 * ss - a);
-}
-
-/*!
- * @brief cubic hermite interpolation
- *
- * Formula:
- *  H(s) = P0*(2*s^3 - 3*s^2 + 1) + T0*(s^3 - 2*s^2 + s)
- *            + P1*(-2*s^3 + 3*s^2) + T1*(s^3 - s^2)
- *
- * similar result using matrix:
- *  H(s) = glm_smc(t, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1})
- *
- * glm_eq(glm_smc(...), glm_hermite(...)) should return TRUE
- *
- * @param[in]  s    parameter between 0 and 1
- * @param[in]  p0   begin point
- * @param[in]  t0   tangent 1
- * @param[in]  t1   tangent 2
- * @param[in]  p1   end point
- *
- * @return H(s)
- */
-CGLM_INLINE
-float
-glm_hermite(float s, float p0, float t0, float t1, float p1) {
-  float ss, d, a, b, c, e, f;
-
-  ss = s  * s;
-  a  = ss + ss;
-  c  = a  + ss;
-  b  = a  * s;
-  d  = s  * ss;
-  f  = d  - ss;
-  e  = b  - c;
-
-  return p0 * (e + 1.0f) + t0 * (f - ss + s) + t1 * f - p1 * e;
-}
-
-/*!
- * @brief iterative way to solve cubic equation
- *
- * @param[in]  prm  parameter between 0 and 1
- * @param[in]  p0   begin point
- * @param[in]  c0   control point 1
- * @param[in]  c1   control point 2
- * @param[in]  p1   end point
- *
- * @return parameter to use in cubic equation
- */
-CGLM_INLINE
-float
-glm_decasteljau(float prm, float p0, float c0, float c1, float p1) {
-  float u, v, a, b, c, d, e, f;
-  int   i;
-
-  if (prm - p0 < CGLM_DECASTEL_SMALL)
-    return 0.0f;
-
-  if (p1 - prm < CGLM_DECASTEL_SMALL)
-    return 1.0f;
-
-  u  = 0.0f;
-  v  = 1.0f;
-
-  for (i = 0; i < CGLM_DECASTEL_MAX; i++) {
-    /* de Casteljau Subdivision */
-    a  = (p0 + c0) * 0.5f;
-    b  = (c0 + c1) * 0.5f;
-    c  = (c1 + p1) * 0.5f;
-    d  = (a  + b)  * 0.5f;
-    e  = (b  + c)  * 0.5f;
-    f  = (d  + e)  * 0.5f; /* this one is on the curve! */
-
-    /* The curve point is close enough to our wanted t */
-    if (fabsf(f - prm) < CGLM_DECASTEL_EPS)
-      return glm_clamp_zo((u  + v) * 0.5f);
-
-    /* dichotomy */
-    if (f < prm) {
-      p0 = f;
-      c0 = e;
-      c1 = c;
-      u  = (u  + v) * 0.5f;
-    } else {
-      c0 = a;
-      c1 = d;
-      p1 = f;
-      v  = (u  + v) * 0.5f;
-    }
-  }
-
-  return glm_clamp_zo((u  + v) * 0.5f);
-}
-
-#endif /* cglm_bezier_h */

external/cglm/box.h

@@ -1,281 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_box_h
-#define cglm_box_h
-
-#include "common.h"
-#include "vec3.h"
-#include "vec4.h"
-#include "util.h"
-
-/*!
- * @brief apply transform to Axis-Aligned Bounding Box
- *
- * @param[in]  box  bounding box
- * @param[in]  m    transform matrix
- * @param[out] dest transformed bounding box
- */
-CGLM_INLINE
-void
-glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
-  vec3 v[2], xa, xb, ya, yb, za, zb;
-
-  glm_vec3_scale(m[0], box[0][0], xa);
-  glm_vec3_scale(m[0], box[1][0], xb);
-
-  glm_vec3_scale(m[1], box[0][1], ya);
-  glm_vec3_scale(m[1], box[1][1], yb);
-
-  glm_vec3_scale(m[2], box[0][2], za);
-  glm_vec3_scale(m[2], box[1][2], zb);
-
-  /* translation + min(xa, xb) + min(ya, yb) + min(za, zb) */
-  glm_vec3(m[3], v[0]);
-  glm_vec3_minadd(xa, xb, v[0]);
-  glm_vec3_minadd(ya, yb, v[0]);
-  glm_vec3_minadd(za, zb, v[0]);
-
-  /* translation + max(xa, xb) + max(ya, yb) + max(za, zb) */
-  glm_vec3(m[3], v[1]);
-  glm_vec3_maxadd(xa, xb, v[1]);
-  glm_vec3_maxadd(ya, yb, v[1]);
-  glm_vec3_maxadd(za, zb, v[1]);
-
-  glm_vec3_copy(v[0], dest[0]);
-  glm_vec3_copy(v[1], dest[1]);
-}
-
-/*!
- * @brief merges two AABB bounding box and creates new one
- *
- * two box must be in same space, if one of box is in different space then
- * you should consider to convert it's space by glm_box_space
- *
- * @param[in]  box1 bounding box 1
- * @param[in]  box2 bounding box 2
- * @param[out] dest merged bounding box
- */
-CGLM_INLINE
-void
-glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
-  dest[0][0] = glm_min(box1[0][0], box2[0][0]);
-  dest[0][1] = glm_min(box1[0][1], box2[0][1]);
-  dest[0][2] = glm_min(box1[0][2], box2[0][2]);
-
-  dest[1][0] = glm_max(box1[1][0], box2[1][0]);
-  dest[1][1] = glm_max(box1[1][1], box2[1][1]);
-  dest[1][2] = glm_max(box1[1][2], box2[1][2]);
-}
-
-/*!
- * @brief crops a bounding box with another one.
- *
- * this could be useful for getting a bbox which fits with view frustum and
- * object bounding boxes. In this case you crop view frustum box with objects
- * box
- *
- * @param[in]  box     bounding box 1
- * @param[in]  cropBox crop box
- * @param[out] dest    cropped bounding box
- */
-CGLM_INLINE
-void
-glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
-  dest[0][0] = glm_max(box[0][0], cropBox[0][0]);
-  dest[0][1] = glm_max(box[0][1], cropBox[0][1]);
-  dest[0][2] = glm_max(box[0][2], cropBox[0][2]);
-
-  dest[1][0] = glm_min(box[1][0], cropBox[1][0]);
-  dest[1][1] = glm_min(box[1][1], cropBox[1][1]);
-  dest[1][2] = glm_min(box[1][2], cropBox[1][2]);
-}
-
-/*!
- * @brief crops a bounding box with another one.
- *
- * this could be useful for getting a bbox which fits with view frustum and
- * object bounding boxes. In this case you crop view frustum box with objects
- * box
- *
- * @param[in]  box      bounding box
- * @param[in]  cropBox  crop box
- * @param[in]  clampBox minimum box
- * @param[out] dest     cropped bounding box
- */
-CGLM_INLINE
-void
-glm_aabb_crop_until(vec3 box[2],
-                    vec3 cropBox[2],
-                    vec3 clampBox[2],
-                    vec3 dest[2]) {
-  glm_aabb_crop(box, cropBox, dest);
-  glm_aabb_merge(clampBox, dest, dest);
-}
-
-/*!
- * @brief check if AABB intersects with frustum planes
- *
- * this could be useful for frustum culling using AABB.
- *
- * OPTIMIZATION HINT:
- *  if planes order is similar to LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR
- *  then this method should run even faster because it would only use two
- *  planes if object is not inside the two planes
- *  fortunately cglm extracts planes as this order! just pass what you got!
- *
- * @param[in]  box     bounding box
- * @param[in]  planes  frustum planes
- */
-CGLM_INLINE
-bool
-glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
-  float *p, dp;
-  int    i;
-
-  for (i = 0; i < 6; i++) {
-    p  = planes[i];
-    dp = p[0] * box[p[0] > 0.0f][0]
-       + p[1] * box[p[1] > 0.0f][1]
-       + p[2] * box[p[2] > 0.0f][2];
-
-    if (dp < -p[3])
-      return false;
-  }
-
-  return true;
-}
-
-/*!
- * @brief invalidate AABB min and max values
- *
- * @param[in, out]  box bounding box
- */
-CGLM_INLINE
-void
-glm_aabb_invalidate(vec3 box[2]) {
-  glm_vec3_broadcast(FLT_MAX,  box[0]);
-  glm_vec3_broadcast(-FLT_MAX, box[1]);
-}
-
-/*!
- * @brief check if AABB is valid or not
- *
- * @param[in]  box bounding box
- */
-CGLM_INLINE
-bool
-glm_aabb_isvalid(vec3 box[2]) {
-  return glm_vec3_max(box[0]) != FLT_MAX
-         && glm_vec3_min(box[1]) != -FLT_MAX;
-}
-
-/*!
- * @brief distance between of min and max
- *
- * @param[in]  box bounding box
- */
-CGLM_INLINE
-float
-glm_aabb_size(vec3 box[2]) {
-  return glm_vec3_distance(box[0], box[1]);
-}
-
-/*!
- * @brief radius of sphere which surrounds AABB
- *
- * @param[in]  box bounding box
- */
-CGLM_INLINE
-float
-glm_aabb_radius(vec3 box[2]) {
-  return glm_aabb_size(box) * 0.5f;
-}
-
-/*!
- * @brief computes center point of AABB
- *
- * @param[in]   box  bounding box
- * @param[out]  dest center of bounding box
- */
-CGLM_INLINE
-void
-glm_aabb_center(vec3 box[2], vec3 dest) {
-  glm_vec3_center(box[0], box[1], dest);
-}
-
-/*!
- * @brief check if two AABB intersects
- *
- * @param[in]   box    bounding box
- * @param[in]   other  other bounding box
- */
-CGLM_INLINE
-bool
-glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
-  return (box[0][0] <= other[1][0] && box[1][0] >= other[0][0])
-      && (box[0][1] <= other[1][1] && box[1][1] >= other[0][1])
-      && (box[0][2] <= other[1][2] && box[1][2] >= other[0][2]);
-}
-
-/*!
- * @brief check if AABB intersects with sphere
- *
- * https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
- * Solid Box - Solid Sphere test.
- *
- * Sphere Representation in cglm: [center.x, center.y, center.z, radii]
- *
- * @param[in]   box    solid bounding box
- * @param[in]   s      solid sphere
- */
-CGLM_INLINE
-bool
-glm_aabb_sphere(vec3 box[2], vec4 s) {
-  float dmin;
-  int   a, b, c;
-
-  a = (s[0] < box[0][0]) + (s[0] > box[1][0]);
-  b = (s[1] < box[0][1]) + (s[1] > box[1][1]);
-  c = (s[2] < box[0][2]) + (s[2] > box[1][2]);
-
-  dmin  = glm_pow2((s[0] - box[!(a - 1)][0]) * (a != 0))
-        + glm_pow2((s[1] - box[!(b - 1)][1]) * (b != 0))
-        + glm_pow2((s[2] - box[!(c - 1)][2]) * (c != 0));
-
-  return dmin <= glm_pow2(s[3]);
-}
-
-/*!
- * @brief check if point is inside of AABB
- *
- * @param[in]   box    bounding box
- * @param[in]   point  point
- */
-CGLM_INLINE
-bool
-glm_aabb_point(vec3 box[2], vec3 point) {
-  return (point[0] >= box[0][0] && point[0] <= box[1][0])
-      && (point[1] >= box[0][1] && point[1] <= box[1][1])
-      && (point[2] >= box[0][2] && point[2] <= box[1][2]);
-}
-
-/*!
- * @brief check if AABB contains other AABB
- *
- * @param[in]   box    bounding box
- * @param[in]   other  other bounding box
- */
-CGLM_INLINE
-bool
-glm_aabb_contains(vec3 box[2], vec3 other[2]) {
-  return (box[0][0] <= other[0][0] && box[1][0] >= other[1][0])
-      && (box[0][1] <= other[0][1] && box[1][1] >= other[1][1])
-      && (box[0][2] <= other[0][2] && box[1][2] >= other[1][2]);
-}
-
-#endif /* cglm_box_h */

external/cglm/call.h

@@ -1,51 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_call_h
-#define cglm_call_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "cglm.h"
-#include "call/vec2.h"
-#include "call/vec3.h"
-#include "call/vec4.h"
-#include "call/ivec2.h"
-#include "call/ivec3.h"
-#include "call/ivec4.h"
-#include "call/mat2.h"
-#include "call/mat2x3.h"
-#include "call/mat2x4.h"
-#include "call/mat3.h"
-#include "call/mat3x2.h"
-#include "call/mat3x4.h"
-#include "call/mat4.h"
-#include "call/mat4x2.h"
-#include "call/mat4x3.h"
-#include "call/affine.h"
-#include "call/cam.h"
-#include "call/quat.h"
-#include "call/euler.h"
-#include "call/plane.h"
-#include "call/noise.h"
-#include "call/frustum.h"
-#include "call/aabb2d.h"
-#include "call/box.h"
-#include "call/io.h"
-#include "call/project.h"
-#include "call/sphere.h"
-#include "call/ease.h"
-#include "call/curve.h"
-#include "call/bezier.h"
-#include "call/ray.h"
-#include "call/affine2d.h"
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglm_call_h */

external/cglm/call/aabb2d.h

@@ -1,89 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_aabb2d_h
-#define cglmc_aabb2d_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-/* DEPRECATED! use _diag */
-#define glmc_aabb2d_size(aabb) glmc_aabb2d_diag(aabb)
-
-CGLM_EXPORT
-void
-glmc_aabb2d_zero(vec2 aabb[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb2d_copy(vec2 aabb[2], vec2 dest[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb2d_crop_until(vec2 aabb[2],
-                     vec2 cropAabb[2],
-                     vec2 clampAabb[2],
-                     vec2 dest[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb2d_invalidate(vec2 aabb[2]);
-
-CGLM_EXPORT
-bool
-glmc_aabb2d_isvalid(vec2 aabb[2]);
-
-CGLM_EXPORT
-float
-glmc_aabb2d_diag(vec2 aabb[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb2d_sizev(vec2 aabb[2], vec2 dest);
-
-CGLM_EXPORT
-float
-glmc_aabb2d_radius(vec2 aabb[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb2d_center(vec2 aabb[2], vec2 dest);
-
-CGLM_EXPORT
-bool
-glmc_aabb2d_aabb(vec2 aabb[2], vec2 other[2]);
-
-CGLM_EXPORT
-bool
-glmc_aabb2d_point(vec2 aabb[2], vec2 point);
-
-CGLM_EXPORT
-bool
-glmc_aabb2d_contains(vec2 aabb[2], vec2 other[2]);
-
-CGLM_EXPORT
-bool
-glmc_aabb2d_circle(vec2 aabb[2], vec3 s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_aabb2d_h */

external/cglm/call/affine.h

@@ -1,167 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_affine_h
-#define cglmc_affine_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_translate_make(mat4 m, vec3 v);
-
-CGLM_EXPORT
-void
-glmc_translate_to(mat4 m, vec3 v, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_translate(mat4 m, vec3 v);
-
-CGLM_EXPORT
-void
-glmc_translate_x(mat4 m, float to);
-
-CGLM_EXPORT
-void
-glmc_translate_y(mat4 m, float to);
-
-CGLM_EXPORT
-void
-glmc_translate_z(mat4 m, float to);
-
-CGLM_EXPORT
-void
-glmc_scale_make(mat4 m, vec3 v);
-
-CGLM_EXPORT
-void
-glmc_scale_to(mat4 m, vec3 v, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_scale(mat4 m, vec3 v);
-
-CGLM_EXPORT
-void
-glmc_scale_uni(mat4 m, float s);
-
-CGLM_EXPORT
-void
-glmc_rotate_x(mat4 m, float rad, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_rotate_y(mat4 m, float rad, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_rotate_z(mat4 m, float rad, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_rotate_make(mat4 m, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_rotate(mat4 m, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_spin(mat4 m, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_decompose_scalev(mat4 m, vec3 s);
-
-CGLM_EXPORT
-bool
-glmc_uniscaled(mat4 m);
-
-CGLM_EXPORT
-void
-glmc_decompose_rs(mat4 m, mat4 r, vec3 s);
-
-CGLM_EXPORT
-void
-glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
-
-/* affine-post */
-
-CGLM_EXPORT
-void
-glmc_translated(mat4 m, vec3 v);
-
-CGLM_EXPORT
-void
-glmc_translated_to(mat4 m, vec3 v, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_translated_x(mat4 m, float x);
-
-CGLM_EXPORT
-void
-glmc_translated_y(mat4 m, float y);
-
-CGLM_EXPORT
-void
-glmc_translated_z(mat4 m, float z);
-
-CGLM_EXPORT
-void
-glmc_rotated_x(mat4 m, float angle, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_rotated_y(mat4 m, float angle, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_rotated_z(mat4 m, float angle, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_rotated(mat4 m, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_spinned(mat4 m, float angle, vec3 axis);
-
-/* affine-mat */
-
-CGLM_EXPORT
-void
-glmc_mul(mat4 m1, mat4 m2, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_inv_tr(mat4 mat);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_affine_h */

external/cglm/call/affine2d.h

@@ -1,67 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_affine2d_h
-#define cglmc_affine2d_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_translate2d_make(mat3 m, vec2 v);
-
-CGLM_EXPORT
-void
-glmc_translate2d_to(mat3 m, vec2 v, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_translate2d(mat3 m, vec2 v);
-
-CGLM_EXPORT
-void
-glmc_translate2d_x(mat3 m, float to);
-
-CGLM_EXPORT
-void
-glmc_translate2d_y(mat3 m, float to);
-
-CGLM_EXPORT
-void
-glmc_scale2d_to(mat3 m, vec2 v, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_scale2d_make(mat3 m, vec2 v);
-
-CGLM_EXPORT
-void
-glmc_scale2d(mat3 m, vec2 v);
-
-CGLM_EXPORT
-void
-glmc_scale2d_uni(mat3 m, float s);
-
-CGLM_EXPORT
-void
-glmc_rotate2d_make(mat3 m, float angle);
-
-CGLM_EXPORT
-void
-glmc_rotate2d(mat3 m, float angle);
-
-CGLM_EXPORT
-void
-glmc_rotate2d_to(mat3 m, float angle, mat3 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_affine2d_h */

external/cglm/call/bezier.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_bezier_h
-#define cglmc_bezier_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-float
-glmc_bezier(float s, float p0, float c0, float c1, float p1);
-
-CGLM_EXPORT
-float
-glmc_hermite(float s, float p0, float t0, float t1, float p1);
-
-CGLM_EXPORT
-float
-glmc_decasteljau(float prm, float p0, float c0, float c1, float p1);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_bezier_h */

external/cglm/call/box.h

@@ -1,78 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_box_h
-#define cglmc_box_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb_crop_until(vec3 box[2],
-                     vec3 cropBox[2],
-                     vec3 clampBox[2],
-                     vec3 dest[2]);
-
-CGLM_EXPORT
-bool
-glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
-
-CGLM_EXPORT
-void
-glmc_aabb_invalidate(vec3 box[2]);
-
-CGLM_EXPORT
-bool
-glmc_aabb_isvalid(vec3 box[2]);
-
-CGLM_EXPORT
-float
-glmc_aabb_size(vec3 box[2]);
-
-CGLM_EXPORT
-float
-glmc_aabb_radius(vec3 box[2]);
-
-CGLM_EXPORT
-void
-glmc_aabb_center(vec3 box[2], vec3 dest);
-
-CGLM_EXPORT
-bool
-glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
-
-CGLM_EXPORT
-bool
-glmc_aabb_point(vec3 box[2], vec3 point);
-
-CGLM_EXPORT
-bool
-glmc_aabb_contains(vec3 box[2], vec3 other[2]);
-
-CGLM_EXPORT
-bool
-glmc_aabb_sphere(vec3 box[2], vec4 s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_box_h */

external/cglm/call/cam.h

@@ -1,133 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_cam_h
-#define cglmc_cam_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_frustum(float left,   float right,
-             float bottom, float top,
-             float nearZ,  float farZ,
-             mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_ortho(float left,   float right,
-           float bottom, float top,
-           float nearZ,  float farZ,
-           mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb(vec3 box[2], mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default(float aspect, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_s(float aspect, float size, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_persp_move_far(mat4 proj, float deltaFar);
-
-CGLM_EXPORT
-void
-glmc_perspective_default(float aspect, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_perspective_resize(float aspect, mat4 proj);
-
-CGLM_EXPORT
-void
-glmc_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look(vec3 eye, vec3 dir, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp(mat4 proj,
-                  float * __restrict nearZ,
-                  float * __restrict farZ,
-                  float * __restrict top,
-                  float * __restrict bottom,
-                  float * __restrict left,
-                  float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decompv(mat4 proj, float dest[6]);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_x(mat4 proj,
-                    float * __restrict left,
-                    float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_y(mat4 proj,
-                    float * __restrict top,
-                    float * __restrict bottom);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_z(mat4 proj,
-                    float * __restrict nearZ,
-                    float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_far(mat4 proj, float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_near(mat4 proj, float * __restrict nearZ);
-
-CGLM_EXPORT
-float
-glmc_persp_fovy(mat4 proj);
-
-CGLM_EXPORT
-float
-glmc_persp_aspect(mat4 proj);
-
-CGLM_EXPORT
-void
-glmc_persp_sizes(mat4 proj, float fovy, vec4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_cam_h */

external/cglm/call/clipspace/ortho_lh_no.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ortho_lh_no_h
-#define cglmc_ortho_lh_no_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_ortho_lh_no(float left,    float right,
-                 float bottom,  float top,
-                 float nearZ,   float farZ,
-                 mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_lh_no(vec3 box[2], mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_lh_no(float aspect, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_s_lh_no(float aspect, float size, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ortho_lh_no_h */

external/cglm/call/clipspace/ortho_lh_zo.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ortho_lh_zo_h
-#define cglmc_ortho_lh_zo_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_ortho_lh_zo(float left,    float right,
-                 float bottom,  float top,
-                 float nearZ,   float farZ,
-                 mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_lh_zo(vec3 box[2], mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_lh_zo(float aspect, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_s_lh_zo(float aspect, float size, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ortho_lh_zo_h */

external/cglm/call/clipspace/ortho_rh_no.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ortho_rh_no_h
-#define cglmc_ortho_rh_no_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_ortho_rh_no(float left,    float right,
-                 float bottom,  float top,
-                 float nearZ,   float farZ,
-                 mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_rh_no(vec3 box[2], mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_rh_no(float aspect, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_s_rh_no(float aspect, float size, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ortho_rh_no_h */

external/cglm/call/clipspace/ortho_rh_zo.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ortho_rh_zo_h
-#define cglmc_ortho_rh_zo_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_ortho_rh_zo(float left,    float right,
-                 float bottom,  float top,
-                 float nearZ,   float farZ,
-                 mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_rh_zo(vec3 box[2], mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_rh_zo(float aspect, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_ortho_default_s_rh_zo(float aspect, float size, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ortho_rh_zo_h */

external/cglm/call/clipspace/persp_lh_no.h

@@ -1,87 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_persp_lh_no_h
-#define cglmc_persp_lh_no_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_frustum_lh_no(float left,    float right,
-                   float bottom,  float top,
-                   float nearZ,   float farZ,
-                   mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_perspective_lh_no(float fovy,
-                       float aspect,
-                       float nearVal,
-                       float farVal,
-                       mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_persp_move_far_lh_no(mat4 proj, float deltaFar);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_lh_no(mat4 proj,
-                        float * __restrict nearZ, float * __restrict farZ,
-                        float * __restrict top,   float * __restrict bottom,
-                        float * __restrict left,  float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decompv_lh_no(mat4 proj, float dest[6]);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_x_lh_no(mat4 proj,
-                          float * __restrict left,
-                          float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_y_lh_no(mat4 proj,
-                          float * __restrict top,
-                          float * __restrict bottom);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_z_lh_no(mat4 proj,
-                          float * __restrict nearZ,
-                          float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ);
-
-CGLM_EXPORT
-void
-glmc_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest);
-
-CGLM_EXPORT
-float
-glmc_persp_fovy_lh_no(mat4 proj);
-
-CGLM_EXPORT
-float
-glmc_persp_aspect_lh_no(mat4 proj);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_persp_lh_no_h */

external/cglm/call/clipspace/persp_lh_zo.h

@@ -1,87 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_persp_lh_zo_h
-#define cglmc_persp_lh_zo_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_frustum_lh_zo(float left,    float right,
-                   float bottom,  float top,
-                   float nearZ,   float farZ,
-                   mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_perspective_lh_zo(float fovy,
-                       float aspect,
-                       float nearVal,
-                       float farVal,
-                       mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_persp_move_far_lh_zo(mat4 proj, float deltaFar);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_lh_zo(mat4 proj,
-                        float * __restrict nearZ, float * __restrict farZ,
-                        float * __restrict top,   float * __restrict bottom,
-                        float * __restrict left,  float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decompv_lh_zo(mat4 proj, float dest[6]);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_x_lh_zo(mat4 proj,
-                          float * __restrict left,
-                          float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_y_lh_zo(mat4 proj,
-                          float * __restrict top,
-                          float * __restrict bottom);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_z_lh_zo(mat4 proj,
-                          float * __restrict nearZ,
-                          float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ);
-
-CGLM_EXPORT
-void
-glmc_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest);
-
-CGLM_EXPORT
-float
-glmc_persp_fovy_lh_zo(mat4 proj);
-
-CGLM_EXPORT
-float
-glmc_persp_aspect_lh_zo(mat4 proj);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_persp_lh_zo_h */

external/cglm/call/clipspace/persp_rh_no.h

@@ -1,87 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_persp_rh_no_h
-#define cglmc_persp_rh_no_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_frustum_rh_no(float left,    float right,
-                   float bottom,  float top,
-                   float nearZ,   float farZ,
-                   mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_perspective_rh_no(float fovy,
-                       float aspect,
-                       float nearVal,
-                       float farVal,
-                       mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_persp_move_far_rh_no(mat4 proj, float deltaFar);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_rh_no(mat4 proj,
-                        float * __restrict nearZ, float * __restrict farZ,
-                        float * __restrict top,   float * __restrict bottom,
-                        float * __restrict left,  float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decompv_rh_no(mat4 proj, float dest[6]);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_x_rh_no(mat4 proj,
-                          float * __restrict left,
-                          float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_y_rh_no(mat4 proj,
-                          float * __restrict top,
-                          float * __restrict bottom);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_z_rh_no(mat4 proj,
-                          float * __restrict nearZ,
-                          float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ);
-
-CGLM_EXPORT
-void
-glmc_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest);
-
-CGLM_EXPORT
-float
-glmc_persp_fovy_rh_no(mat4 proj);
-
-CGLM_EXPORT
-float
-glmc_persp_aspect_rh_no(mat4 proj);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_persp_rh_no_h */

external/cglm/call/clipspace/persp_rh_zo.h

@@ -1,87 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_persp_rh_zo_h
-#define cglmc_persp_rh_zo_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_frustum_rh_zo(float left,    float right,
-                   float bottom,  float top,
-                   float nearZ,   float farZ,
-                   mat4  dest);
-
-CGLM_EXPORT
-void
-glmc_perspective_rh_zo(float fovy,
-                       float aspect,
-                       float nearVal,
-                       float farVal,
-                       mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_persp_move_far_rh_zo(mat4 proj, float deltaFar);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_rh_zo(mat4 proj,
-                        float * __restrict nearZ, float * __restrict farZ,
-                        float * __restrict top,   float * __restrict bottom,
-                        float * __restrict left,  float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decompv_rh_zo(mat4 proj, float dest[6]);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_x_rh_zo(mat4 proj,
-                          float * __restrict left,
-                          float * __restrict right);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_y_rh_zo(mat4 proj,
-                          float * __restrict top,
-                          float * __restrict bottom);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_z_rh_zo(mat4 proj,
-                          float * __restrict nearZ,
-                          float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ);
-
-CGLM_EXPORT
-void
-glmc_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ);
-
-CGLM_EXPORT
-void
-glmc_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest);
-
-CGLM_EXPORT
-float
-glmc_persp_fovy_rh_zo(mat4 proj);
-
-CGLM_EXPORT
-float
-glmc_persp_aspect_rh_zo(mat4 proj);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_persp_rh_zo_h */

external/cglm/call/clipspace/project_no.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_project_no_h
-#define cglmc_project_no_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_project_z_no(vec3 pos, mat4 m);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_project_no_h */

external/cglm/call/clipspace/project_zo.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_project_zo_h
-#define cglmc_project_zo_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_project_z_zo(vec3 pos, mat4 m);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_project_zo_h */

external/cglm/call/clipspace/view_lh_no.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_view_lh_no_h
-#define cglmc_view_lh_no_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_view_lh_no_h */

external/cglm/call/clipspace/view_lh_zo.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_view_lh_zo_h
-#define cglmc_view_lh_zo_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_view_lh_zo_h */

external/cglm/call/clipspace/view_rh_no.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_view_rh_no_h
-#define cglmc_view_rh_no_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_view_rh_no_h */

external/cglm/call/clipspace/view_rh_zo.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_view_rh_zo_h
-#define cglmc_view_rh_zo_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_view_rh_zo_h */

external/cglm/call/curve.h

@@ -1,23 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_curve_h
-#define cglmc_curve_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-float
-glmc_smc(float s, mat4 m, vec4 c);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_curve_h */

external/cglm/call/ease.h

@@ -1,143 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ease_h
-#define cglmc_ease_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-float
-glmc_ease_linear(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_sine_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_sine_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_sine_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quad_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quad_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quad_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_cubic_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_cubic_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_cubic_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quart_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quart_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quart_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quint_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quint_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_quint_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_exp_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_exp_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_exp_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_circ_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_circ_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_circ_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_back_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_back_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_back_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_elast_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_elast_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_elast_inout(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_bounce_out(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_bounce_in(float t);
-
-CGLM_EXPORT
-float
-glmc_ease_bounce_inout(float t);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ease_h */

external/cglm/call/euler.h

@@ -1,80 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_euler_h
-#define cglmc_euler_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_euler_angles(mat4 m, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_euler(vec3 angles, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_euler_xyz(vec3 angles,  mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_euler_zyx(vec3 angles,  mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_euler_zxy(vec3 angles, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_euler_xzy(vec3 angles, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_euler_yzx(vec3 angles, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_euler_yxz(vec3 angles, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_euler_by_order(vec3 angles, glm_euler_seq axis, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_euler_xyz_quat(vec3 angles, versor dest);
-
-CGLM_EXPORT
-void
-glmc_euler_xzy_quat(vec3 angles, versor dest);
-
-CGLM_EXPORT
-void
-glmc_euler_yxz_quat(vec3 angles, versor dest);
-
-CGLM_EXPORT
-void
-glmc_euler_yzx_quat(vec3 angles, versor dest);
-
-CGLM_EXPORT
-void
-glmc_euler_zxy_quat(vec3 angles, versor dest);
-
-CGLM_EXPORT
-void
-glmc_euler_zyx_quat(vec3 angles, versor dest);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_euler_h */

external/cglm/call/frustum.h

@@ -1,41 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_frustum_h
-#define cglmc_frustum_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_frustum_planes(mat4 m, vec4 dest[6]);
-
-CGLM_EXPORT
-void
-glmc_frustum_corners(mat4 invMat, vec4 dest[8]);
-
-CGLM_EXPORT
-void
-glmc_frustum_center(vec4 corners[8], vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]);
-
-CGLM_EXPORT
-void
-glmc_frustum_corners_at(vec4  corners[8],
-                        float splitDist,
-                        float farDist,
-                        vec4  planeCorners[4]);
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_frustum_h */

external/cglm/call/io.h

@@ -1,45 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_io_h
-#define cglmc_io_h
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_mat4_print(mat4   matrix,
-                FILE * __restrict ostream);
-
-CGLM_EXPORT
-void
-glmc_mat3_print(mat3 matrix,
-                FILE * __restrict ostream);
-
-CGLM_EXPORT
-void
-glmc_vec4_print(vec4 vec,
-                FILE * __restrict ostream);
-
-CGLM_EXPORT
-void
-glmc_vec3_print(vec3 vec,
-                FILE * __restrict ostream);
-
-CGLM_EXPORT
-void
-glmc_versor_print(versor vec,
-                  FILE * __restrict ostream);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_io_h */

external/cglm/call/ivec2.h

@@ -1,179 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ivec2_h
-#define cglmc_ivec2_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_ivec2(int * __restrict v, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_copy(ivec2 a, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_zero(ivec2 v);
-
-CGLM_EXPORT
-void
-glmc_ivec2_one(ivec2 v);
-
-CGLM_EXPORT
-int
-glmc_ivec2_dot(ivec2 a, ivec2 b);
-
-CGLM_EXPORT
-int
-glmc_ivec2_cross(ivec2 a, ivec2 b);
-
-CGLM_EXPORT
-void
-glmc_ivec2_add(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_adds(ivec2 v, int s, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_subs(ivec2 v, int s, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_scale(ivec2 v, int s, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_div(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_divs(ivec2 v, int s, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_mod(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_addadd(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_addadds(ivec2 a, int s, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_subadd(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_subadds(ivec2 a, int s, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_muladd(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_muladds(ivec2 a, int s, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_maxadd(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_minadd(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_subsub(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_subsubs(ivec2 a, int s, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_addsub(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_addsubs(ivec2 a, int s, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_mulsub(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_mulsubs(ivec2 a, int s, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_maxsub(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec2_minsub(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT
-int
-glmc_ivec2_distance2(ivec2 a, ivec2 b);
-
-CGLM_EXPORT
-float
-glmc_ivec2_distance(ivec2 a, ivec2 b);
-
-CGLM_EXPORT
-void
-glmc_ivec2_fill(ivec2 v, int val);
-
-CGLM_EXPORT
-bool
-glmc_ivec2_eq(ivec2 v, int val);
-
-CGLM_EXPORT
-bool
-glmc_ivec2_eqv(ivec2 a, ivec2 b);
-
-CGLM_EXPORT
-void
-glmc_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec2_clamp(ivec2 v, int minVal, int maxVal);
-
-CGLM_EXPORT
-void
-glmc_ivec2_abs(ivec2 v, ivec2 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ivec2_h */

external/cglm/call/ivec3.h

@@ -1,183 +0,0 @@
-/*
- * Copyright (c);, Recep Aslantas.
- *
- * MIT License (MIT);, http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ivec3_h
-#define cglmc_ivec3_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_ivec3(ivec4 v4, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_copy(ivec3 a, ivec3 dest);
-
-CGLM_EXPORT
-void 
-glmc_ivec3_zero(ivec3 v);
-
-CGLM_EXPORT
-void
-glmc_ivec3_one(ivec3 v);
-
-CGLM_EXPORT
-int
-glmc_ivec3_dot(ivec3 a, ivec3 b);
-
-CGLM_EXPORT
-int
-glmc_ivec3_norm2(ivec3 v);
-
-CGLM_EXPORT
-int
-glmc_ivec3_norm(ivec3 v);
-
-CGLM_EXPORT
-void
-glmc_ivec3_add(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_adds(ivec3 v, int s, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_subs(ivec3 v, int s, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_scale(ivec3 v, int s, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_div(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_divs(ivec3 v, int s, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_mod(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_addadd(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_addadds(ivec3 a, int s, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_subadd(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_subadds(ivec3 a, int s, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_muladd(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_muladds(ivec3 a, int s, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_maxadd(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_minadd(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_subsub(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_subsubs(ivec3 a, int s, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_addsub(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_addsubs(ivec3 a, int s, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_mulsub(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_mulsubs(ivec3 a, int s, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_maxsub(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec3_minsub(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT
-int
-glmc_ivec3_distance2(ivec3 a, ivec3 b);
-
-CGLM_EXPORT
-float
-glmc_ivec3_distance(ivec3 a, ivec3 b);
-
-CGLM_EXPORT
-void
-glmc_ivec3_fill(ivec3 v, int val);
-
-CGLM_EXPORT
-bool
-glmc_ivec3_eq(ivec3 v, int val);
-
-CGLM_EXPORT
-bool
-glmc_ivec3_eqv(ivec3 a, ivec3 b);
-
-CGLM_EXPORT
-void
-glmc_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec3_clamp(ivec3 v, int minVal, int maxVal);
-
-CGLM_EXPORT
-void
-glmc_ivec3_abs(ivec3 v, ivec3 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ivec3_h */

external/cglm/call/ivec4.h

@@ -1,147 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ivec4_h
-#define cglmc_ivec4_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_ivec4(ivec3 v3, int last, ivec4 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec4_copy(ivec4 a, ivec4 dest);
-
-CGLM_EXPORT
-void 
-glmc_ivec4_zero(ivec4 v);
-
-CGLM_EXPORT
-void
-glmc_ivec4_one(ivec4 v);
-
-CGLM_EXPORT
-void
-glmc_ivec4_add(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec4_adds(ivec4 v, int s, ivec4 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec4_subs(ivec4 v, int s, ivec4 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec4_scale(ivec4 v, int s, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_addadd(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_addadds(ivec4 a, int s, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_subadd(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_subadds(ivec4 a, int s, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_muladd(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_muladds(ivec4 a, int s, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_maxadd(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_minadd(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_subsub(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_subsubs(ivec4 a, int s, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_addsub(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_addsubs(ivec4 a, int s, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_mulsub(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_mulsubs(ivec4 a, int s, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_maxsub(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT 
-void 
-glmc_ivec4_minsub(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT
-int
-glmc_ivec4_distance2(ivec4 a, ivec4 b);
-
-CGLM_EXPORT
-float
-glmc_ivec4_distance(ivec4 a, ivec4 b);
-
-CGLM_EXPORT
-void
-glmc_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest);
-
-CGLM_EXPORT
-void
-glmc_ivec4_clamp(ivec4 v, int minVal, int maxVal);
-
-CGLM_EXPORT
-void
-glmc_ivec4_abs(ivec4 v, ivec4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ivec4_h */

external/cglm/call/mat2.h

@@ -1,83 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat2_h
-#define cglmc_mat2_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_mat2_make(const float * __restrict src, mat2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2_copy(mat2 mat, mat2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2_identity(mat2 m);
-
-CGLM_EXPORT
-void
-glmc_mat2_identity_array(mat2 * __restrict mats, size_t count);
-
-CGLM_EXPORT
-void
-glmc_mat2_zero(mat2 m);
-
-CGLM_EXPORT
-void
-glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2_transpose_to(mat2 mat, mat2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2_transpose(mat2 m);
-
-CGLM_EXPORT
-void
-glmc_mat2_scale(mat2 m, float s);
-
-CGLM_EXPORT
-void
-glmc_mat2_inv(mat2 mat, mat2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2_swap_col(mat2 mat, int col1, int col2);
-
-CGLM_EXPORT
-void
-glmc_mat2_swap_row(mat2 mat, int row1, int row2);
-
-CGLM_EXPORT
-float
-glmc_mat2_trace(mat2 m);
-
-CGLM_EXPORT
-float
-glmc_mat2_det(mat2 m);
-
-CGLM_EXPORT
-float
-glmc_mat2_rmc(vec2 r, mat2 m, vec2 c);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat2_h */

external/cglm/call/mat2x3.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat2x3_h
-#define cglmc_mat2x3_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_mat2x3_copy(mat2x3 src, mat2x3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x3_zero(mat2x3 m);
-
-CGLM_EXPORT
-void
-glmc_mat2x3_make(const float * __restrict src, mat2x3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x3_transpose(mat2x3 src, mat3x2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x3_scale(mat2x3 m, float s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat2x3_h */

external/cglm/call/mat2x4.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat2x4_h
-#define cglmc_mat2x4_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_mat2x4_copy(mat2x4 src, mat2x4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x4_zero(mat2x4 m);
-
-CGLM_EXPORT
-void
-glmc_mat2x4_make(const float * __restrict src, mat2x4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x4_transpose(mat2x4 src, mat4x2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat2x4_scale(mat2x4 m, float s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat2x4_h */

external/cglm/call/mat3.h

@@ -1,94 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat3_h
-#define cglmc_mat3_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-/* DEPRECATED! use _copy, _ucopy versions */
-#define glmc_mat3_dup(mat, dest)  glmc_mat3_copy(mat, dest)
-
-CGLM_EXPORT
-void
-glmc_mat3_copy(mat3 mat, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3_identity(mat3 mat);
-
-CGLM_EXPORT
-void
-glmc_mat3_zero(mat3 mat);
-
-CGLM_EXPORT
-void
-glmc_mat3_identity_array(mat3 * __restrict mat, size_t count);
-
-CGLM_EXPORT
-void
-glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3_transpose_to(mat3 m, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3_transpose(mat3 m);
-
-CGLM_EXPORT
-void
-glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_mat3_trace(mat3 m);
-
-CGLM_EXPORT
-void
-glmc_mat3_quat(mat3 m, versor dest);
-
-CGLM_EXPORT
-void
-glmc_mat3_scale(mat3 m, float s);
-
-CGLM_EXPORT
-float
-glmc_mat3_det(mat3 mat);
-
-CGLM_EXPORT
-void
-glmc_mat3_inv(mat3 mat, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3_swap_col(mat3 mat, int col1, int col2);
-
-CGLM_EXPORT
-void
-glmc_mat3_swap_row(mat3 mat, int row1, int row2);
-
-CGLM_EXPORT
-float
-glmc_mat3_rmc(vec3 r, mat3 m, vec3 c);
-
-CGLM_EXPORT
-void
-glmc_mat3_make(const float * __restrict src, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3_textrans(float sx, float sy, float rot, float tx, float ty, mat3 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat3_h */

external/cglm/call/mat3x2.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat3x2_h
-#define cglmc_mat3x2_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_mat3x2_copy(mat3x2 src, mat3x2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x2_zero(mat3x2 m);
-
-CGLM_EXPORT
-void
-glmc_mat3x2_make(const float * __restrict src, mat3x2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x2_transpose(mat3x2 src, mat2x3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x2_scale(mat3x2 m, float s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat3x2_h */

external/cglm/call/mat3x4.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat3x4_h
-#define cglmc_mat3x4_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_mat3x4_copy(mat3x4 src, mat3x4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x4_zero(mat3x4 m);
-
-CGLM_EXPORT
-void
-glmc_mat3x4_make(const float * __restrict src, mat3x4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x4_transpose(mat3x4 src, mat4x3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat3x4_scale(mat3x4 m, float s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat3x4_h */

external/cglm/call/mat4.h

@@ -1,135 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat_h
-#define cglmc_mat_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-/* DEPRECATED! use _copy, _ucopy versions */
-#define glmc_mat4_udup(mat, dest) glmc_mat4_ucopy(mat, dest)
-#define glmc_mat4_dup(mat, dest)  glmc_mat4_copy(mat, dest)
-
-CGLM_EXPORT
-void
-glmc_mat4_ucopy(mat4 mat, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_copy(mat4 mat, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_identity(mat4 mat);
-
-CGLM_EXPORT
-void
-glmc_mat4_identity_array(mat4 * __restrict mat, size_t count);
-
-CGLM_EXPORT
-void
-glmc_mat4_zero(mat4 mat);
-
-CGLM_EXPORT
-void
-glmc_mat4_pick3(mat4 mat, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_pick3t(mat4 mat, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_ins3(mat3 mat, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_mat4_trace(mat4 m);
-
-CGLM_EXPORT
-float
-glmc_mat4_trace3(mat4 m);
-
-CGLM_EXPORT
-void
-glmc_mat4_quat(mat4 m, versor dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_transpose_to(mat4 m, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_transpose(mat4 m);
-
-CGLM_EXPORT
-void
-glmc_mat4_scale_p(mat4 m, float s);
-
-CGLM_EXPORT
-void
-glmc_mat4_scale(mat4 m, float s);
-
-CGLM_EXPORT
-float
-glmc_mat4_det(mat4 mat);
-
-CGLM_EXPORT
-void
-glmc_mat4_inv(mat4 mat, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_inv_precise(mat4 mat, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_inv_fast(mat4 mat, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_swap_col(mat4 mat, int col1, int col2);
-
-CGLM_EXPORT
-void
-glmc_mat4_swap_row(mat4 mat, int row1, int row2);
-
-CGLM_EXPORT
-float
-glmc_mat4_rmc(vec4 r, mat4 m, vec4 c);
-
-CGLM_EXPORT
-void
-glmc_mat4_make(const float * __restrict src, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4_textrans(float sx, float sy, float rot, float tx, float ty, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat_h */

external/cglm/call/mat4x2.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat4x2_h
-#define cglmc_mat4x2_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_mat4x2_copy(mat4x2 src, mat4x2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x2_zero(mat4x2 m);
-
-CGLM_EXPORT
-void
-glmc_mat4x2_make(const float * __restrict src, mat4x2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x2_transpose(mat4x2 src, mat2x4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x2_scale(mat4x2 m, float s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat4x2_h */

external/cglm/call/mat4x3.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_mat4x3_h
-#define cglmc_mat4x3_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_mat4x3_copy(mat4x3 src, mat4x3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x3_zero(mat4x3 m);
-
-CGLM_EXPORT
-void
-glmc_mat4x3_make(const float * __restrict src, mat4x3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x3_transpose(mat4x3 src, mat3x4 dest);
-
-CGLM_EXPORT
-void
-glmc_mat4x3_scale(mat4x3 m, float s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_mat4x3_h */

external/cglm/call/noise.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_noise_h
-#define cglmc_noise_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-float
-glmc_perlin_vec4(vec4 point);
-
-CGLM_EXPORT
-float
-glmc_perlin_vec3(vec3 point);
-
-CGLM_EXPORT
-float
-glmc_perlin_vec2(vec2 point);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_noise_h */

external/cglm/call/plane.h

@@ -1,23 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_plane_h
-#define cglmc_plane_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_plane_normalize(vec4 plane);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_plane_h */

external/cglm/call/project.h

@@ -1,39 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_project_h
-#define cglmc_project_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_project_z(vec3 pos, mat4 m);
-
-CGLM_EXPORT
-void
-glmc_pickmatrix(vec2 center, vec2 size, vec4 vp, mat4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_project_h */

external/cglm/call/quat.h

@@ -1,175 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_quat_h
-#define cglmc_quat_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_quat_identity(versor q);
-
-CGLM_EXPORT
-void
-glmc_quat_identity_array(versor * __restrict q, size_t count);
-
-CGLM_EXPORT
-void
-glmc_quat_init(versor q, float x, float y, float z, float w);
-
-CGLM_EXPORT
-void
-glmc_quat(versor q, float angle, float x, float y, float z);
-
-CGLM_EXPORT
-void
-glmc_quatv(versor q, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_quat_copy(versor q, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_from_vecs(vec3 a, vec3 b, versor dest);
-
-CGLM_EXPORT
-float
-glmc_quat_norm(versor q);
-
-CGLM_EXPORT
-void
-glmc_quat_normalize_to(versor q, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_normalize(versor q);
-
-CGLM_EXPORT
-float
-glmc_quat_dot(versor p, versor q);
-
-CGLM_EXPORT
-void
-glmc_quat_conjugate(versor q, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_inv(versor q, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_add(versor p, versor q, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_sub(versor p, versor q, versor dest);
-
-CGLM_EXPORT
-float
-glmc_quat_real(versor q);
-
-CGLM_EXPORT
-void
-glmc_quat_imag(versor q, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_imagn(versor q, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_quat_imaglen(versor q);
-
-CGLM_EXPORT
-float
-glmc_quat_angle(versor q);
-
-CGLM_EXPORT
-void
-glmc_quat_axis(versor q, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_mul(versor p, versor q, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_mat4(versor q, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_mat4t(versor q, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_mat3(versor q, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_mat3t(versor q, mat3 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_lerp(versor from, versor to, float t, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_lerpc(versor from, versor to, float t, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_nlerp(versor q, versor r, float t, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_slerp(versor q, versor r, float t, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_slerp_longest(versor q, versor r, float t, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_look(vec3 eye, versor ori, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_for(vec3 dir, vec3 up, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
-
-CGLM_EXPORT
-void
-glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_rotate(mat4 m, versor q, mat4 dest);
-
-CGLM_EXPORT
-void
-glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
-
-CGLM_EXPORT
-void
-glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
-
-CGLM_EXPORT
-void
-glmc_quat_make(const float * __restrict src, versor dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_quat_h */

external/cglm/call/ray.h

@@ -1,39 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_ray_h
-#define cglmc_ray_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "../cglm.h"
-
-CGLM_EXPORT
-bool
-glmc_ray_triangle(vec3   origin,
-                  vec3   direction,
-                  vec3   v0,
-                  vec3   v1,
-                  vec3   v2,
-                  float *d);
-
-CGLM_EXPORT
-bool
-glmc_ray_sphere(vec3 origin,
-                vec3 dir,
-                vec4 s,
-                float * __restrict t1,
-                float * __restrict t2);
-
-CGLM_EXPORT
-void
-glmc_ray_at(vec3 orig, vec3 dir, float t, vec3 point);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_ray_h */

external/cglm/call/sphere.h

@@ -1,39 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_sphere_h
-#define cglmc_sphere_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-float
-glmc_sphere_radii(vec4 s);
-
-CGLM_EXPORT
-void
-glmc_sphere_transform(vec4 s, mat4 m, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest);
-
-CGLM_EXPORT
-bool
-glmc_sphere_sphere(vec4 s1, vec4 s2);
-
-CGLM_EXPORT
-bool
-glmc_sphere_point(vec4 s, vec3 point);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_sphere_h */

external/cglm/call/vec2.h

@@ -1,251 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_vec2_h
-#define cglmc_vec2_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-CGLM_EXPORT
-void
-glmc_vec2(float * __restrict v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_fill(vec2 v, float val);
-
-CGLM_EXPORT
-bool
-glmc_vec2_eq(vec2 v, float val);
-
-CGLM_EXPORT
-bool
-glmc_vec2_eqv(vec2 a, vec2 b);
-
-CGLM_EXPORT
-void
-glmc_vec2_copy(vec2 a, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_zero(vec2 v);
-
-CGLM_EXPORT
-void
-glmc_vec2_one(vec2 v);
-
-CGLM_EXPORT
-float
-glmc_vec2_dot(vec2 a, vec2 b);
-
-CGLM_EXPORT
-float
-glmc_vec2_cross(vec2 a, vec2 b);
-
-CGLM_EXPORT
-float
-glmc_vec2_norm2(vec2 v);
-
-CGLM_EXPORT
-float
-glmc_vec2_norm(vec2 v);
-
-CGLM_EXPORT
-void
-glmc_vec2_add(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_adds(vec2 v, float s, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_sub(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_subs(vec2 v, float s, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_mul(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_scale(vec2 v, float s, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_scale_as(vec2 v, float s, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_div(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_divs(vec2 v, float s, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_muladds(vec2 a, float s, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_subsub(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_addsub(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_mulsub(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_mulsubs(vec2 a, float s, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_maxsub(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_minsub(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_negate_to(vec2 v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_negate(vec2 v);
-
-CGLM_EXPORT
-void
-glmc_vec2_normalize(vec2 v);
-
-CGLM_EXPORT
-void
-glmc_vec2_normalize_to(vec2 v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_rotate(vec2 v, float angle, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_center(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-float
-glmc_vec2_distance2(vec2 a, vec2 b);
-
-CGLM_EXPORT
-float
-glmc_vec2_distance(vec2 a, vec2 b);
-
-CGLM_EXPORT
-void
-glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_minv(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_clamp(vec2 v, float minval, float maxval);
-
-CGLM_EXPORT
-void
-glmc_vec2_abs(vec2 v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_fract(vec2 v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_floor(vec2 v, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_mods(vec2 v, float s, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_swizzle(vec2 v, int mask, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_step(vec2 edge, vec2 x, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_steps(float edge, vec2 x, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_stepr(vec2 edge, float x, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_complex_mul(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_complex_div(vec2 a, vec2 b, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_complex_conjugate(vec2 a, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_make(const float * __restrict src, vec2 dest);
-
-CGLM_EXPORT
-void
-glmc_vec2_reflect(vec2 v, vec2 n, vec2 dest);
-
-CGLM_EXPORT
-bool
-glmc_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_vec2_h */

external/cglm/call/vec3.h

@@ -1,369 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_vec3_h
-#define cglmc_vec3_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-/* DEPRECATED! use _copy, _ucopy versions */
-#define glmc_vec_dup(v, dest)          glmc_vec3_copy(v, dest)
-#define glmc_vec3_flipsign(v)          glmc_vec3_negate(v)
-#define glmc_vec3_flipsign_to(v, dest) glmc_vec3_negate_to(v, dest)
-#define glmc_vec3_inv(v)               glmc_vec3_negate(v)
-#define glmc_vec3_inv_to(v, dest)      glmc_vec3_negate_to(v, dest)
-#define glmc_vec3_step_uni(edge, x, dest) glmc_vec3_steps(edge, x, dest);
-
-CGLM_EXPORT
-void
-glmc_vec3(vec4 v4, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_copy(vec3 a, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_zero(vec3 v);
-
-CGLM_EXPORT
-void
-glmc_vec3_one(vec3 v);
-
-CGLM_EXPORT
-float
-glmc_vec3_dot(vec3 a, vec3 b);
-
-CGLM_EXPORT
-void
-glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_vec3_norm(vec3 v);
-
-CGLM_EXPORT
-float
-glmc_vec3_norm2(vec3 v);
-
-CGLM_EXPORT
-float
-glmc_vec3_norm_one(vec3 v);
-
-CGLM_EXPORT
-float
-glmc_vec3_norm_inf(vec3 v);
-
-CGLM_EXPORT
-void
-glmc_vec3_normalize_to(vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_normalize(vec3 v);
-
-CGLM_EXPORT
-void
-glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_adds(vec3 v, float s, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_sub(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_subs(vec3 v, float s, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_mul(vec3 a, vec3 b, vec3 d);
-
-CGLM_EXPORT
-void
-glmc_vec3_scale(vec3 v, float s, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_scale_as(vec3 v, float s, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_div(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_divs(vec3 a, float s, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_muladds(vec3 a, float s, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_subsub(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_addsub(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_mulsub(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_mulsubs(vec3 a, float s, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_maxsub(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_minsub(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_negate(vec3 v);
-
-CGLM_EXPORT
-void
-glmc_vec3_negate_to(vec3 v, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_vec3_angle(vec3 a, vec3 b);
-
-CGLM_EXPORT
-void
-glmc_vec3_rotate(vec3 v, float angle, vec3 axis);
-
-CGLM_EXPORT
-void
-glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_vec3_distance2(vec3 a, vec3 b);
-
-CGLM_EXPORT
-float
-glmc_vec3_distance(vec3 a, vec3 b);
-
-CGLM_EXPORT
-void
-glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_clamp(vec3 v, float minVal, float maxVal);
-
-CGLM_EXPORT
-void
-glmc_vec3_ortho(vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest);
-
-CGLM_INLINE
-void
-glmc_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
-  glmc_vec3_lerp(from, to, t, dest);
-}
-
-CGLM_INLINE
-void
-glmc_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
-  glmc_vec3_lerpc(from, to, t, dest);
-}
-
-CGLM_EXPORT
-void
-glmc_vec3_step(vec3 edge, vec3 x, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_swizzle(vec3 v, int mask, vec3 dest);
-
-/* ext */
-
-CGLM_EXPORT
-void
-glmc_vec3_mulv(vec3 a, vec3 b, vec3 d);
-
-CGLM_EXPORT
-void
-glmc_vec3_broadcast(float val, vec3 d);
-
-CGLM_EXPORT
-void
-glmc_vec3_fill(vec3 v, float val);
-
-CGLM_EXPORT
-bool
-glmc_vec3_eq(vec3 v, float val);
-
-CGLM_EXPORT
-bool
-glmc_vec3_eq_eps(vec3 v, float val);
-
-CGLM_EXPORT
-bool
-glmc_vec3_eq_all(vec3 v);
-
-CGLM_EXPORT
-bool
-glmc_vec3_eqv(vec3 a, vec3 b);
-
-CGLM_EXPORT
-bool
-glmc_vec3_eqv_eps(vec3 a, vec3 b);
-
-CGLM_EXPORT
-float
-glmc_vec3_max(vec3 v);
-
-CGLM_EXPORT
-float
-glmc_vec3_min(vec3 v);
-
-CGLM_EXPORT
-bool
-glmc_vec3_isnan(vec3 v);
-
-CGLM_EXPORT
-bool
-glmc_vec3_isinf(vec3 v);
-
-CGLM_EXPORT
-bool
-glmc_vec3_isvalid(vec3 v);
-
-CGLM_EXPORT
-void
-glmc_vec3_sign(vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_abs(vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_fract(vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_floor(vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_mods(vec3 v, float s, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_steps(float edge, vec3 x, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_stepr(vec3 edge, float x, vec3 dest);
-
-CGLM_EXPORT
-float
-glmc_vec3_hadd(vec3 v);
-
-CGLM_EXPORT
-void
-glmc_vec3_sqrt(vec3 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_make(const float * __restrict src, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec3_reflect(vec3 v, vec3 n, vec3 dest);
-
-CGLM_EXPORT
-bool
-glmc_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_vec3_h */

external/cglm/call/vec4.h

@@ -1,342 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglmc_vec4_h
-#define cglmc_vec4_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../cglm.h"
-
-/* DEPRECATED! use _copy, _ucopy versions */
-#define glmc_vec4_dup3(v, dest)         glmc_vec4_copy3(v, dest)
-#define glmc_vec4_dup(v, dest)          glmc_vec4_copy(v, dest)
-#define glmc_vec4_flipsign(v)           glmc_vec4_negate(v)
-#define glmc_vec4_flipsign_to(v, dest)  glmc_vec4_negate_to(v, dest)
-#define glmc_vec4_inv(v)                glmc_vec4_negate(v)
-#define glmc_vec4_inv_to(v, dest)       glmc_vec4_negate_to(v, dest)
-#define glmc_vec4_step_uni(edge, x, dest) glmc_vec4_steps(edge, x, dest)
-
-CGLM_EXPORT
-void
-glmc_vec4(vec3 v3, float last, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_zero(vec4 v);
-
-CGLM_EXPORT
-void
-glmc_vec4_one(vec4 v);
-
-CGLM_EXPORT
-void
-glmc_vec4_copy3(vec4 v, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_copy(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_ucopy(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-float
-glmc_vec4_dot(vec4 a, vec4 b);
-
-CGLM_EXPORT
-float
-glmc_vec4_norm(vec4 v);
-
-CGLM_EXPORT
-float
-glmc_vec4_norm2(vec4 v);
-
-CGLM_EXPORT
-float
-glmc_vec4_norm_one(vec4 v);
-
-CGLM_EXPORT
-float
-glmc_vec4_norm_inf(vec4 v);
-
-CGLM_EXPORT
-void
-glmc_vec4_normalize_to(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_normalize(vec4 v);
-
-CGLM_EXPORT
-void
-glmc_vec4_add(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_adds(vec4 v, float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_sub(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_subs(vec4 v, float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_mul(vec4 a, vec4 b, vec4 d);
-
-CGLM_EXPORT
-void
-glmc_vec4_scale(vec4 v, float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_scale_as(vec4 v, float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_div(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_divs(vec4 v, float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_muladds(vec4 a, float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_subsub(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_addsub(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_mulsub(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_mulsubs(vec4 a, float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_maxsub(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_minsub(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_negate(vec4 v);
-
-CGLM_EXPORT
-void
-glmc_vec4_negate_to(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-float
-glmc_vec4_distance(vec4 a, vec4 b);
-
-CGLM_EXPORT
-float
-glmc_vec4_distance2(vec4 a, vec4 b);
-
-CGLM_EXPORT
-void
-glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_clamp(vec4 v, float minVal, float maxVal);
-
-CGLM_EXPORT
-void
-glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest);
-
-CGLM_INLINE
-void
-glmc_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
-  glmc_vec4_lerp(from, to, t, dest);
-}
-
-CGLM_INLINE
-void
-glmc_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
-  glmc_vec4_lerpc(from, to, t, dest);
-}
-
-CGLM_EXPORT
-void
-glmc_vec4_step(vec4 edge, vec4 x, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_cubic(float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_swizzle(vec4 v, int mask, vec4 dest);
-
-/* ext */
-
-CGLM_EXPORT
-void
-glmc_vec4_mulv(vec4 a, vec4 b, vec4 d);
-
-CGLM_EXPORT
-void
-glmc_vec4_broadcast(float val, vec4 d);
-
-CGLM_EXPORT
-void
-glmc_vec4_fill(vec4 v, float val);
-
-CGLM_EXPORT
-bool
-glmc_vec4_eq(vec4 v, float val);
-
-CGLM_EXPORT
-bool
-glmc_vec4_eq_eps(vec4 v, float val);
-
-CGLM_EXPORT
-bool
-glmc_vec4_eq_all(vec4 v);
-
-CGLM_EXPORT
-bool
-glmc_vec4_eqv(vec4 a, vec4 b);
-
-CGLM_EXPORT
-bool
-glmc_vec4_eqv_eps(vec4 a, vec4 b);
-
-CGLM_EXPORT
-float
-glmc_vec4_max(vec4 v);
-
-CGLM_EXPORT
-float
-glmc_vec4_min(vec4 v);
-
-CGLM_EXPORT
-bool
-glmc_vec4_isnan(vec4 v);
-
-CGLM_EXPORT
-bool
-glmc_vec4_isinf(vec4 v);
-
-CGLM_EXPORT
-bool
-glmc_vec4_isvalid(vec4 v);
-
-CGLM_EXPORT
-void
-glmc_vec4_sign(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_abs(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_fract(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_floor(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_mods(vec4 v, float s, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_steps(float edge, vec4 x, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_stepr(vec4 edge, float x, vec4 dest);
-
-CGLM_EXPORT
-float
-glmc_vec4_hadd(vec4 v);
-
-CGLM_EXPORT
-void
-glmc_vec4_sqrt(vec4 v, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_make(const float * __restrict src, vec4 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_reflect(vec4 v, vec4 n, vec4 dest);
-
-CGLM_EXPORT
-bool
-glmc_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* cglmc_vec4_h */

external/cglm/cam.h

@@ -1,582 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void  glm_frustum(float left,   float right,
-                                 float bottom, float top,
-                                 float nearZ,  float farZ,
-                                 mat4  dest)
-   CGLM_INLINE void  glm_ortho(float left,   float right,
-                               float bottom, float top,
-                               float nearZ,  float farZ,
-                               mat4  dest)
-   CGLM_INLINE void  glm_ortho_aabb(vec3 box[2], mat4 dest)
-   CGLM_INLINE void  glm_ortho_aabb_p(vec3 box[2],  float padding, mat4 dest)
-   CGLM_INLINE void  glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest)
-   CGLM_INLINE void  glm_ortho_default(float aspect, mat4  dest)
-   CGLM_INLINE void  glm_ortho_default_s(float aspect, float size, mat4 dest)
-   CGLM_INLINE void  glm_perspective(float fovy,
-                                     float aspect,
-                                     float nearZ,
-                                     float farZ,
-                                     mat4  dest)
-   CGLM_INLINE void  glm_perspective_default(float aspect, mat4 dest)
-   CGLM_INLINE void  glm_perspective_resize(float aspect, mat4 proj)
-   CGLM_INLINE void  glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void  glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void  glm_look_anyup(vec3 eye, vec3 dir, mat4 dest)
-   CGLM_INLINE void  glm_persp_decomp(mat4   proj,
-                                      float *nearZ, float *farZ,
-                                      float *top,   float *bottom,
-                                      float *left,  float *right)
-   CGLM_INLINE void  glm_persp_decompv(mat4 proj, float dest[6])
-   CGLM_INLINE void  glm_persp_decomp_x(mat4 proj, float *left, float *right)
-   CGLM_INLINE void  glm_persp_decomp_y(mat4 proj, float *top,  float *bottom)
-   CGLM_INLINE void  glm_persp_decomp_z(mat4 proj, float *nearv, float *farv)
-   CGLM_INLINE void  glm_persp_decomp_far(mat4 proj, float *farZ)
-   CGLM_INLINE void  glm_persp_decomp_near(mat4 proj, float *nearZ)
-   CGLM_INLINE float glm_persp_fovy(mat4 proj)
-   CGLM_INLINE float glm_persp_aspect(mat4 proj)
-   CGLM_INLINE void  glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
- */
-
-#ifndef cglm_cam_h
-#define cglm_cam_h
-
-#include "common.h"
-#include "plane.h"
-
-#include "clipspace/persp.h"
-
-#ifndef CGLM_CLIPSPACE_INCLUDE_ALL
-#  if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-#    include "clipspace/ortho_lh_zo.h"
-#    include "clipspace/persp_lh_zo.h"
-#    include "clipspace/view_lh_zo.h"
-#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-#    include "clipspace/ortho_lh_no.h"
-#    include "clipspace/persp_lh_no.h"
-#    include "clipspace/view_lh_no.h"
-#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-#    include "clipspace/ortho_rh_zo.h"
-#    include "clipspace/persp_rh_zo.h"
-#    include "clipspace/view_rh_zo.h"
-#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-#    include "clipspace/ortho_rh_no.h"
-#    include "clipspace/persp_rh_no.h"
-#    include "clipspace/view_rh_no.h"
-#  endif
-#else
-#  include "clipspace/ortho_lh_zo.h"
-#  include "clipspace/persp_lh_zo.h"
-#  include "clipspace/ortho_lh_no.h"
-#  include "clipspace/persp_lh_no.h"
-#  include "clipspace/ortho_rh_zo.h"
-#  include "clipspace/persp_rh_zo.h"
-#  include "clipspace/ortho_rh_no.h"
-#  include "clipspace/persp_rh_no.h"
-#  include "clipspace/view_lh_zo.h"
-#  include "clipspace/view_lh_no.h"
-#  include "clipspace/view_rh_zo.h"
-#  include "clipspace/view_rh_no.h"
-#endif
-
-/*!
- * @brief set up perspective peprojection matrix
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_frustum(float left,    float right,
-            float bottom,  float top,
-            float nearZ,   float farZ,
-            mat4  dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_frustum_lh_zo(left, right, bottom, top, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_frustum_lh_no(left, right, bottom, top, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_frustum_rh_zo(left, right, bottom, top, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_frustum_rh_no(left, right, bottom, top, nearZ, farZ, dest);
-#endif
-}
-
-/*!
- * @brief set up orthographic projection matrix
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho(float left,    float right,
-          float bottom,  float top,
-          float nearZ,   float farZ,
-          mat4  dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho_lh_zo(left, right, bottom, top, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_ortho_lh_no(left, right, bottom, top, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_ortho_rh_zo(left, right, bottom, top, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_ortho_rh_no(left, right, bottom, top, nearZ, farZ, dest);
-#endif
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box   AABB
- * @param[out] dest  result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb(vec3 box[2], mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho_aabb_lh_zo(box, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_ortho_aabb_lh_no(box, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_ortho_aabb_rh_zo(box, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_ortho_aabb_rh_no(box, dest);
-#endif
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho_aabb_p_lh_zo(box, padding, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_ortho_aabb_p_lh_no(box, padding, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_ortho_aabb_p_rh_zo(box, padding, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_ortho_aabb_p_rh_no(box, padding, dest);
-#endif
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding for near and far
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho_aabb_pz_lh_zo(box, padding, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_ortho_aabb_pz_lh_no(box, padding, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_ortho_aabb_pz_rh_zo(box, padding, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_ortho_aabb_pz_rh_no(box, padding, dest);
-#endif
-}
-
-/*!
- * @brief set up unit orthographic projection matrix
- *
- * @param[in]  aspect aspect ration ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default(float aspect, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho_default_lh_zo(aspect, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_ortho_default_lh_no(aspect, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_ortho_default_rh_zo(aspect, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_ortho_default_rh_no(aspect, dest);
-#endif
-}
-
-/*!
- * @brief set up orthographic projection matrix with given CUBE size
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[in]  size   cube size
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_s(float aspect, float size, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho_default_s_lh_zo(aspect, size, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_ortho_default_s_lh_no(aspect, size, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_ortho_default_s_rh_zo(aspect, size, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_ortho_default_s_rh_no(aspect, size, dest);
-#endif
-}
-
-/*!
- * @brief set up perspective projection matrix
- *
- * @param[in]  fovy    field of view angle
- * @param[in]  aspect  aspect ratio ( width / height )
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping planes
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_perspective_lh_zo(fovy, aspect, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_perspective_lh_no(fovy, aspect, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_perspective_rh_zo(fovy, aspect, nearZ, farZ, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_perspective_rh_no(fovy, aspect, nearZ, farZ, dest);
-#endif
-}
-
-/*!
- * @brief extend perspective projection matrix's far distance
- *
- * this function does not guarantee far >= near, be aware of that!
- *
- * @param[in, out] proj      projection matrix to extend
- * @param[in]      deltaFar  distance from existing far (negative to shink)
- */
-CGLM_INLINE
-void
-glm_persp_move_far(mat4 proj, float deltaFar) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_move_far_lh_zo(proj, deltaFar);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_move_far_lh_no(proj, deltaFar);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_move_far_rh_zo(proj, deltaFar);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_move_far_rh_no(proj, deltaFar);
-#endif
-}
-
-/*!
- * @brief set up perspective projection matrix with default near/far
- *        and angle values
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_default(float aspect, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_perspective_default_lh_zo(aspect, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_perspective_default_lh_no(aspect, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_perspective_default_rh_zo(aspect, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_perspective_default_rh_no(aspect, dest);
-#endif
-}
-
-/*!
- * @brief resize perspective matrix by aspect ratio ( width / height )
- *        this makes very easy to resize proj matrix when window /viewport
- *        reized
- *
- * @param[in]      aspect aspect ratio ( width / height )
- * @param[in, out] proj   perspective projection matrix
- */
-CGLM_INLINE
-void
-glm_perspective_resize(float aspect, mat4 proj) {
-  if (proj[0][0] == 0.0f)
-    return;
-
-  proj[0][0] = proj[1][1] / aspect;
-}
-
-/*!
- * @brief set up view matrix
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  center center vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
-  glm_lookat_lh(eye, center, up, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
-  glm_lookat_rh(eye, center, up, dest);
-#endif
-}
-
-/*!
- * @brief set up view matrix
- *
- * convenient wrapper for lookat: if you only have direction not target self
- * then this might be useful. Because you need to get target from direction.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
-  glm_look_lh(eye, dir, up, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
-  glm_look_rh(eye, dir, up, dest);
-#endif
-}
-
-/*!
- * @brief set up view matrix
- *
- * convenient wrapper for look: if you only have direction and if you don't
- * care what UP vector is then this might be useful to create view matrix
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
-  glm_look_anyup_lh(eye, dir, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
-  glm_look_anyup_rh(eye, dir, dest);
-#endif
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection.
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- * @param[out] top     top
- * @param[out] bottom  bottom
- * @param[out] left    left
- * @param[out] right   right
- */
-CGLM_INLINE
-void
-glm_persp_decomp(mat4 proj,
-                 float * __restrict nearZ, float * __restrict farZ,
-                 float * __restrict top,   float * __restrict bottom,
-                 float * __restrict left,  float * __restrict right) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_decomp_lh_zo(proj, nearZ, farZ, top, bottom, left, right);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_decomp_lh_no(proj, nearZ, farZ, top, bottom, left, right);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_decomp_rh_zo(proj, nearZ, farZ, top, bottom, left, right);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_decomp_rh_no(proj, nearZ, farZ, top, bottom, left, right);
-#endif
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection.
- *        this makes easy to get all values at once
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] dest   array
- */
-CGLM_INLINE
-void
-glm_persp_decompv(mat4 proj, float dest[6]) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_decompv_lh_zo(proj, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_decompv_lh_no(proj, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_decompv_rh_zo(proj, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_decompv_rh_no(proj, dest);
-#endif
-}
-
-/*!
- * @brief decomposes left and right values of perspective projection.
- *        x stands for x axis (left / right axis)
- *
- * @param[in]  proj  perspective projection matrix
- * @param[out] left  left
- * @param[out] right right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_x(mat4 proj,
-                   float * __restrict left,
-                   float * __restrict right) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_decomp_x_lh_zo(proj, left, right);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_decomp_x_lh_no(proj, left, right);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_decomp_x_rh_zo(proj, left, right);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_decomp_x_rh_no(proj, left, right);
-#endif
-}
-
-/*!
- * @brief decomposes top and bottom values of perspective projection.
- *        y stands for y axis (top / bottom axis)
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] top    top
- * @param[out] bottom bottom
- */
-CGLM_INLINE
-void
-glm_persp_decomp_y(mat4 proj,
-                   float * __restrict top,
-                   float * __restrict bottom) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_decomp_y_lh_zo(proj, top, bottom);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_decomp_y_lh_no(proj, top, bottom);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_decomp_y_rh_zo(proj, top, bottom);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_decomp_y_rh_no(proj, top, bottom);
-#endif
-}
-
-/*!
- * @brief decomposes near and far values of perspective projection.
- *        z stands for z axis (near / far axis)
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_z(mat4 proj, float * __restrict nearZ, float * __restrict farZ) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_decomp_z_lh_zo(proj, nearZ, farZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_decomp_z_lh_no(proj, nearZ, farZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_decomp_z_rh_zo(proj, nearZ, farZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_decomp_z_rh_no(proj, nearZ, farZ);
-#endif
-}
-
-/*!
- * @brief decomposes far value of perspective projection.
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] farZ   far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_far(mat4 proj, float * __restrict farZ) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_decomp_far_lh_zo(proj, farZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_decomp_far_lh_no(proj, farZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_decomp_far_rh_zo(proj, farZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_decomp_far_rh_no(proj, farZ);
-#endif
-}
-
-/*!
- * @brief decomposes near value of perspective projection.
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] nearZ  near
- */
-CGLM_INLINE
-void
-glm_persp_decomp_near(mat4 proj, float * __restrict nearZ) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_decomp_near_lh_zo(proj, nearZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_decomp_near_lh_no(proj, nearZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_decomp_near_rh_zo(proj, nearZ);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_decomp_near_rh_no(proj, nearZ);
-#endif
-}
-
-/*!
- * @brief returns sizes of near and far planes of perspective projection
- *
- * @param[in]  proj perspective projection matrix
- * @param[in]  fovy fovy (see brief)
- * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
- */
-CGLM_INLINE
-void
-glm_persp_sizes(mat4 proj, float fovy, vec4 dest) {
-#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_sizes_lh_zo(proj, fovy, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glm_persp_sizes_lh_no(proj, fovy, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_sizes_rh_zo(proj, fovy, dest);
-#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_persp_sizes_rh_no(proj, fovy, dest);
-#endif
-}
-
-#endif /* cglm_cam_h */

external/cglm/cglm.c

@@ -1,3 +0,0 @@
-#define CGLM_FORCE_DEPTH_ZERO_TO_ONE
-
-#include "cglm.h"

external/cglm/cglm.h

@@ -1,48 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_h
-#define cglm_h
-
-#include "common.h"
-#include "vec2.h"
-#include "vec3.h"
-#include "vec4.h"
-#include "ivec2.h"
-#include "ivec3.h"
-#include "ivec4.h"
-#include "mat4.h"
-#include "mat4x2.h"
-#include "mat4x3.h"
-#include "mat3.h"
-#include "mat3x2.h"
-#include "mat3x4.h"
-#include "mat2.h"
-#include "mat2x3.h"
-#include "mat2x4.h"
-#include "affine.h"
-#include "cam.h"
-#include "frustum.h"
-#include "quat.h"
-#include "euler.h"
-#include "plane.h"
-#include "noise.h"
-#include "aabb2d.h"
-#include "box.h"
-#include "color.h"
-#include "util.h"
-#include "io.h"
-#include "project.h"
-#include "sphere.h"
-#include "ease.h"
-#include "curve.h"
-#include "bezier.h"
-#include "ray.h"
-#include "affine2d.h"
-#include "affine2d-post.h"
-
-#endif /* cglm_h */

external/cglm/clipspace/ortho_lh_no.h

@@ -1,183 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_ortho_lh_no(float left,    float right,
-                                    float bottom,  float top,
-                                    float nearZ, float farZ,
-                                    mat4  dest)
-   CGLM_INLINE void glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_p_lh_no(vec3 box[2],
-                                           float padding,
-                                           mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_pz_lh_no(vec3 box[2],
-                                            float padding,
-                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_default_lh_no(float aspect,
-                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_default_s_lh_no(float aspect,
-                                              float size,
-                                              mat4 dest)
- */
-
-#ifndef cglm_ortho_lh_no_h
-#define cglm_ortho_lh_no_h
-
-#include "../common.h"
-#include "../plane.h"
-#include "../mat4.h"
-
-/*!
- * @brief set up orthographic projection matrix
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_lh_no(float left,    float right,
-                float bottom,  float top,
-                float nearZ, float farZ,
-                mat4  dest) {
-  float rl, tb, fn;
-
-  glm_mat4_zero(dest);
-
-  rl = 1.0f / (right  - left);
-  tb = 1.0f / (top    - bottom);
-  fn =-1.0f / (farZ - nearZ);
-
-  dest[0][0] = 2.0f * rl;
-  dest[1][1] = 2.0f * tb;
-  dest[2][2] =-2.0f * fn;
-  dest[3][0] =-(right  + left)    * rl;
-  dest[3][1] =-(top    + bottom)  * tb;
-  dest[3][2] = (farZ + nearZ) * fn;
-  dest[3][3] = 1.0f;
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box   AABB
- * @param[out] dest  result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest) {
-  glm_ortho_lh_no(box[0][0],  box[1][0],
-                  box[0][1],  box[1][1],
-                 -box[1][2], -box[0][2],
-                  dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho_lh_no(box[0][0] - padding,    box[1][0] + padding,
-                  box[0][1] - padding,    box[1][1] + padding,
-                -(box[1][2] + padding), -(box[0][2] - padding),
-                  dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding for near and far
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho_lh_no(box[0][0],              box[1][0],
-                  box[0][1],              box[1][1],
-                -(box[1][2] + padding), -(box[0][2] - padding),
-                  dest);
-}
-
-/*!
- * @brief set up unit orthographic projection matrix
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  aspect aspect ration ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_lh_no(float aspect, mat4 dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho_lh_no(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
-    return;
-  }
-
-  aspect = 1.0f / aspect;
-
-  glm_ortho_lh_no(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix with given CUBE size
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[in]  size   cube size
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_s_lh_no(float aspect, float size, mat4 dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho_lh_no(-size * aspect,
-                     size * aspect,
-                    -size,
-                     size,
-                    -size - 100.0f,
-                     size + 100.0f,
-                     dest);
-    return;
-  }
-
-  glm_ortho_lh_no(-size,
-                   size,
-                  -size / aspect,
-                   size / aspect,
-                  -size - 100.0f,
-                   size + 100.0f,
-                   dest);
-}
-
-#endif /*cglm_ortho_lh_no_h*/

external/cglm/clipspace/ortho_lh_zo.h

@@ -1,177 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_ortho_lh_zo(float left,    float right,
-                                    float bottom,  float top,
-                                    float nearZ, float farZ,
-                                    mat4  dest)
-   CGLM_INLINE void glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_p_lh_zo(vec3 box[2],
-                                           float padding,
-                                           mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_pz_lh_zo(vec3 box[2],
-                                            float padding,
-                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_default_lh_zo(float aspect,
-                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_default_s_lh_zo(float aspect,
-                                              float size,
-                                              mat4 dest)
- */
-
-#ifndef cglm_ortho_lh_zo_h
-#define cglm_ortho_lh_zo_h
-
-#include "../common.h"
-#include "../plane.h"
-#include "../mat4.h"
-
-/*!
- * @brief set up orthographic projection matrix with a left-hand coordinate
- *        system and a clip-space of [0, 1].
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_lh_zo(float left,    float right,
-                float bottom,  float top,
-                float nearZ, float farZ,
-                mat4  dest) {
-  float rl, tb, fn;
-
-  glm_mat4_zero(dest);
-
-  rl = 1.0f / (right  - left);
-  tb = 1.0f / (top    - bottom);
-  fn =-1.0f / (farZ - nearZ);
-
-  dest[0][0] = 2.0f * rl;
-  dest[1][1] = 2.0f * tb;
-  dest[2][2] =-fn;
-  dest[3][0] =-(right  + left)    * rl;
-  dest[3][1] =-(top    + bottom)  * tb;
-  dest[3][2] = nearZ * fn;
-  dest[3][3] = 1.0f;
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a left-hand coordinate system and a clip-space of [0, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box   AABB
- * @param[out] dest  result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest) {
-  glm_ortho_lh_zo(box[0][0],  box[1][0],
-                  box[0][1],  box[1][1],
-                 -box[1][2], -box[0][2],
-                  dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a left-hand coordinate system and a clip-space of [0, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho_lh_zo(box[0][0] - padding,    box[1][0] + padding,
-                  box[0][1] - padding,    box[1][1] + padding,
-                -(box[1][2] + padding), -(box[0][2] - padding),
-                  dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a left-hand coordinate system and a clip-space of [0, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding for near and far
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho_lh_zo(box[0][0],              box[1][0],
-                  box[0][1],              box[1][1],
-                -(box[1][2] + padding), -(box[0][2] - padding),
-                  dest);
-}
-
-/*!
- * @brief set up unit orthographic projection matrix
- *        with a left-hand coordinate system and a clip-space of [0, 1].
- *
- * @param[in]  aspect aspect ration ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_lh_zo(float aspect, mat4 dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho_lh_zo(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
-    return;
-  }
-
-  aspect = 1.0f / aspect;
-
-  glm_ortho_lh_zo(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix with given CUBE size
- *        with a left-hand coordinate system and a clip-space of [0, 1].
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[in]  size   cube size
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_s_lh_zo(float aspect, float size, mat4 dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho_lh_zo(-size * aspect,
-                     size * aspect,
-                    -size,
-                     size,
-                    -size - 100.0f,
-                     size + 100.0f,
-                     dest);
-    return;
-  }
-
-  glm_ortho_lh_zo(-size,
-                   size,
-                  -size / aspect,
-                   size / aspect,
-                  -size - 100.0f,
-                   size + 100.0f,
-                   dest);
-}
-
-#endif /*cglm_ortho_lh_zo_h*/

external/cglm/clipspace/ortho_rh_no.h

@@ -1,183 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_ortho_rh_no(float left,    float right,
-                                    float bottom,  float top,
-                                    float nearZ, float farZ,
-                                    mat4  dest)
-   CGLM_INLINE void glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_p_rh_no(vec3 box[2],
-                                           float padding,
-                                           mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_pz_rh_no(vec3 box[2],
-                                            float padding,
-                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_default_rh_no(float aspect,
-                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_default_s_rh_no(float aspect,
-                                              float size,
-                                              mat4 dest)
- */
-
-#ifndef cglm_ortho_rh_no_h
-#define cglm_ortho_rh_no_h
-
-#include "../common.h"
-#include "../plane.h"
-#include "../mat4.h"
-
-/*!
- * @brief set up orthographic projection matrix
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_rh_no(float left,    float right,
-                float bottom,  float top,
-                float nearZ, float farZ,
-                mat4  dest) {
-  float rl, tb, fn;
-
-  glm_mat4_zero(dest);
-
-  rl = 1.0f / (right  - left);
-  tb = 1.0f / (top    - bottom);
-  fn =-1.0f / (farZ - nearZ);
-
-  dest[0][0] = 2.0f * rl;
-  dest[1][1] = 2.0f * tb;
-  dest[2][2] = 2.0f * fn;
-  dest[3][0] =-(right  + left)    * rl;
-  dest[3][1] =-(top    + bottom)  * tb;
-  dest[3][2] = (farZ + nearZ) * fn;
-  dest[3][3] = 1.0f;
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box   AABB
- * @param[out] dest  result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest) {
-  glm_ortho_rh_no(box[0][0],  box[1][0],
-                  box[0][1],  box[1][1],
-                 -box[1][2], -box[0][2],
-                  dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho_rh_no(box[0][0] - padding,    box[1][0] + padding,
-                  box[0][1] - padding,    box[1][1] + padding,
-                -(box[1][2] + padding), -(box[0][2] - padding),
-                  dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding for near and far
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho_rh_no(box[0][0],              box[1][0],
-                  box[0][1],              box[1][1],
-                -(box[1][2] + padding), -(box[0][2] - padding),
-                  dest);
-}
-
-/*!
- * @brief set up unit orthographic projection matrix
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  aspect aspect ration ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_rh_no(float aspect, mat4 dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho_rh_no(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
-    return;
-  }
-
-  aspect = 1.0f / aspect;
-
-  glm_ortho_rh_no(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix with given CUBE size
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[in]  size   cube size
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_s_rh_no(float aspect, float size, mat4 dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho_rh_no(-size * aspect,
-                     size * aspect,
-                    -size,
-                     size,
-                    -size - 100.0f,
-                     size + 100.0f,
-                     dest);
-    return;
-  }
-
-  glm_ortho_rh_no(-size,
-                   size,
-                  -size / aspect,
-                   size / aspect,
-                  -size - 100.0f,
-                   size + 100.0f,
-                   dest);
-}
-
-#endif /*cglm_ortho_rh_no_h*/

external/cglm/clipspace/ortho_rh_zo.h

@@ -1,181 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_ortho_rh_zo(float left,    float right,
-                                    float bottom,  float top,
-                                    float nearZ, float farZ,
-                                    mat4  dest)
-   CGLM_INLINE void glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_p_rh_zo(vec3 box[2],
-                                           float padding,
-                                           mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(vec3 box[2],
-                                            float padding,
-                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_default_rh_zo(float aspect,
-                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_default_s_rh_zo(float aspect,
-                                              float size,
-                                              mat4 dest)
- */
-
-#ifndef cglm_ortho_rh_zo_h
-#define cglm_ortho_rh_zo_h
-
-#include "../common.h"
-#include "../plane.h"
-#include "../mat4.h"
-
-/*!
- * @brief set up orthographic projection matrix with a right-hand coordinate
- *        system and a clip-space of [0, 1].
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_rh_zo(float left,    float right,
-                float bottom,  float top,
-                float nearZ, float farZ,
-                mat4  dest) {
-  float rl, tb, fn;
-
-  glm_mat4_zero(dest);
-
-  rl = 1.0f / (right  - left);
-  tb = 1.0f / (top    - bottom);
-  fn =-1.0f / (farZ - nearZ);
-
-  dest[0][0] = 2.0f * rl;
-  dest[1][1] = 2.0f * tb;
-  dest[2][2] = fn;
-  dest[3][0] =-(right  + left)    * rl;
-  dest[3][1] =-(top    + bottom)  * tb;
-  dest[3][2] = nearZ * fn;
-  dest[3][3] = 1.0f;
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a right-hand coordinate system and a clip-space with depth
- *        values from zero to one.
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box   AABB
- * @param[out] dest  result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
-  glm_ortho_rh_zo(box[0][0],  box[1][0],
-                  box[0][1],  box[1][1],
-                 -box[1][2], -box[0][2],
-                  dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a right-hand coordinate system and a clip-space with depth
- *        values from zero to one.
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho_rh_zo(box[0][0] - padding,    box[1][0] + padding,
-                  box[0][1] - padding,    box[1][1] + padding,
-                -(box[1][2] + padding), -(box[0][2] - padding),
-                  dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix using bounding box
- *        with a right-hand coordinate system and a clip-space with depth
- *        values from zero to one.
- *
- * bounding box (AABB) must be in view space
- *
- * @param[in]  box     AABB
- * @param[in]  padding padding for near and far
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho_rh_zo(box[0][0],              box[1][0],
-                  box[0][1],              box[1][1],
-                -(box[1][2] + padding), -(box[0][2] - padding),
-                  dest);
-}
-
-/*!
- * @brief set up unit orthographic projection matrix with a right-hand
- *        coordinate system and a clip-space of [0, 1].
- *
- * @param[in]  aspect aspect ration ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_rh_zo(float aspect, mat4 dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho_rh_zo(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
-    return;
-  }
-
-  aspect = 1.0f / aspect;
-
-  glm_ortho_rh_zo(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix with given CUBE size
- *        with a right-hand coordinate system and a clip-space with depth
- *        values from zero to one.
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[in]  size   cube size
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_s_rh_zo(float aspect, float size, mat4 dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho_rh_zo(-size * aspect,
-                     size * aspect,
-                    -size,
-                     size,
-                    -size - 100.0f,
-                     size + 100.0f,
-                     dest);
-    return;
-  }
-
-  glm_ortho_rh_zo(-size,
-                   size,
-                  -size / aspect,
-                   size / aspect,
-                  -size - 100.0f,
-                   size + 100.0f,
-                   dest);
-}
-
-#endif /*cglm_ortho_rh_zo_h*/

external/cglm/clipspace/persp.h

@@ -1,48 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void  glm_persp_decomp_far(mat4 proj, float *farZ)
-   CGLM_INLINE float glm_persp_fovy(mat4 proj)
-   CGLM_INLINE float glm_persp_aspect(mat4 proj)
-   CGLM_INLINE void  glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
- */
-
-#ifndef cglm_persp_h
-#define cglm_persp_h
-
-#include "../common.h"
-#include "../plane.h"
-#include "../mat4.h"
-
-/*!
- * @brief returns field of view angle along the Y-axis (in radians)
- *
- * if you need to degrees, use glm_deg to convert it or use this:
- * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_fovy(mat4 proj) {
-  return 2.0f * atanf(1.0f / proj[1][1]);
-}
-
-/*!
- * @brief returns aspect ratio of perspective projection
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_aspect(mat4 proj) {
-  return proj[1][1] / proj[0][0];
-}
-
-#endif /* cglm_persp_h */

external/cglm/clipspace/persp_lh_no.h

@@ -1,395 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_frustum_lh_no(float left,    float right,
-                                       float bottom,  float top,
-                                       float nearZ, float farZ,
-                                       mat4  dest)
-   CGLM_INLINE void glm_perspective_lh_no(float fovy,
-                                          float aspect,
-                                          float nearZ,
-                                          float farZ,
-                                          mat4  dest)
-   CGLM_INLINE void glm_perspective_default_lh_no(float aspect, mat4 dest)
-   CGLM_INLINE void glm_perspective_resize_lh_no(float aspect, mat4 proj)
-   CGLM_INLINE void glm_persp_move_far_lh_no(mat4 proj,
-                                             float deltaFar)
-   CGLM_INLINE void glm_persp_decomp_lh_no(mat4 proj,
-                                           float * __restrict nearZ,
-                                           float * __restrict farZ,
-                                           float * __restrict top,
-                                           float * __restrict bottom,
-                                           float * __restrict left,
-                                           float * __restrict right)
-  CGLM_INLINE void glm_persp_decompv_lh_no(mat4 proj,
-                                           float dest[6])
-  CGLM_INLINE void glm_persp_decomp_x_lh_no(mat4 proj,
-                                            float * __restrict left,
-                                            float * __restrict right)
-  CGLM_INLINE void glm_persp_decomp_y_lh_no(mat4 proj,
-                                            float * __restrict top,
-                                            float * __restrict bottom)
-  CGLM_INLINE void glm_persp_decomp_z_lh_no(mat4 proj,
-                                            float * __restrict nearZ,
-                                            float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ)
-  CGLM_INLINE void glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest)
- */
-
-#ifndef cglm_persp_lh_no_h
-#define cglm_persp_lh_no_h
-
-#include "../common.h"
-#include "persp.h"
-
-/*!
- * @brief set up perspective peprojection matrix
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_frustum_lh_no(float left,    float right,
-                  float bottom,  float top,
-                  float nearZ, float farZ,
-                  mat4  dest) {
-  float rl, tb, fn, nv;
-
-  glm_mat4_zero(dest);
-
-  rl = 1.0f / (right  - left);
-  tb = 1.0f / (top    - bottom);
-  fn =-1.0f / (farZ - nearZ);
-  nv = 2.0f * nearZ;
-
-  dest[0][0] = nv * rl;
-  dest[1][1] = nv * tb;
-  dest[2][0] = (right  + left)    * rl;
-  dest[2][1] = (top    + bottom)  * tb;
-  dest[2][2] =-(farZ + nearZ) * fn;
-  dest[2][3] = 1.0f;
-  dest[3][2] = farZ * nv * fn;
-}
-
-/*!
- * @brief set up perspective projection matrix
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  fovy    field of view angle
- * @param[in]  aspect  aspect ratio ( width / height )
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping planes
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_lh_no(float fovy,
-                      float aspect,
-                      float nearZ,
-                      float farZ,
-                      mat4  dest) {
-  float f, fn;
-
-  glm_mat4_zero(dest);
-
-  f  = 1.0f / tanf(fovy * 0.5f);
-  fn = 1.0f / (nearZ - farZ);
-
-  dest[0][0] = f / aspect;
-  dest[1][1] = f;
-  dest[2][2] =-(nearZ + farZ) * fn;
-  dest[2][3] = 1.0f;
-  dest[3][2] = 2.0f * nearZ * farZ * fn;
-
-}
-
-/*!
- * @brief set up perspective projection matrix with default near/far
- *        and angle values with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_default_lh_no(float aspect, mat4 dest) {
-  glm_perspective_lh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
-}
-
-/*!
- * @brief resize perspective matrix by aspect ratio ( width / height )
- *        this makes very easy to resize proj matrix when window /viewport
- *        resized with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]      aspect aspect ratio ( width / height )
- * @param[in, out] proj   perspective projection matrix
- */
-CGLM_INLINE
-void
-glm_perspective_resize_lh_no(float aspect, mat4 proj) {
-  if (proj[0][0] == 0.0f)
-    return;
-
-  proj[0][0] = proj[1][1] / aspect;
-}
-
-/*!
- * @brief extend perspective projection matrix's far distance
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * this function does not guarantee far >= near, be aware of that!
- *
- * @param[in, out] proj      projection matrix to extend
- * @param[in]      deltaFar  distance from existing far (negative to shink)
- */
-CGLM_INLINE
-void
-glm_persp_move_far_lh_no(mat4 proj, float deltaFar) {
-  float fn, farZ, nearZ, p22, p32;
-
-  p22        = -proj[2][2];
-  p32        = proj[3][2];
-
-  nearZ    = p32 / (p22 - 1.0f);
-  farZ     = p32 / (p22 + 1.0f) + deltaFar;
-  fn         = 1.0f / (nearZ - farZ);
-
-  proj[2][2] = -(farZ + nearZ) * fn;
-  proj[3][2] = 2.0f * nearZ * farZ * fn;
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- * @param[out] top     top
- * @param[out] bottom  bottom
- * @param[out] left    left
- * @param[out] right   right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_lh_no(mat4 proj,
-                       float * __restrict nearZ, float * __restrict farZ,
-                       float * __restrict top,   float * __restrict bottom,
-                       float * __restrict left,  float * __restrict right) {
-  float m00, m11, m20, m21, m22, m32, n, f;
-  float n_m11, n_m00;
-
-  m00 = proj[0][0];
-  m11 = proj[1][1];
-  m20 = proj[2][0];
-  m21 = proj[2][1];
-  m22 =-proj[2][2];
-  m32 = proj[3][2];
-
-  n = m32 / (m22 - 1.0f);
-  f = m32 / (m22 + 1.0f);
-
-  n_m11 = n / m11;
-  n_m00 = n / m00;
-
-  *nearZ = n;
-  *farZ  = f;
-  *bottom  = n_m11 * (m21 - 1.0f);
-  *top     = n_m11 * (m21 + 1.0f);
-  *left    = n_m00 * (m20 - 1.0f);
-  *right   = n_m00 * (m20 + 1.0f);
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *        this makes easy to get all values at once
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] dest   array
- */
-CGLM_INLINE
-void
-glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
-  glm_persp_decomp_lh_no(proj, &dest[0], &dest[1], &dest[2],
-                               &dest[3], &dest[4], &dest[5]);
-}
-
-/*!
- * @brief decomposes left and right values of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *        x stands for x axis (left / right axis)
- *
- * @param[in]  proj  perspective projection matrix
- * @param[out] left  left
- * @param[out] right right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_x_lh_no(mat4 proj,
-                         float * __restrict left,
-                         float * __restrict right) {
-  float nearZ, m20, m00, m22;
-
-  m00 = proj[0][0];
-  m20 = proj[2][0];
-  m22 =-proj[2][2];
-
-  nearZ = proj[3][2] / (m22 - 1.0f);
-  *left   = nearZ * (m20 - 1.0f) / m00;
-  *right  = nearZ * (m20 + 1.0f) / m00;
-}
-
-/*!
- * @brief decomposes top and bottom values of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *        y stands for y axis (top / bottom axis)
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] top    top
- * @param[out] bottom bottom
- */
-CGLM_INLINE
-void
-glm_persp_decomp_y_lh_no(mat4 proj,
-                         float * __restrict top,
-                         float * __restrict bottom) {
-  float nearZ, m21, m11, m22;
-
-  m21 = proj[2][1];
-  m11 = proj[1][1];
-  m22 =-proj[2][2];
-
-  nearZ = proj[3][2] / (m22 - 1.0f);
-  *bottom = nearZ * (m21 - 1.0f) / m11;
-  *top    = nearZ * (m21 + 1.0f) / m11;
-}
-
-/*!
- * @brief decomposes near and far values of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *        z stands for z axis (near / far axis)
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_z_lh_no(mat4 proj,
-                         float * __restrict nearZ,
-                         float * __restrict farZ) {
-  float m32, m22;
-
-  m32 = proj[3][2];
-  m22 =-proj[2][2];
-
-  *nearZ = m32 / (m22 - 1.0f);
-  *farZ  = m32 / (m22 + 1.0f);
-}
-
-/*!
- * @brief decomposes far value of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] farZ   far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
-  *farZ = proj[3][2] / (-proj[2][2] + 1.0f);
-}
-
-/*!
- * @brief decomposes near value of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- */
-CGLM_INLINE
-void
-glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
-  *nearZ = proj[3][2] / (-proj[2][2] - 1.0f);
-}
-
-/*!
- * @brief returns sizes of near and far planes of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  proj perspective projection matrix
- * @param[in]  fovy fovy (see brief)
- * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
- */
-CGLM_INLINE
-void
-glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
-  float t, a, nearZ, farZ;
-
-  t = 2.0f * tanf(fovy * 0.5f);
-  a = glm_persp_aspect(proj);
-
-  glm_persp_decomp_z_lh_no(proj, &nearZ, &farZ);
-
-  dest[1]  = t * nearZ;
-  dest[3]  = t * farZ;
-  dest[0]  = a * dest[1];
-  dest[2]  = a * dest[3];
-}
-
-/*!
- * @brief returns field of view angle along the Y-axis (in radians)
- *        with a left-hand coordinate system and a clip-space of [-1, 1].
- *
- * if you need to degrees, use glm_deg to convert it or use this:
- * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_fovy_lh_no(mat4 proj) {
-  return glm_persp_fovy(proj);
-}
-
-/*!
- * @brief returns aspect ratio of perspective projection
- *        with a left-hand coordinate system and a clip-space of [-1, 1].
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_aspect_lh_no(mat4 proj) {
-  return glm_persp_aspect(proj);
-}
-
-#endif /*cglm_cam_lh_no_h*/

external/cglm/clipspace/persp_lh_zo.h

@@ -1,387 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_frustum_lh_zo(float left,    float right,
-                                      float bottom,  float top,
-                                      float nearZ, float farZ,
-                                      mat4  dest)
-   CGLM_INLINE void glm_perspective_lh_zo(float fovy,
-                                          float aspect,
-                                          float nearZ,
-                                          float farZ,
-                                          mat4  dest)
-   CGLM_INLINE void glm_perspective_default_lh_zo(float aspect, mat4 dest)
-   CGLM_INLINE void glm_perspective_resize_lh_zo(float aspect, mat4 proj)
-   CGLM_INLINE void glm_persp_move_far_lh_zo(mat4 proj,
-                                             float deltaFar)
-   CGLM_INLINE void glm_persp_decomp_lh_zo(mat4 proj,
-                                           float * __restrict nearZ,
-                                           float * __restrict farZ,
-                                           float * __restrict top,
-                                           float * __restrict bottom,
-                                           float * __restrict left,
-                                           float * __restrict right)
-  CGLM_INLINE void glm_persp_decompv_lh_zo(mat4 proj,
-                                           float dest[6])
-  CGLM_INLINE void glm_persp_decomp_x_lh_zo(mat4 proj,
-                                            float * __restrict left,
-                                            float * __restrict right)
-  CGLM_INLINE void glm_persp_decomp_y_lh_zo(mat4 proj,
-                                            float * __restrict top,
-                                            float * __restrict bottom)
-  CGLM_INLINE void glm_persp_decomp_z_lh_zo(mat4 proj,
-                                            float * __restrict nearZ,
-                                            float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ)
-  CGLM_INLINE void glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest)
- */
-
-#ifndef cglm_persp_lh_zo_h
-#define cglm_persp_lh_zo_h
-
-#include "../common.h"
-#include "persp.h"
-
-/*!
- * @brief set up perspective peprojection matrix with a left-hand coordinate
- *        system and a clip-space of [0, 1].
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_frustum_lh_zo(float left,    float right,
-                  float bottom,  float top,
-                  float nearZ, float farZ,
-                  mat4  dest) {
-  float rl, tb, fn, nv;
-
-  glm_mat4_zero(dest);
-
-  rl = 1.0f / (right  - left);
-  tb = 1.0f / (top    - bottom);
-  fn =-1.0f / (farZ - nearZ);
-  nv = 2.0f * nearZ;
-
-  dest[0][0] = nv * rl;
-  dest[1][1] = nv * tb;
-  dest[2][0] = (right  + left)    * rl;
-  dest[2][1] = (top    + bottom)  * tb;
-  dest[2][2] =-farZ * fn;
-  dest[2][3] = 1.0f;
-  dest[3][2] = farZ * nearZ * fn;
-}
-
-/*!
- * @brief set up perspective projection matrix with a left-hand coordinate
- * system and a clip-space of [0, 1].
- *
- * @param[in]  fovy    field of view angle
- * @param[in]  aspect  aspect ratio ( width / height )
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping planes
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_lh_zo(float fovy,
-                      float aspect,
-                      float nearZ,
-                      float farZ,
-                      mat4  dest) {
-  float f, fn;
-
-  glm_mat4_zero(dest);
-
-  f  = 1.0f / tanf(fovy * 0.5f);
-  fn = 1.0f / (nearZ - farZ);
-
-  dest[0][0] = f / aspect;
-  dest[1][1] = f;
-  dest[2][2] =-farZ * fn;
-  dest[2][3] = 1.0f;
-  dest[3][2] = nearZ * farZ * fn;
-}
-
-/*!
- * @brief extend perspective projection matrix's far distance with a
- *        left-hand coordinate system and a clip-space with depth values
- *        from zero to one.
- *
- * this function does not guarantee far >= near, be aware of that!
- *
- * @param[in, out] proj      projection matrix to extend
- * @param[in]      deltaFar  distance from existing far (negative to shink)
- */
-CGLM_INLINE
-void
-glm_persp_move_far_lh_zo(mat4 proj, float deltaFar) {
-  float fn, farZ, nearZ, p22, p32;
-
-  p22        = -proj[2][2];
-  p32        = proj[3][2];
-
-  nearZ    = p32 / p22;
-  farZ     = p32 / (p22 + 1.0f) + deltaFar;
-  fn         = 1.0f / (nearZ - farZ);
-
-  proj[2][2] = -farZ * fn;
-  proj[3][2] = nearZ * farZ * fn;
-}
-
-/*!
- * @brief set up perspective projection matrix with default near/far
- *        and angle values with a left-hand coordinate system and a 
- *        clip-space of [0, 1].
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_default_lh_zo(float aspect, mat4 dest) {
-  glm_perspective_lh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
-}
-
-/*!
- * @brief resize perspective matrix by aspect ratio ( width / height )
- *        this makes very easy to resize proj matrix when window /viewport
- *        reized
- *
- * @param[in]      aspect aspect ratio ( width / height )
- * @param[in, out] proj   perspective projection matrix
- */
-CGLM_INLINE
-void
-glm_perspective_resize_lh_zo(float aspect, mat4 proj) {
-  if (proj[0][0] == 0.0f)
-    return;
-
-  proj[0][0] = proj[1][1] / aspect;
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection
- *        with angle values with a left-hand coordinate system and a 
- *        clip-space of [0, 1].
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- * @param[out] top     top
- * @param[out] bottom  bottom
- * @param[out] left    left
- * @param[out] right   right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_lh_zo(mat4 proj,
-                    float * __restrict nearZ, float * __restrict farZ,
-                    float * __restrict top,     float * __restrict bottom,
-                    float * __restrict left,    float * __restrict right) {
-  float m00, m11, m20, m21, m22, m32, n, f;
-  float n_m11, n_m00;
-
-  m00 = proj[0][0];
-  m11 = proj[1][1];
-  m20 = proj[2][0];
-  m21 = proj[2][1];
-  m22 =-proj[2][2];
-  m32 = proj[3][2];
-
-  n = m32 / m22;
-  f = m32 / (m22 + 1.0f);
-
-  n_m11 = n / m11;
-  n_m00 = n / m00;
-
-  *nearZ = n;
-  *farZ  = f;
-  *bottom  = n_m11 * (m21 - 1.0f);
-  *top     = n_m11 * (m21 + 1.0f);
-  *left    = n_m00 * (m20 - 1.0f);
-  *right   = n_m00 * (m20 + 1.0f);
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection
- *        with angle values with a left-hand coordinate system and a 
- *        clip-space of [0, 1].
- *        this makes easy to get all values at once
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] dest   array
- */
-CGLM_INLINE
-void
-glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
-  glm_persp_decomp_lh_zo(proj, &dest[0], &dest[1], &dest[2],
-                               &dest[3], &dest[4], &dest[5]);
-}
-
-/*!
- * @brief decomposes left and right values of perspective projection (ZO).
- *        x stands for x axis (left / right axis)
- *
- * @param[in]  proj  perspective projection matrix
- * @param[out] left  left
- * @param[out] right right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_x_lh_zo(mat4 proj,
-                         float * __restrict left,
-                         float * __restrict right) {
-  float nearZ, m20, m00;
-
-  m00 = proj[0][0];
-  m20 = proj[2][0];
-
-  nearZ = proj[3][2] / (proj[3][3]);
-  *left   = nearZ * (m20 - 1.0f) / m00;
-  *right  = nearZ * (m20 + 1.0f) / m00;
-}
-
-/*!
- * @brief decomposes top and bottom values of perspective projection
- *        with angle values with a left-hand coordinate system and a 
- *        clip-space of [0, 1].
- *        y stands for y axis (top / bottom axis)
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] top    top
- * @param[out] bottom bottom
- */
-CGLM_INLINE
-void
-glm_persp_decomp_y_lh_zo(mat4 proj,
-                         float * __restrict top,
-                         float * __restrict bottom) {
-  float nearZ, m21, m11;
-
-  m21 = proj[2][1];
-  m11 = proj[1][1];
-
-  nearZ = proj[3][2] / (proj[3][3]);
-  *bottom = nearZ * (m21 - 1) / m11;
-  *top    = nearZ * (m21 + 1) / m11;
-}
-
-/*!
- * @brief decomposes near and far values of perspective projection
- *        with angle values with a left-hand coordinate system and a 
- *        clip-space of [0, 1].
- *        z stands for z axis (near / far axis)
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_z_lh_zo(mat4 proj,
-                         float * __restrict nearZ,
-                         float * __restrict farZ) {
-  float m32, m22;
-
-  m32 = proj[3][2];
-  m22 = -proj[2][2];
-
-  *nearZ = m32 / m22;
-  *farZ  = m32 / (m22 + 1.0f);
-}
-
-/*!
- * @brief decomposes far value of perspective projection
- *        with angle values with a left-hand coordinate system and a 
- *        clip-space of [0, 1].
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] farZ   far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
-  *farZ = proj[3][2] / (-proj[2][2] + 1.0f);
-}
-
-/*!
- * @brief decomposes near value of perspective projection
- *        with angle values with a left-hand coordinate system and a 
- *        clip-space of [0, 1].
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- */
-CGLM_INLINE
-void
-glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
-  *nearZ = proj[3][2] / -proj[2][2];
-}
-
-/*!
- * @brief returns sizes of near and far planes of perspective projection
- *        with a left-hand coordinate system and a
- *        clip-space of [0, 1].
- *
- * @param[in]  proj perspective projection matrix
- * @param[in]  fovy fovy (see brief)
- * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
- */
-CGLM_INLINE
-void
-glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
-  float t, a, nearZ, farZ;
-
-  t = 2.0f * tanf(fovy * 0.5f);
-  a = glm_persp_aspect(proj);
-
-  glm_persp_decomp_z_lh_zo(proj, &nearZ, &farZ);
-
-  dest[1]  = t * nearZ;
-  dest[3]  = t * farZ;
-  dest[0]  = a * dest[1];
-  dest[2]  = a * dest[3];
-}
-
-/*!
- * @brief returns field of view angle along the Y-axis (in radians)
- *        with a left-hand coordinate system and a clip-space of [0, 1].
- *
- * if you need to degrees, use glm_deg to convert it or use this:
- * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_fovy_lh_zo(mat4 proj) {
-  return glm_persp_fovy(proj);
-}
-
-/*!
- * @brief returns aspect ratio of perspective projection
- *        with a left-hand coordinate system and a clip-space of [0, 1].
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_aspect_lh_zo(mat4 proj) {
-  return glm_persp_aspect(proj);
-}
-
-#endif /*cglm_persp_lh_zo_h*/

external/cglm/clipspace/persp_rh_no.h

@@ -1,395 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_frustum_rh_no(float left,    float right,
-                                      float bottom,  float top,
-                                      float nearZ, float farZ,
-                                      mat4  dest)
-   CGLM_INLINE void glm_perspective_rh_no(float fovy,
-                                          float aspect,
-                                          float nearZ,
-                                          float farZ,
-                                          mat4  dest)
-   CGLM_INLINE void glm_perspective_default_rh_no(float aspect, mat4 dest)
-   CGLM_INLINE void glm_perspective_resize_rh_no(float aspect, mat4 proj)
-   CGLM_INLINE void glm_persp_move_far_rh_no(mat4 proj,
-                                             float deltaFar)
-   CGLM_INLINE void glm_persp_decomp_rh_no(mat4 proj,
-                                           float * __restrict nearZ,
-                                           float * __restrict farZ,
-                                           float * __restrict top,
-                                           float * __restrict bottom,
-                                           float * __restrict left,
-                                           float * __restrict right)
-  CGLM_INLINE void glm_persp_decompv_rh_no(mat4 proj,
-                                           float dest[6])
-  CGLM_INLINE void glm_persp_decomp_x_rh_no(mat4 proj,
-                                            float * __restrict left,
-                                            float * __restrict right)
-  CGLM_INLINE void glm_persp_decomp_y_rh_no(mat4 proj,
-                                            float * __restrict top,
-                                            float * __restrict bottom)
-  CGLM_INLINE void glm_persp_decomp_z_rh_no(mat4 proj,
-                                            float * __restrict nearZ,
-                                            float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ)
-  CGLM_INLINE void glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest)
- */
-
-#ifndef cglm_persp_rh_no_h
-#define cglm_persp_rh_no_h
-
-#include "../common.h"
-#include "persp.h"
-
-/*!
- * @brief set up perspective peprojection matrix
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_frustum_rh_no(float left,    float right,
-                  float bottom,  float top,
-                  float nearZ, float farZ,
-                  mat4  dest) {
-  float rl, tb, fn, nv;
-
-  glm_mat4_zero(dest);
-
-  rl = 1.0f / (right  - left);
-  tb = 1.0f / (top    - bottom);
-  fn =-1.0f / (farZ - nearZ);
-  nv = 2.0f * nearZ;
-
-  dest[0][0] = nv * rl;
-  dest[1][1] = nv * tb;
-  dest[2][0] = (right  + left)    * rl;
-  dest[2][1] = (top    + bottom)  * tb;
-  dest[2][2] = (farZ + nearZ) * fn;
-  dest[2][3] =-1.0f;
-  dest[3][2] = farZ * nv * fn;
-}
-
-/*!
- * @brief set up perspective projection matrix
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  fovy    field of view angle
- * @param[in]  aspect  aspect ratio ( width / height )
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping planes
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_rh_no(float fovy,
-                      float aspect,
-                      float nearZ,
-                      float farZ,
-                      mat4  dest) {
-  float f, fn;
-
-  glm_mat4_zero(dest);
-
-  f  = 1.0f / tanf(fovy * 0.5f);
-  fn = 1.0f / (nearZ - farZ);
-
-  dest[0][0] = f / aspect;
-  dest[1][1] = f;
-  dest[2][2] = (nearZ + farZ) * fn;
-  dest[2][3] =-1.0f;
-  dest[3][2] = 2.0f * nearZ * farZ * fn;
-
-}
-
-/*!
- * @brief set up perspective projection matrix with default near/far
- *        and angle values with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_default_rh_no(float aspect, mat4 dest) {
-  glm_perspective_rh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
-}
-
-/*!
- * @brief resize perspective matrix by aspect ratio ( width / height )
- *        this makes very easy to resize proj matrix when window /viewport
- *        resized with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]      aspect aspect ratio ( width / height )
- * @param[in, out] proj   perspective projection matrix
- */
-CGLM_INLINE
-void
-glm_perspective_resize_rh_no(float aspect, mat4 proj) {
-  if (proj[0][0] == 0.0f)
-    return;
-
-  proj[0][0] = proj[1][1] / aspect;
-}
-
-/*!
- * @brief extend perspective projection matrix's far distance
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * this function does not guarantee far >= near, be aware of that!
- *
- * @param[in, out] proj      projection matrix to extend
- * @param[in]      deltaFar  distance from existing far (negative to shink)
- */
-CGLM_INLINE
-void
-glm_persp_move_far_rh_no(mat4 proj, float deltaFar) {
-  float fn, farZ, nearZ, p22, p32;
-
-  p22        = proj[2][2];
-  p32        = proj[3][2];
-
-  nearZ    = p32 / (p22 - 1.0f);
-  farZ     = p32 / (p22 + 1.0f) + deltaFar;
-  fn         = 1.0f / (nearZ - farZ);
-
-  proj[2][2] = (farZ + nearZ) * fn;
-  proj[3][2] = 2.0f * nearZ * farZ * fn;
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- * @param[out] top     top
- * @param[out] bottom  bottom
- * @param[out] left    left
- * @param[out] right   right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_rh_no(mat4 proj,
-                       float * __restrict nearZ, float * __restrict farZ,
-                       float * __restrict top,     float * __restrict bottom,
-                       float * __restrict left,    float * __restrict right) {
-  float m00, m11, m20, m21, m22, m32, n, f;
-  float n_m11, n_m00;
-
-  m00 = proj[0][0];
-  m11 = proj[1][1];
-  m20 = proj[2][0];
-  m21 = proj[2][1];
-  m22 = proj[2][2];
-  m32 = proj[3][2];
-
-  n = m32 / (m22 - 1.0f);
-  f = m32 / (m22 + 1.0f);
-
-  n_m11 = n / m11;
-  n_m00 = n / m00;
-
-  *nearZ = n;
-  *farZ  = f;
-  *bottom  = n_m11 * (m21 - 1.0f);
-  *top     = n_m11 * (m21 + 1.0f);
-  *left    = n_m00 * (m20 - 1.0f);
-  *right   = n_m00 * (m20 + 1.0f);
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *        this makes easy to get all values at once
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] dest   array
- */
-CGLM_INLINE
-void
-glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
-  glm_persp_decomp_rh_no(proj, &dest[0], &dest[1], &dest[2],
-                               &dest[3], &dest[4], &dest[5]);
-}
-
-/*!
- * @brief decomposes left and right values of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *        x stands for x axis (left / right axis)
- *
- * @param[in]  proj  perspective projection matrix
- * @param[out] left  left
- * @param[out] right right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_x_rh_no(mat4 proj,
-                         float * __restrict left,
-                         float * __restrict right) {
-  float nearZ, m20, m00, m22;
-
-  m00 = proj[0][0];
-  m20 = proj[2][0];
-  m22 = proj[2][2];
-
-  nearZ = proj[3][2] / (m22 - 1.0f);
-  *left   = nearZ * (m20 - 1.0f) / m00;
-  *right  = nearZ * (m20 + 1.0f) / m00;
-}
-
-/*!
- * @brief decomposes top and bottom values of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *        y stands for y axis (top / bottom axis)
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] top    top
- * @param[out] bottom bottom
- */
-CGLM_INLINE
-void
-glm_persp_decomp_y_rh_no(mat4 proj,
-                         float * __restrict top,
-                         float * __restrict bottom) {
-  float nearZ, m21, m11, m22;
-
-  m21 = proj[2][1];
-  m11 = proj[1][1];
-  m22 = proj[2][2];
-
-  nearZ = proj[3][2] / (m22 - 1.0f);
-  *bottom = nearZ * (m21 - 1.0f) / m11;
-  *top    = nearZ * (m21 + 1.0f) / m11;
-}
-
-/*!
- * @brief decomposes near and far values of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *        z stands for z axis (near / far axis)
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_z_rh_no(mat4 proj,
-                      float * __restrict nearZ,
-                      float * __restrict farZ) {
-  float m32, m22;
-
-  m32 = proj[3][2];
-  m22 = proj[2][2];
-
-  *nearZ = m32 / (m22 - 1.0f);
-  *farZ  = m32 / (m22 + 1.0f);
-}
-
-/*!
- * @brief decomposes far value of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] farZ   far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
-  *farZ = proj[3][2] / (proj[2][2] + 1.0f);
-}
-
-/*!
- * @brief decomposes near value of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ near
- */
-CGLM_INLINE
-void
-glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
-  *nearZ = proj[3][2] / (proj[2][2] - 1.0f);
-}
-
-/*!
- * @brief returns sizes of near and far planes of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [-1, 1].
- *
- * @param[in]  proj perspective projection matrix
- * @param[in]  fovy fovy (see brief)
- * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
- */
-CGLM_INLINE
-void
-glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
-  float t, a, nearZ, farZ;
-
-  t = 2.0f * tanf(fovy * 0.5f);
-  a = glm_persp_aspect(proj);
-
-  glm_persp_decomp_z_rh_no(proj, &nearZ, &farZ);
-
-  dest[1]  = t * nearZ;
-  dest[3]  = t * farZ;
-  dest[0]  = a * dest[1];
-  dest[2]  = a * dest[3];
-}
-
-/*!
- * @brief returns field of view angle along the Y-axis (in radians)
- *        with a right-hand coordinate system and a clip-space of [-1, 1].
- *
- * if you need to degrees, use glm_deg to convert it or use this:
- * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_fovy_rh_no(mat4 proj) {
-  return glm_persp_fovy(proj);
-}
-
-/*!
- * @brief returns aspect ratio of perspective projection
- *        with a right-hand coordinate system and a clip-space of [-1, 1].
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_aspect_rh_no(mat4 proj) {
-  return glm_persp_aspect(proj);
-}
-
-#endif /*cglm_cam_rh_no_h*/

external/cglm/clipspace/persp_rh_zo.h

@@ -1,389 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_frustum_rh_zo(float left,    float right,
-                                      float bottom,  float top,
-                                      float nearZ, float farZ,
-                                      mat4  dest)
-   CGLM_INLINE void glm_perspective_rh_zo(float fovy,
-                                          float aspect,
-                                          float nearZ,
-                                          float farZ,
-                                          mat4  dest)
-   CGLM_INLINE void glm_perspective_default_rh_zo(float aspect, mat4 dest)
-   CGLM_INLINE void glm_perspective_resize_rh_zo(float aspect, mat4 proj)
-   CGLM_INLINE void glm_persp_move_far_rh_zo(mat4 proj,
-                                             float deltaFar)
-   CGLM_INLINE void glm_persp_decomp_rh_zo(mat4 proj,
-                                           float * __restrict nearZ,
-                                           float * __restrict farZ,
-                                           float * __restrict top,
-                                           float * __restrict bottom,
-                                           float * __restrict left,
-                                           float * __restrict right)
-  CGLM_INLINE void glm_persp_decompv_rh_zo(mat4 proj,
-                                           float dest[6])
-  CGLM_INLINE void glm_persp_decomp_x_rh_zo(mat4 proj,
-                                            float * __restrict left,
-                                            float * __restrict right)
-  CGLM_INLINE void glm_persp_decomp_y_rh_zo(mat4 proj,
-                                            float * __restrict top,
-                                            float * __restrict bottom)
-  CGLM_INLINE void glm_persp_decomp_z_rh_zo(mat4 proj,
-                                            float * __restrict nearZ,
-                                            float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ)
-  CGLM_INLINE void glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest)
- */
-
-#ifndef cglm_persp_rh_zo_h
-#define cglm_persp_rh_zo_h
-
-#include "../common.h"
-#include "persp.h"
-
-/*!
- * @brief set up perspective peprojection matrix with a right-hand coordinate
- *        system and a clip-space of [0, 1].
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearZ   near clipping plane
- * @param[in]  farZ    far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_frustum_rh_zo(float left,    float right,
-                  float bottom,  float top,
-                  float nearZ, float farZ,
-                  mat4  dest) {
-  float rl, tb, fn, nv;
-
-  glm_mat4_zero(dest);
-
-  rl = 1.0f / (right  - left);
-  tb = 1.0f / (top    - bottom);
-  fn =-1.0f / (farZ - nearZ);
-  nv = 2.0f * nearZ;
-
-  dest[0][0] = nv * rl;
-  dest[1][1] = nv * tb;
-  dest[2][0] = (right  + left)    * rl;
-  dest[2][1] = (top    + bottom)  * tb;
-  dest[2][2] = farZ * fn;
-  dest[2][3] =-1.0f;
-  dest[3][2] = farZ * nearZ * fn;
-}
-
-/*!
- * @brief set up perspective projection matrix with a right-hand coordinate
- *        system and a clip-space of [0, 1].
- *
- * @param[in]  fovy    field of view angle
- * @param[in]  aspect  aspect ratio ( width / height )
- * @param[in]  nearZ near clipping plane
- * @param[in]  farZ  far clipping planes
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_rh_zo(float fovy,
-                      float aspect,
-                      float nearZ,
-                      float farZ,
-                      mat4  dest) {
-  float f, fn;
-
-  glm_mat4_zero(dest);
-
-  f  = 1.0f / tanf(fovy * 0.5f);
-  fn = 1.0f / (nearZ - farZ);
-
-  dest[0][0] = f / aspect;
-  dest[1][1] = f;
-  dest[2][2] = farZ * fn;
-  dest[2][3] =-1.0f;
-  dest[3][2] = nearZ * farZ * fn;
-}
-
-/*!
- * @brief set up perspective projection matrix with default near/far
- *        and angle values with a right-hand coordinate system and a
- *        clip-space of [0, 1].
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_default_rh_zo(float aspect, mat4 dest) {
-  glm_perspective_rh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
-}
-
-/*!
- * @brief resize perspective matrix by aspect ratio ( width / height )
- *        this makes very easy to resize proj matrix when window /viewport
- *        resized with a right-hand coordinate system and a clip-space of
- *        [0, 1].
- *
- * @param[in]      aspect aspect ratio ( width / height )
- * @param[in, out] proj   perspective projection matrix
- */
-CGLM_INLINE
-void
-glm_perspective_resize_rh_zo(float aspect, mat4 proj) {
-  if (proj[0][0] == 0.0f)
-    return;
-
-  proj[0][0] = proj[1][1] / aspect;
-}
-
-/*!
- * @brief extend perspective projection matrix's far distance with a
- *        right-hand coordinate system and a clip-space of [0, 1].
- *
- * this function does not guarantee far >= near, be aware of that!
- *
- * @param[in, out] proj      projection matrix to extend
- * @param[in]      deltaFar  distance from existing far (negative to shink)
- */
-CGLM_INLINE
-void
-glm_persp_move_far_rh_zo(mat4 proj, float deltaFar) {
-  float fn, farZ, nearZ, p22, p32;
-
-  p22        = proj[2][2];
-  p32        = proj[3][2];
-
-  nearZ    = p32 / p22;
-  farZ     = p32 / (p22 + 1.0f) + deltaFar;
-  fn         = 1.0f / (nearZ - farZ);
-
-  proj[2][2] = farZ * fn;
-  proj[3][2] = nearZ * farZ * fn;
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection
- *        with angle values with a right-hand coordinate system and a 
- *        clip-space of [0, 1].
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- * @param[out] top     top
- * @param[out] bottom  bottom
- * @param[out] left    left
- * @param[out] right   right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_rh_zo(mat4 proj,
-                    float * __restrict nearZ, float * __restrict farZ,
-                    float * __restrict top,     float * __restrict bottom,
-                    float * __restrict left,    float * __restrict right) {
-  float m00, m11, m20, m21, m22, m32, n, f;
-  float n_m11, n_m00;
-
-  m00 = proj[0][0];
-  m11 = proj[1][1];
-  m20 = proj[2][0];
-  m21 = proj[2][1];
-  m22 = proj[2][2];
-  m32 = proj[3][2];
-
-  n = m32 / m22;
-  f = m32 / (m22 + 1.0f);
-
-  n_m11 = n / m11;
-  n_m00 = n / m00;
-
-  *nearZ = n;
-  *farZ  = f;
-  *bottom  = n_m11 * (m21 - 1.0f);
-  *top     = n_m11 * (m21 + 1.0f);
-  *left    = n_m00 * (m20 - 1.0f);
-  *right   = n_m00 * (m20 + 1.0f);
-}
-
-/*!
- * @brief decomposes frustum values of perspective projection
- *        with angle values with a right-hand coordinate system and a 
- *        clip-space of [0, 1].
- *        this makes easy to get all values at once
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] dest   array
- */
-CGLM_INLINE
-void
-glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
-  glm_persp_decomp_rh_zo(proj, &dest[0], &dest[1], &dest[2],
-                               &dest[3], &dest[4], &dest[5]);
-}
-
-/*!
- * @brief decomposes left and right values of perspective projection (ZO).
- *        x stands for x axis (left / right axis)
- *
- * @param[in]  proj  perspective projection matrix
- * @param[out] left  left
- * @param[out] right right
- */
-CGLM_INLINE
-void
-glm_persp_decomp_x_rh_zo(mat4 proj,
-                         float * __restrict left,
-                         float * __restrict right) {
-  float nearZ, m20, m00, m22;
-
-  m00 = proj[0][0];
-  m20 = proj[2][0];
-  m22 = proj[2][2];
-
-  nearZ = proj[3][2] / m22;
-  *left   = nearZ * (m20 - 1.0f) / m00;
-  *right  = nearZ * (m20 + 1.0f) / m00;
-}
-
-/*!
- * @brief decomposes top and bottom values of perspective projection
- *        with angle values with a right-hand coordinate system and a 
- *        clip-space of [0, 1].
- *        y stands for y axis (top / bottom axis)
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] top    top
- * @param[out] bottom bottom
- */
-CGLM_INLINE
-void
-glm_persp_decomp_y_rh_zo(mat4 proj,
-                         float * __restrict top,
-                         float * __restrict bottom) {
-  float nearZ, m21, m11, m22;
-
-  m21 = proj[2][1];
-  m11 = proj[1][1];
-  m22 = proj[2][2];
-
-  nearZ = proj[3][2] / m22;
-  *bottom = nearZ * (m21 - 1) / m11;
-  *top    = nearZ * (m21 + 1) / m11;
-}
-
-/*!
- * @brief decomposes near and far values of perspective projection
- *        with angle values with a right-hand coordinate system and a 
- *        clip-space of [0, 1].
- *        z stands for z axis (near / far axis)
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- * @param[out] farZ    far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_z_rh_zo(mat4 proj,
-                         float * __restrict nearZ,
-                         float * __restrict farZ) {
-  float m32, m22;
-
-  m32 = proj[3][2];
-  m22 = proj[2][2];
-
-  *nearZ = m32 / m22;
-  *farZ  = m32 / (m22 + 1.0f);
-}
-
-/*!
- * @brief decomposes far value of perspective projection
- *        with angle values with a right-hand coordinate system and a 
- *        clip-space of [0, 1].
- *
- * @param[in]  proj   perspective projection matrix
- * @param[out] farZ   far
- */
-CGLM_INLINE
-void
-glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
-  *farZ = proj[3][2] / (proj[2][2] + 1.0f);
-}
-
-/*!
- * @brief decomposes near value of perspective projection
- *        with angle values with a right-hand coordinate system and a 
- *        clip-space of [0, 1].
- *
- * @param[in]  proj    perspective projection matrix
- * @param[out] nearZ   near
- */
-CGLM_INLINE
-void
-glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
-  *nearZ = proj[3][2] / proj[2][2];
-}
-
-/*!
- * @brief returns sizes of near and far planes of perspective projection
- *        with a right-hand coordinate system and a
- *        clip-space of [0, 1].
- *
- * @param[in]  proj perspective projection matrix
- * @param[in]  fovy fovy (see brief)
- * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
- */
-CGLM_INLINE
-void
-glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
-  float t, a, nearZ, farZ;
-
-  t = 2.0f * tanf(fovy * 0.5f);
-  a = glm_persp_aspect(proj);
-
-  glm_persp_decomp_z_rh_zo(proj, &nearZ, &farZ);
-
-  dest[1]  = t * nearZ;
-  dest[3]  = t * farZ;
-  dest[0]  = a * dest[1];
-  dest[2]  = a * dest[3];
-}
-
-/*!
- * @brief returns field of view angle along the Y-axis (in radians)
- *        with a right-hand coordinate system and a clip-space of [0, 1].
- *
- * if you need to degrees, use glm_deg to convert it or use this:
- * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_fovy_rh_zo(mat4 proj) {
-  return glm_persp_fovy(proj);
-}
-
-/*!
- * @brief returns aspect ratio of perspective projection
- *        with a right-hand coordinate system and a clip-space of [0, 1].
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_aspect_rh_zo(mat4 proj) {
-  return glm_persp_aspect(proj);
-}
-
-#endif /*cglm_persp_rh_zo_h*/

external/cglm/clipspace/project_no.h

@@ -1,109 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_project_no_h
-#define cglm_project_no_h
-
-#include "../common.h"
-#include "../vec3.h"
-#include "../vec4.h"
-#include "../mat4.h"
-
-/*!
- * @brief maps the specified viewport coordinates into specified space [1]
- *        the matrix should contain projection matrix.
- *
- * if you don't have ( and don't want to have ) an inverse matrix then use
- * glm_unproject version. You may use existing inverse of matrix in somewhere
- * else, this is why glm_unprojecti exists to save save inversion cost
- *
- * [1] space:
- *  1- if m = invProj:     View Space
- *  2- if m = invViewProj: World Space
- *  3- if m = invMVP:      Object Space
- *
- * You probably want to map the coordinates into object space
- * so use invMVP as m
- *
- * Computing viewProj:
- *   glm_mat4_mul(proj, view, viewProj);
- *   glm_mat4_mul(viewProj, model, MVP);
- *   glm_mat4_inv(viewProj, invMVP);
- *
- * @param[in]  pos      point/position in viewport coordinates
- * @param[in]  invMat   matrix (see brief)
- * @param[in]  vp       viewport as [x, y, width, height]
- * @param[out] dest     unprojected coordinates
- */
-CGLM_INLINE
-void
-glm_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
-  vec4 v;
-
-  v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
-  v[1] = 2.0f * (pos[1] - vp[1]) / vp[3] - 1.0f;
-  v[2] = 2.0f *  pos[2]                  - 1.0f;
-  v[3] = 1.0f;
-
-  glm_mat4_mulv(invMat, v, v);
-  glm_vec4_scale(v, 1.0f / v[3], v);
-  glm_vec3(v, dest);
-}
-
-/*!
- * @brief map object coordinates to window coordinates
- *
- * Computing MVP:
- *   glm_mat4_mul(proj, view, viewProj);
- *   glm_mat4_mul(viewProj, model, MVP);
- *
- * @param[in]  pos      object coordinates
- * @param[in]  m        MVP matrix
- * @param[in]  vp       viewport as [x, y, width, height]
- * @param[out] dest     projected coordinates
- */
-CGLM_INLINE
-void
-glm_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
-  CGLM_ALIGN(16) vec4 pos4;
-
-  glm_vec4(pos, 1.0f, pos4);
-
-  glm_mat4_mulv(m, pos4, pos4);
-  glm_vec4_scale(pos4, 1.0f / pos4[3], pos4); /* pos = pos / pos.w */
-  glm_vec4_scale(pos4, 0.5f, pos4);
-  glm_vec4_adds(pos4,  0.5f, pos4);
-
-  dest[0] = pos4[0] * vp[2] + vp[0];
-  dest[1] = pos4[1] * vp[3] + vp[1];
-  dest[2] = pos4[2];
-}
-
-/*!
- * @brief map object's z coordinate to window coordinates
- *
- * Computing MVP:
- *   glm_mat4_mul(proj, view, viewProj);
- *   glm_mat4_mul(viewProj, model, MVP);
- *
- * @param[in]  v  object coordinates
- * @param[in]  m  MVP matrix
- *
- * @returns projected z coordinate
- */
-CGLM_INLINE
-float
-glm_project_z_no(vec3 v, mat4 m) {
-  float z, w;
-
-  z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
-  w = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
-
-  return 0.5f * (z / w) + 0.5f;
-}
-
-#endif /* cglm_project_no_h */

external/cglm/clipspace/project_zo.h

@@ -1,111 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_project_zo_h
-#define cglm_project_zo_h
-
-#include "../common.h"
-#include "../vec3.h"
-#include "../vec4.h"
-#include "../mat4.h"
-
-/*!
- * @brief maps the specified viewport coordinates into specified space [1]
- *        the matrix should contain projection matrix.
- *
- * if you don't have ( and don't want to have ) an inverse matrix then use
- * glm_unproject version. You may use existing inverse of matrix in somewhere
- * else, this is why glm_unprojecti exists to save save inversion cost
- *
- * [1] space:
- *  1- if m = invProj:     View Space
- *  2- if m = invViewProj: World Space
- *  3- if m = invMVP:      Object Space
- *
- * You probably want to map the coordinates into object space
- * so use invMVP as m
- *
- * Computing viewProj:
- *   glm_mat4_mul(proj, view, viewProj);
- *   glm_mat4_mul(viewProj, model, MVP);
- *   glm_mat4_inv(viewProj, invMVP);
- *
- * @param[in]  pos      point/position in viewport coordinates
- * @param[in]  invMat   matrix (see brief)
- * @param[in]  vp       viewport as [x, y, width, height]
- * @param[out] dest     unprojected coordinates
- */
-CGLM_INLINE
-void
-glm_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
-  vec4 v;
-
-  v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
-  v[1] = 2.0f * (pos[1] - vp[1]) / vp[3] - 1.0f;
-  v[2] = pos[2];
-  v[3] = 1.0f;
-
-  glm_mat4_mulv(invMat, v, v);
-  glm_vec4_scale(v, 1.0f / v[3], v);
-  glm_vec3(v, dest);
-}
-
-/*!
- * @brief map object coordinates to window coordinates
- *
- * Computing MVP:
- *   glm_mat4_mul(proj, view, viewProj);
- *   glm_mat4_mul(viewProj, model, MVP);
- *
- * @param[in]  pos      object coordinates
- * @param[in]  m        MVP matrix
- * @param[in]  vp       viewport as [x, y, width, height]
- * @param[out] dest     projected coordinates
- */
-CGLM_INLINE
-void
-glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
-  CGLM_ALIGN(16) vec4 pos4;
-
-  glm_vec4(pos, 1.0f, pos4);
-
-  glm_mat4_mulv(m, pos4, pos4);
-  glm_vec4_scale(pos4, 1.0f / pos4[3], pos4); /* pos = pos / pos.w */
-
-  dest[2] = pos4[2];
-  
-  glm_vec4_scale(pos4, 0.5f, pos4);
-  glm_vec4_adds(pos4,  0.5f, pos4);
-
-  dest[0] = pos4[0] * vp[2] + vp[0];
-  dest[1] = pos4[1] * vp[3] + vp[1];
-}
-
-/*!
- * @brief map object's z coordinate to window coordinates
- *
- * Computing MVP:
- *   glm_mat4_mul(proj, view, viewProj);
- *   glm_mat4_mul(viewProj, model, MVP);
- *
- * @param[in]  v  object coordinates
- * @param[in]  m  MVP matrix
- *
- * @returns projected z coordinate
- */
-CGLM_INLINE
-float
-glm_project_z_zo(vec3 v, mat4 m) {
-  float z, w;
-
-  z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
-  w = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
-
-  return z / w;
-}
-
-#endif /* cglm_project_zo_h */

external/cglm/clipspace/view_lh.h

@@ -1,99 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest)
- */
-
-#ifndef cglm_view_lh_h
-#define cglm_view_lh_h
-
-#include "../common.h"
-#include "../plane.h"
-
-/*!
- * @brief set up view matrix (LH)
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  center center vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-  CGLM_ALIGN(8) vec3 f, u, s;
-
-  glm_vec3_sub(center, eye, f);
-  glm_vec3_normalize(f);
-
-  glm_vec3_crossn(up, f, s);
-  glm_vec3_cross(f, s, u);
-
-  dest[0][0] = s[0];
-  dest[0][1] = u[0];
-  dest[0][2] = f[0];
-  dest[1][0] = s[1];
-  dest[1][1] = u[1];
-  dest[1][2] = f[1];
-  dest[2][0] = s[2];
-  dest[2][1] = u[2];
-  dest[2][2] = f[2];
-  dest[3][0] =-glm_vec3_dot(s, eye);
-  dest[3][1] =-glm_vec3_dot(u, eye);
-  dest[3][2] =-glm_vec3_dot(f, eye);
-  dest[0][3] = dest[1][3] = dest[2][3] = 0.0f;
-  dest[3][3] = 1.0f;
-}
-
-/*!
- * @brief set up view matrix with left handed coordinate system
- *
- * convenient wrapper for lookat: if you only have direction not target self
- * then this might be useful. Because you need to get target from direction.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-  CGLM_ALIGN(8) vec3 target;
-  glm_vec3_add(eye, dir, target);
-  glm_lookat_lh(eye, target, up, dest);
-}
-
-/*!
- * @brief set up view matrix with left handed coordinate system
- *
- * convenient wrapper for look: if you only have direction and if you don't
- * care what UP vector is then this might be useful to create view matrix
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest) {
-  CGLM_ALIGN(8) vec3 up;
-  glm_vec3_ortho(dir, up);
-  glm_look_lh(eye, dir, up, dest);
-}
-
-#endif /*cglm_view_lh_h*/

external/cglm/clipspace/view_lh_no.h

@@ -1,74 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest)
- */
-
-#ifndef cglm_view_lh_no_h
-#define cglm_view_lh_no_h
-
-#include "../common.h"
-#include "view_lh.h"
-
-/*!
- * @brief set up view matrix with left handed coordinate system.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  center center vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-  glm_lookat_lh(eye, center, up, dest);
-}
-
-/*!
- * @brief set up view matrix with left handed coordinate system.
- *
- * convenient wrapper for lookat: if you only have direction not target self
- * then this might be useful. Because you need to get target from direction.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-  glm_look_lh(eye, dir, up, dest);
-}
-
-/*!
- * @brief set up view matrix with left handed coordinate system.
- *
- * convenient wrapper for look: if you only have direction and if you don't
- * care what UP vector is then this might be useful to create view matrix
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest) {
-  glm_look_anyup_lh(eye, dir, dest);
-}
-
-#endif /*cglm_view_lh_no_h*/

external/cglm/clipspace/view_lh_zo.h

@@ -1,74 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest)
- */
-
-#ifndef cglm_view_lh_zo_h
-#define cglm_view_lh_zo_h
-
-#include "../common.h"
-#include "view_lh.h"
-
-/*!
- * @brief set up view matrix with left handed coordinate system.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  center center vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-  glm_lookat_lh(eye, center, up, dest);
-}
-
-/*!
- * @brief set up view matrix with left handed coordinate system.
- *
- * convenient wrapper for lookat: if you only have direction not target self
- * then this might be useful. Because you need to get target from direction.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-  glm_look_lh(eye, dir, up, dest);
-}
-
-/*!
- * @brief set up view matrix with left handed coordinate system.
- *
- * convenient wrapper for look: if you only have direction and if you don't
- * care what UP vector is then this might be useful to create view matrix
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest) {
-  glm_look_anyup_lh(eye, dir, dest);
-}
-
-#endif /*cglm_view_lh_zo_h*/

external/cglm/clipspace/view_rh.h

@@ -1,99 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest)
- */
-
-#ifndef cglm_view_rh_h
-#define cglm_view_rh_h
-
-#include "../common.h"
-#include "../plane.h"
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  center center vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-  CGLM_ALIGN(8) vec3 f, u, s;
-
-  glm_vec3_sub(center, eye, f);
-  glm_vec3_normalize(f);
-
-  glm_vec3_crossn(f, up, s);
-  glm_vec3_cross(s, f, u);
-
-  dest[0][0] = s[0];
-  dest[0][1] = u[0];
-  dest[0][2] =-f[0];
-  dest[1][0] = s[1];
-  dest[1][1] = u[1];
-  dest[1][2] =-f[1];
-  dest[2][0] = s[2];
-  dest[2][1] = u[2];
-  dest[2][2] =-f[2];
-  dest[3][0] =-glm_vec3_dot(s, eye);
-  dest[3][1] =-glm_vec3_dot(u, eye);
-  dest[3][2] = glm_vec3_dot(f, eye);
-  dest[0][3] = dest[1][3] = dest[2][3] = 0.0f;
-  dest[3][3] = 1.0f;
-}
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * convenient wrapper for lookat: if you only have direction not target self
- * then this might be useful. Because you need to get target from direction.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-  CGLM_ALIGN(8) vec3 target;
-  glm_vec3_add(eye, dir, target);
-  glm_lookat_rh(eye, target, up, dest);
-}
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * convenient wrapper for look: if you only have direction and if you don't
- * care what UP vector is then this might be useful to create view matrix
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest) {
-  CGLM_ALIGN(8) vec3 up;
-  glm_vec3_ortho(dir, up);
-  glm_look_rh(eye, dir, up, dest);
-}
-
-#endif /*cglm_view_rh_h*/

external/cglm/clipspace/view_rh_no.h

@@ -1,74 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest)
- */
-
-#ifndef cglm_view_rh_no_h
-#define cglm_view_rh_no_h
-
-#include "../common.h"
-#include "view_rh.h"
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  center center vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-  glm_lookat_rh(eye, center, up, dest);
-}
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * convenient wrapper for lookat: if you only have direction not target self
- * then this might be useful. Because you need to get target from direction.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-  glm_look_rh(eye, dir, up, dest);
-}
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * convenient wrapper for look: if you only have direction and if you don't
- * care what UP vector is then this might be useful to create view matrix
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest) {
-  glm_look_anyup_rh(eye, dir, dest);
-}
-
-#endif /*cglm_view_rh_no_h*/

external/cglm/clipspace/view_rh_zo.h

@@ -1,74 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest)
- */
-
-#ifndef cglm_view_rh_zo_h
-#define cglm_view_rh_zo_h
-
-#include "../common.h"
-#include "view_rh.h"
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  center center vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-  glm_lookat_rh(eye, center, up, dest);
-}
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * convenient wrapper for lookat: if you only have direction not target self
- * then this might be useful. Because you need to get target from direction.
- *
- * NOTE: The UP vector must not be parallel to the line of sight from
- *       the eye point to the reference point
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-  glm_look_rh(eye, dir, up, dest);
-}
-
-/*!
- * @brief set up view matrix with right handed coordinate system.
- *
- * convenient wrapper for look: if you only have direction and if you don't
- * care what UP vector is then this might be useful to create view matrix
- *
- * @param[in]  eye    eye vector
- * @param[in]  dir    direction vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest) {
-  glm_look_anyup_rh(eye, dir, dest);
-}
-
-#endif /*cglm_view_rh_zo_h*/

external/cglm/color.h

@@ -1,26 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_color_h
-#define cglm_color_h
-
-#include "common.h"
-#include "vec3.h"
-
-/*!
- * @brief averages the color channels into one value
- *
- * @param[in]  rgb RGB color
- */
-CGLM_INLINE
-float
-glm_luminance(vec3 rgb) {
-  vec3 l = {0.212671f, 0.715160f, 0.072169f};
-  return glm_dot(rgb, l);
-}
-
-#endif /* cglm_color_h */

external/cglm/common.h

@@ -1,130 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_common_h
-#define cglm_common_h
-
-#define __cglm__ 1
-
-#ifndef _USE_MATH_DEFINES
-#  define _USE_MATH_DEFINES       /* for windows */
-#endif
-
-#ifndef _CRT_SECURE_NO_WARNINGS
-#  define _CRT_SECURE_NO_WARNINGS /* for windows */
-#endif
-
-#include <stdint.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <math.h>
-#include <float.h>
-#include <stdbool.h>
-
-#if defined(_MSC_VER)
-#  ifdef CGLM_STATIC
-#    define CGLM_EXPORT
-#  elif defined(CGLM_EXPORTS)
-#    define CGLM_EXPORT __declspec(dllexport)
-#  else
-#    define CGLM_EXPORT __declspec(dllimport)
-#  endif
-#  define CGLM_INLINE __forceinline
-#else
-#  define CGLM_EXPORT __attribute__((visibility("default")))
-#  define CGLM_INLINE static inline __attribute((always_inline))
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-#  define CGLM_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
-#  define CGLM_LIKELY(expr)   __builtin_expect(!!(expr), 1)
-#else
-#  define CGLM_UNLIKELY(expr) (expr)
-#  define CGLM_LIKELY(expr)   (expr)
-#endif
-
-#if defined(_M_FP_FAST) || defined(__FAST_MATH__)
-#  define CGLM_FAST_MATH
-#endif
-
-#define GLM_SHUFFLE4(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w))
-#define GLM_SHUFFLE3(z, y, x)    (((z) << 4) | ((y) << 2) | (x))
-#define GLM_SHUFFLE2(y, x)       (((y) << 2) | (x))
-
-#include "types.h"
-#include "simd/intrin.h"
-
-#ifndef CGLM_USE_DEFAULT_EPSILON
-#  ifndef GLM_FLT_EPSILON
-#    define GLM_FLT_EPSILON 1e-5f
-#  endif
-#else
-#  define GLM_FLT_EPSILON FLT_EPSILON
-#endif
-
-/*
- * Clip control: define CGLM_FORCE_DEPTH_ZERO_TO_ONE before including
- * CGLM to use a clip space between 0 to 1.
- * Coordinate system: define CGLM_FORCE_LEFT_HANDED before including
- * CGLM to use the left handed coordinate system by default.
- */
-
-#define CGLM_CLIP_CONTROL_ZO_BIT (1 << 0) /* ZERO_TO_ONE */
-#define CGLM_CLIP_CONTROL_NO_BIT (1 << 1) /* NEGATIVE_ONE_TO_ONE */
-#define CGLM_CLIP_CONTROL_LH_BIT (1 << 2) /* LEFT_HANDED, For DirectX, Metal, Vulkan */
-#define CGLM_CLIP_CONTROL_RH_BIT (1 << 3) /* RIGHT_HANDED, For OpenGL, default in GLM */
-
-#define CGLM_CLIP_CONTROL_LH_ZO (CGLM_CLIP_CONTROL_LH_BIT | CGLM_CLIP_CONTROL_ZO_BIT)
-#define CGLM_CLIP_CONTROL_LH_NO (CGLM_CLIP_CONTROL_LH_BIT | CGLM_CLIP_CONTROL_NO_BIT)
-#define CGLM_CLIP_CONTROL_RH_ZO (CGLM_CLIP_CONTROL_RH_BIT | CGLM_CLIP_CONTROL_ZO_BIT)
-#define CGLM_CLIP_CONTROL_RH_NO (CGLM_CLIP_CONTROL_RH_BIT | CGLM_CLIP_CONTROL_NO_BIT)
-
-#ifdef CGLM_FORCE_DEPTH_ZERO_TO_ONE
-#  ifdef CGLM_FORCE_LEFT_HANDED
-#    define CGLM_CONFIG_CLIP_CONTROL CGLM_CLIP_CONTROL_LH_ZO
-#  else
-#    define CGLM_CONFIG_CLIP_CONTROL CGLM_CLIP_CONTROL_RH_ZO
-#  endif
-#else
-#  ifdef CGLM_FORCE_LEFT_HANDED
-#    define CGLM_CONFIG_CLIP_CONTROL CGLM_CLIP_CONTROL_LH_NO
-#  else
-#    define CGLM_CONFIG_CLIP_CONTROL CGLM_CLIP_CONTROL_RH_NO
-#  endif
-#endif
-
-/* struct API configurator */
-/* TODO: move struct/common.h? */
-/* WARN: dont use concant helpers outside cglm headers, because they may be changed */
-
-#define CGLM_MACRO_CONCAT_HELPER(A, B, C, D, E, ...) A ## B ## C ## D ## E ## __VA_ARGS__
-#define CGLM_MACRO_CONCAT(A, B, C, D, E, ...) CGLM_MACRO_CONCAT_HELPER(A, B, C, D, E,__VA_ARGS__)
-
-#ifndef CGLM_OMIT_NS_FROM_STRUCT_API
-#  ifndef CGLM_STRUCT_API_NS
-#    define CGLM_STRUCT_API_NS glms
-#  endif
-#  ifndef CGLM_STRUCT_API_NS_SEPERATOR
-#    define CGLM_STRUCT_API_NS_SEPERATOR _
-#  endif
-#else
-#  define CGLM_STRUCT_API_NS
-#  define CGLM_STRUCT_API_NS_SEPERATOR
-#endif
-
-#ifndef CGLM_STRUCT_API_NAME_SUFFIX
-#  define CGLM_STRUCT_API_NAME_SUFFIX
-#endif
-
-#define CGLM_STRUCTAPI(A, ...) CGLM_MACRO_CONCAT(CGLM_STRUCT_API_NS,             \
-                                                 CGLM_STRUCT_API_NS_SEPERATOR,   \
-                                                 A,                              \
-                                                 CGLM_STRUCT_API_NAME_SUFFIX,    \
-                                                 _,                              \
-                                                 __VA_ARGS__)
-
-#endif /* cglm_common_h */

external/cglm/curve.h

@@ -1,40 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_curve_h
-#define cglm_curve_h
-
-#include "common.h"
-#include "vec4.h"
-#include "mat4.h"
-
-/*!
- * @brief helper function to calculate S*M*C multiplication for curves
- *
- * This function does not encourage you to use SMC,
- * instead it is a helper if you use SMC.
- *
- * if you want to specify S as vector then use more generic glm_mat4_rmc() func.
- *
- * Example usage:
- *  B(s) = glm_smc(s, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
- *
- * @param[in]  s  parameter between 0 and 1 (this will be [s3, s2, s, 1])
- * @param[in]  m  basis matrix
- * @param[in]  c  position/control vector
- *
- * @return B(s)
- */
-CGLM_INLINE
-float
-glm_smc(float s, mat4 m, vec4 c) {
-  vec4 vs;
-  glm_vec4_cubic(s, vs);
-  return glm_mat4_rmc(vs, m, c);
-}
-
-#endif /* cglm_curve_h */

external/cglm/ease.h

@@ -1,317 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_ease_h
-#define cglm_ease_h
-
-#include "common.h"
-
-CGLM_INLINE
-float
-glm_ease_linear(float t) {
-  return t;
-}
-
-CGLM_INLINE
-float
-glm_ease_sine_in(float t) {
-  return sinf((t - 1.0f) * GLM_PI_2f) + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_sine_out(float t) {
-  return sinf(t * GLM_PI_2f);
-}
-
-CGLM_INLINE
-float
-glm_ease_sine_inout(float t) {
-  return 0.5f * (1.0f - cosf(t * GLM_PIf));
-}
-
-CGLM_INLINE
-float
-glm_ease_quad_in(float t) {
-  return t * t;
-}
-
-CGLM_INLINE
-float
-glm_ease_quad_out(float t) {
-  return -(t * (t - 2.0f));
-}
-
-CGLM_INLINE
-float
-glm_ease_quad_inout(float t) {
-  float tt;
-
-  tt = t * t;
-  if (t < 0.5f)
-    return 2.0f * tt;
-
-  return (-2.0f * tt) + (4.0f * t) - 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_cubic_in(float t) {
-  return t * t * t;
-}
-
-CGLM_INLINE
-float
-glm_ease_cubic_out(float t) {
-  float f;
-  f = t - 1.0f;
-  return f * f * f + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_cubic_inout(float t) {
-  float f;
-
-  if (t < 0.5f)
-    return 4.0f * t * t * t;
-
-  f = 2.0f * t - 2.0f;
-
-  return 0.5f * f * f * f + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_quart_in(float t) {
-  float f;
-  f = t * t;
-  return f * f;
-}
-
-CGLM_INLINE
-float
-glm_ease_quart_out(float t) {
-  float f;
-
-  f = t - 1.0f;
-
-  return f * f * f * (1.0f - t) + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_quart_inout(float t) {
-  float f, g;
-
-  if (t < 0.5f) {
-    f = t * t;
-    return 8.0f * f * f;
-  }
-
-  f = t - 1.0f;
-  g = f * f;
-
-  return -8.0f * g * g + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_quint_in(float t) {
-  float f;
-  f = t * t;
-  return f * f * t;
-}
-
-CGLM_INLINE
-float
-glm_ease_quint_out(float t) {
-  float f, g;
-
-  f = t - 1.0f;
-  g = f * f;
-
-  return g * g * f + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_quint_inout(float t) {
-  float f, g;
-
-  if (t < 0.5f) {
-    f = t * t;
-    return 16.0f * f * f * t;
-  }
-
-  f = 2.0f * t - 2.0f;
-  g = f * f;
-
-  return 0.5f * g * g * f + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_exp_in(float t) {
-  if (t == 0.0f)
-    return t;
-
-  return powf(2.0f,  10.0f * (t - 1.0f));
-}
-
-CGLM_INLINE
-float
-glm_ease_exp_out(float t) {
-  if (t == 1.0f)
-    return t;
-
-  return 1.0f - powf(2.0f, -10.0f * t);
-}
-
-CGLM_INLINE
-float
-glm_ease_exp_inout(float t) {
-  if (t == 0.0f || t == 1.0f)
-    return t;
-
-  if (t < 0.5f)
-    return 0.5f * powf(2.0f, (20.0f * t) - 10.0f);
-
-  return -0.5f * powf(2.0f, (-20.0f * t) + 10.0f) + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_circ_in(float t) {
-  return 1.0f - sqrtf(1.0f - (t * t));
-}
-
-CGLM_INLINE
-float
-glm_ease_circ_out(float t) {
-  return sqrtf((2.0f - t) * t);
-}
-
-CGLM_INLINE
-float
-glm_ease_circ_inout(float t) {
-  if (t < 0.5f)
-    return 0.5f * (1.0f - sqrtf(1.0f - 4.0f * (t * t)));
-
-  return 0.5f * (sqrtf(-((2.0f * t) - 3.0f) * ((2.0f * t) - 1.0f)) + 1.0f);
-}
-
-CGLM_INLINE
-float
-glm_ease_back_in(float t) {
-  float o, z;
-
-  o = 1.70158f;
-  z = ((o + 1.0f) * t) - o;
-
-  return t * t * z;
-}
-
-CGLM_INLINE
-float
-glm_ease_back_out(float t) {
-  float o, z, n;
-
-  o = 1.70158f;
-  n = t - 1.0f;
-  z = (o + 1.0f) * n + o;
-
-  return n * n * z + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_back_inout(float t) {
-  float o, z, n, m, s, x;
-
-  o = 1.70158f;
-  s = o * 1.525f;
-  x = 0.5f;
-  n = t / 0.5f;
-
-  if (n < 1.0f) {
-    z = (s + 1) * n - s;
-    m = n * n * z;
-    return x * m;
-  }
-
-  n -= 2.0f;
-  z  = (s + 1.0f) * n + s;
-  m  = (n * n * z) + 2;
-
-  return x * m;
-}
-
-CGLM_INLINE
-float
-glm_ease_elast_in(float t) {
-  return sinf(13.0f * GLM_PI_2f * t) * powf(2.0f, 10.0f * (t - 1.0f));
-}
-
-CGLM_INLINE
-float
-glm_ease_elast_out(float t) {
-  return sinf(-13.0f * GLM_PI_2f * (t + 1.0f)) * powf(2.0f, -10.0f * t) + 1.0f;
-}
-
-CGLM_INLINE
-float
-glm_ease_elast_inout(float t) {
-  float a;
-
-  a = 2.0f * t;
-
-  if (t < 0.5f)
-    return 0.5f * sinf(13.0f * GLM_PI_2f * a)
-                * powf(2.0f, 10.0f * (a - 1.0f));
-
-  return 0.5f * (sinf(-13.0f * GLM_PI_2f * a)
-                 * powf(2.0f, -10.0f * (a - 1.0f)) + 2.0f);
-}
-
-CGLM_INLINE
-float
-glm_ease_bounce_out(float t) {
-  float tt;
-
-  tt = t * t;
-
-  if (t < (4.0f / 11.0f))
-    return (121.0f * tt) / 16.0f;
-
-  if (t < 8.0f / 11.0f)
-    return ((363.0f / 40.0f) * tt) - ((99.0f / 10.0f) * t) + (17.0f / 5.0f);
-
-  if (t < (9.0f / 10.0f))
-    return (4356.0f / 361.0f) * tt
-            - (35442.0f / 1805.0f) * t
-            + (16061.0f / 1805.0f);
-
-  return ((54.0f / 5.0f) * tt) - ((513.0f / 25.0f) * t) + (268.0f / 25.0f);
-}
-
-CGLM_INLINE
-float
-glm_ease_bounce_in(float t) {
-  return 1.0f - glm_ease_bounce_out(1.0f - t);
-}
-
-CGLM_INLINE
-float
-glm_ease_bounce_inout(float t) {
-  if (t < 0.5f)
-    return 0.5f * (1.0f - glm_ease_bounce_out(t * 2.0f));
-
-  return 0.5f * glm_ease_bounce_out(t * 2.0f - 1.0f) + 0.5f;
-}
-
-#endif /* cglm_ease_h */