/* CONFIGURATION: #define these before including oogabooga.c to configure All configuration properties has default values if you do not explicitly #define them. - ENTRY_PROC Define this as whatever the entry procedure of your program should be. Example: #define ENTRY_PROC my_entry void entry_proc(int, char**) { // ... } Note: void entry_proc(int, char**); - DO_ZERO_INITIALIZATION 0: Disable zero initialization 1: Enable zero initialization Example: // Disable zero initialization #define DO_ZERO_INITIALIZATION 0 Note: Zero initialization only happens to memory allocated with the alloc() procedure. - ENABLE_SIMD 0: Disable SIMD 1: Enable SIMD Example: // Disable simd #define ENABLE_SIMD 0 - Simd Extensions 0: Disable 1: Enable Possible extensions: SIMD_ENABLE_SSE2 SIMD_ENABLE_SSE41 SIMD_ENABLE_AVX SIMD_ENABLE_AVX2 SIMD_ENABLE_AVX512 Example: // Enable SSE2 Extension #define SIMD_ENABLE_SSE2 1 Note: I recommend that you do not touch this unless you know what you're doing. These may require you to pass the respective instruction set flag to your compiler. For compatilibility reasons, all simd extensions are disabled by default. - INITIAL_PROGRAM_MEMORY_SIZE Defines this as the size in number of bytes you want the initial allocation for your program memory to be. This will grow dynamically as needed. You can use helper macros KB, MB, GB. Example: #define INITIAL_PROGRAM_MEMORY_SIZE (MB(10)) Note: This is not guaranteed to be exactly what you set it to because we have minimum requirements for example to fit the temporary storage in program memory. It's more of a rough guideline. - RUN_TESTS Run ooga booga tests. 0: Disable 1: Enable Example: #define RUN_TESTS 1 - ENABLE_PROFILING Enable time profiling which will be dumped to google_trace.json. 0: Disable 1: Enable Example: #define ENABLE_PROFILING 1 Note: See timing macros in profile.c tm_scope tm_scope_var tm_scope_accum - OOGABOOGA_HEADLESS Run oogabooga in headless mode, i.e. no window, no graphics, no audio. Useful if you only need the oogabooga standard library for something like a game server. 0: Disable 1: Enable Example: #define OOGABOOGA_HEADLESS 1 */ #define OGB_VERSION_MAJOR 0 #define OGB_VERSION_MINOR 1 #define OGB_VERSION_PATCH 3 #define OGB_VERSION (OGB_VERSION_MAJOR*1000000+OGB_VERSION_MINOR*1000+OGB_VERSION_PATCH) #include #include #include #include typedef uint8_t u8; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef int8_t s8; typedef int16_t s16; typedef int32_t s32; typedef int64_t s64; typedef u8 uint8; typedef s8 int8; typedef u16 uint16; typedef s16 int16; typedef u32 uint32; typedef s32 int32; typedef u64 uint64; typedef s64 int64; typedef float f32; typedef double f64; typedef f32 float32; typedef f64 float64; #define F32_MAX 3.402823466e+38F #define F32_MIN 1.175494351e-38F typedef u8 bool; #define false 0 #define true 1 // Determine what compiler we are on #ifdef __clang__ #define COMPILER_CLANG 1 #elif defined(__GNUC__) || defined(__GNUG__) #define COMPILER_GCC 1 #elif defined(_MSC_VER) #define COMPILER_MSVC 1 #else #define COMPILER_UNKNOWN 1 #warning "Compiler is not explicitly supported, some things will probably not work as expected" #endif #define DEBUG 0 #define RELEASE 2 #if defined(NDEBUG) #define CONFIGURATION RELEASE #else #define CONFIGURATION DEBUG #endif #include "cpu.c" #ifndef ENTRY_PROC #define ENTRY_PROC entry #endif #ifndef DO_ZERO_INITIALIZATION #define DO_ZERO_INITIALIZATION 1 #endif #ifndef ENABLE_SIMD #define ENABLE_SIMD 1 #endif #ifndef INITIAL_PROGRAM_MEMORY_SIZE #define INITIAL_PROGRAM_MEMORY_SIZE MB(5) #endif #if ENABLE_SIMD && !defined(SIMD_ENABLE_SSE2) #if COMPILER_CAN_DO_SSE2 #define SIMD_ENABLE_SSE2 1 #else #define SIMD_ENABLE_SSE2 0 #endif #endif #if ENABLE_SIMD && !defined(SIMD_ENABLE_SSE41) #define SIMD_ENABLE_SSE41 0 #endif #if ENABLE_SIMD && !defined(SIMD_ENABLE_AVX) #define SIMD_ENABLE_AVX 0 #endif #if ENABLE_SIMD && !defined(SIMD_ENABLE_AVX2) #define SIMD_ENABLE_AVX2 0 #endif #if ENABLE_SIMD && !defined(SIMD_ENABLE_AVX512) #define SIMD_ENABLE_AVX512 0 #endif #define WINDOWS 0 #define LINUX 1 #define MACOS 2 #ifdef _WIN32 #define COBJMACROS #undef noreturn #include #if CONFIGURATION == DEBUG #include #endif #define TARGET_OS WINDOWS #define OS_PATHS_HAVE_BACKSLASH 1 #elif defined(__linux__) // Include whatever #Incomplete #Portability #define TARGET_OS LINUX #error "Linux is not supported yet"; #define OS_PATHS_HAVE_BACKSLASH 0 #elif defined(__APPLE__) && defined(__MACH__) // Include whatever #Incomplete #Portability #define TARGET_OS MACOS #error "Macos is not supported yet"; #define OS_PATHS_HAVE_BACKSLASH 1 #else #error "Current OS not supported!"; #endif #if OOGABOOGA_LINK_EXTERNAL_INSTANCE #define ogb_instance SHARED_IMPORT extern #elif OOGABOOGA_BUILD_SHARED_LIBRARY #define ogb_instance SHARED_EXPORT #else #define ogb_instance #endif // This needs to be included before dependencies #include "base.c" #include "simd.c" // #Incomplete // We might want to make this configurable ? #define GFX_RENDERER_D3D11 0 #define GFX_RENDERER_VULKAN 1 #define GFX_RENDERER_METAL 2 #ifndef GFX_RENDERER // #Portability #if TARGET_OS == WINDOWS #define GFX_RENDERER GFX_RENDERER_D3D11 #elif TARGET_OS == LINUX #define GFX_RENDERER GFX_RENDERER_VULKAN #elif TARGET_OS == MACOS #define GFX_RENDERER GFX_RENDERER_METAL #endif #endif #include "string.c" #include "unicode.c" #include "string_format.c" #include "hash.c" #include "path_utils.c" #include "linmath.c" #include "utility.c" #include "hash_table.c" #include "growing_array.c" #include "os_interface.c" /// /// // Dependencies /// // The reason dependencies are compiled here is because we need to modify third party code // to use the oogabooga standard where they use the C standard. #include "third_party.c" ///// #include "concurrency.c" #include "profiling.c" #include "random.c" #include "color.c" #include "memory.c" #include "input.c" #ifndef OOGABOOGA_HEADLESS #include "gfx_interface.c" #include "font.c" #include "drawing.c" #include "audio.c" #endif #if !OOGABOOGA_LINK_EXTERNAL_INSTANCE #if TARGET_OS == WINDOWS #include "os_impl_windows.c" #elif TARGET_OS == LINUX #include "os_impl_linux.c" #elif TARGET_OS == MACOS #error "Macos is not supported yet" #else #error "Current OS is not supported" #endif #ifndef OOGABOOGA_HEADLESS // #Portability #if GFX_RENDERER == GFX_RENDERER_D3D11 #include "gfx_impl_d3d11.c" #elif GFX_RENDERER == GFX_RENDERER_VULKAN #error "We only have a D3D11 renderer at the moment" #elif GFX_RENDERER == GFX_RENDERER_METAL #error "We only have a D3D11 renderer at the moment" #else #error "Unknown renderer GFX_RENDERER defined" #endif #endif #endif // NOT OOGABOOGA_LINK_EXTERNAL_INSTANCE #include "tests.c" #define malloc please_use_alloc_for_memory_allocations_instead_of_malloc #define free please_use_dealloc_for_memory_deallocations_instead_of_free Mutex _default_logger_mutex; bool _default_logger_mutex_initted = false; void default_logger(Log_Level level, string s) { if (!_default_logger_mutex_initted) { mutex_init(&_default_logger_mutex); _default_logger_mutex_initted = true; } mutex_acquire_or_wait(&_default_logger_mutex); switch (level) { case LOG_VERBOSE: print("[VERBOSE]: %s\n", s); break; case LOG_INFO: print("[INFO]: %s\n", s); break; case LOG_WARNING: print("[WARNING]: %s\n", s); break; case LOG_ERROR: print("[ERROR]: %s\n", s); break; case LOG_LEVEL_COUNT: break; } mutex_release(&_default_logger_mutex); } ogb_instance void oogabooga_init(u64 program_memory_size); #if !OOGABOOGA_LINK_EXTERNAL_INSTANCE void oogabooga_init(u64 program_memory_size) { context.logger = default_logger; temp_allocator = get_initialization_allocator(); Cpu_Capabilities features = query_cpu_capabilities(); os_init(program_memory_size); heap_init(); temporary_storage_init(TEMPORARY_STORAGE_SIZE); log_info("Ooga booga version is %d.%02d.%03d", OGB_VERSION_MAJOR, OGB_VERSION_MINOR, OGB_VERSION_PATCH); #ifndef OOGABOOGA_HEADLESS gfx_init(); #else log_info("Headless mode on"); #endif log_verbose("CPU has sse1: %cs", features.sse1 ? "true" : "false"); log_verbose("CPU has sse2: %cs", features.sse2 ? "true" : "false"); log_verbose("CPU has sse3: %cs", features.sse3 ? "true" : "false"); log_verbose("CPU has ssse3: %cs", features.ssse3 ? "true" : "false"); log_verbose("CPU has sse41: %cs", features.sse41 ? "true" : "false"); log_verbose("CPU has sse42: %cs", features.sse42 ? "true" : "false"); log_verbose("CPU has avx: %cs", features.avx ? "true" : "false"); log_verbose("CPU has avx2: %cs", features.avx2 ? "true" : "false"); log_verbose("CPU has avx512: %cs", features.avx512 ? "true" : "false"); } #endif int ENTRY_PROC(int argc, char **argv); #if !OOGABOOGA_LINK_EXTERNAL_INSTANCE #if OOGABOOGA_BUILD_SHARED_LIBRARY int SHARED_EXPORT main(int argc, char **argv) { #else int main(int argc, char **argv) { #endif print("Ooga booga program started\n"); oogabooga_init(INITIAL_PROGRAM_MEMORY_SIZE); assert(sizeof(Vector3) == 12, "%d", sizeof(Vector3)); assert(sizeof(Vector2) == 8 , "%d", sizeof(Vector2)); assert(sizeof(Vector4) == 16, "%d", sizeof(Vector4)); assert(main != ENTRY_PROC, "You've ooga'd your last booga"); #if RUN_TESTS oogabooga_run_tests(); #endif int code = ENTRY_PROC(argc, argv); #if ENABLE_PROFILING dump_profile_result(); #endif printf("Ooga booga program exit with code %i\n", code); return code; } #endif // I hope whoever caused this @ microsoft is fired. #ifdef near #undef near #endif #ifdef far #undef far #endif