From: hgn Date: Mon, 27 May 2024 17:58:52 +0000 (+0100) Subject: build tool change X-Git-Url: https://harrygodden.com/git/?a=commitdiff_plain;h=28583723b201a6d6555b1d74b82ed6022bedf4f6;p=vg.git build tool change --- diff --git a/submodules/SDL_GameControllerDB b/submodules/SDL_GameControllerDB index c5b4df0..6ed8d05 160000 --- a/submodules/SDL_GameControllerDB +++ b/submodules/SDL_GameControllerDB @@ -1 +1 @@ -Subproject commit c5b4df0e1061175cb11e3ebbf8045178339864a5 +Subproject commit 6ed8d054340ee8a93a684e11360b66cd8a5c168e diff --git a/submodules/anyascii b/submodules/anyascii index eb5332d..44e971c 160000 --- a/submodules/anyascii +++ b/submodules/anyascii @@ -1 +1 @@ -Subproject commit eb5332d0b5e48d58397e6f27475a18e058330d23 +Subproject commit 44e971c774d9ec67ca6c1f16c5a476724821ab63 diff --git a/submodules/qoi b/submodules/qoi index dfc056e..b8d77df 160000 --- a/submodules/qoi +++ b/submodules/qoi @@ -1 +1 @@ -Subproject commit dfc056e813c98d307238d35f7f041a725d699dfc +Subproject commit b8d77df1e80b652a57f0b7270449b179a6b91f40 diff --git a/submodules/stb b/submodules/stb index 5736b15..8b5f1f3 160000 --- a/submodules/stb +++ b/submodules/stb @@ -1 +1 @@ -Subproject commit 5736b15f7ea0ffb08dd38af21067c314d6a3aae9 +Subproject commit 8b5f1f37b5b75829fc72d38e7b5d4bcbf8a26d55 diff --git a/vg_build.h b/vg_build.h index f284821..35ddc4c 100644 --- a/vg_build.h +++ b/vg_build.h @@ -1,5 +1,3 @@ -/* zig cc scripting tools */ - #include #include #include @@ -14,12 +12,15 @@ /* we dont free dynamic vg_strs in this program. so, we dont care.. */ const char *__asan_default_options() { return "detect_leaks=0"; } -struct vg_env +struct vg_project { - u32 optimization; + vg_str uid, bin_folder; +}; - bool fresh, - debug_asan; +struct vg_compiler_env +{ + u32 optimization; + bool debug_asan; enum platform { @@ -55,59 +56,31 @@ struct vg_env k_libc_version_2_23, } libc; -}; - -struct vg_env vg_test_env = { - .arch = k_architecture_x86_64, - .compiler = k_compiler_clang, - .libc = k_libc_version_native, +} +vg_test_env = +{ + .optimization = 0, .debug_asan = 1, - .fresh = 0, .platform = k_platform_linux, - .optimization = 0 -}; - -struct vg_env vg_release_env = { .arch = k_architecture_x86_64, - .compiler = k_compiler_zigcc, - .libc = k_libc_version_2_23, - .fresh = 1, - .optimization = 3, - .platform = k_platform_anyplatform, - .debug_asan = 0 + .compiler = k_compiler_clang, + .libc = k_libc_version_native }; -struct vg_env vg_test_android_env = { - .arch = k_architecture_armv7a, - .compiler = k_compiler_clang_android, - .libc = k_libc_version_native, - .debug_asan = 0, - .fresh = 0, - .platform = k_platform_android, - .optimization = 0 +struct vg_compiler_conf +{ + vg_str include, + library, + link, + defines; }; -struct vg_project +enum obj_type { - struct vg_env *env; - - vg_str include, /* -I */ - library, /* -L */ - link, /* -llibrary */ - sources, /* file.c obj.o */ - uid, /* env/project identifier */ - target, /* result object name */ - - /* generated */ - compiled_objects; /* space seperated paths to compiled objects */ - - enum obj_type { - k_obj_type_none, - k_obj_type_exe, - k_obj_type_obj, - k_obj_type_shared, - } - type; + k_obj_type_none, + k_obj_type_exe, + k_obj_type_obj, + k_obj_type_shared, }; /* @@ -139,59 +112,12 @@ static const char *compiler_names[] = [k_compiler_clang_android] = "clang" }; -static const char *compiler_paths[] = -{ - [k_compiler_blob] = NULL, - [k_compiler_clang] = "clang", - [k_compiler_zigcc] = "zig cc", - [k_compiler_clang_android] = "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/bin/clang \\\n-target armv7a-linux-androideabi22 \\\n" -}; - static const char *libc_names[] = { [k_libc_version_native] = "", [k_libc_version_2_23] = ".2.23" }; -/* - * source specification - * -------------------------------------------------------------------------- */ - -void vg_add_source( struct vg_project *proj, const char *source ) -{ - if( proj->type == k_obj_type_none ) - vg_fatal_error( "Cannot add source code without setting binary type\n" ); - - vg_strcat( &proj->sources, source ); - vg_strcat( &proj->sources, " " ); -} - -void vg_include_dir( struct vg_project *proj, const char *dir ) -{ - if( proj->type == k_obj_type_none ) - vg_fatal_error( "Cannot add include dir without setting binary type\n" ); - - vg_strcat( &proj->include, dir ); - vg_strcat( &proj->include, " " ); -} - -void vg_library_dir( struct vg_project *proj, const char *dir ) -{ - if( proj->type == k_obj_type_none ) - vg_fatal_error( "Cannot add library dir without setting binary type\n" ); - - vg_strcat( &proj->library, dir ); - vg_strcat( &proj->library, " " ); -} - -void vg_link( struct vg_project *proj, const char *lib ) -{ - if( proj->type == k_obj_type_none ) - vg_fatal_error( "Cannot link library without setting binary type\n" ); - - vg_strcat( &proj->link, lib ); -} - /* * OS & file tools * -------------------------------------------------------------------------- */ @@ -212,14 +138,14 @@ void vg_syscall( const char *fmt, ... ) void vg_add_blob( struct vg_project *proj, const char *blob, const char *dest ) { - vg_syscall( "cp %s bin/%s/%s", blob, proj->uid.buffer, dest ); + vg_syscall( "cp %s %s/%s", blob, proj->bin_folder.buffer, dest ); } void vg_symlink( struct vg_project *proj, const char *folder, const char *bin_name ) { char dest[512]; - snprintf( dest, 512, "bin/%s/%s", proj->uid.buffer, bin_name ); + snprintf( dest, 512, "%s/%s", proj->bin_folder.buffer, bin_name ); if( !access( dest, F_OK ) ) vg_syscall( "unlink %s", dest ); vg_syscall( "ln -srf %s %s", folder, dest ); @@ -227,8 +153,8 @@ void vg_symlink( struct vg_project *proj, void vg_tarball_project( struct vg_project *proj ) { - vg_syscall( "tar -chzvf dist/%s-%u.tar.gz bin/%s/", - proj->uid.buffer, time(NULL), proj->uid.buffer ); + vg_syscall( "tar -chzvf dist/%s-%u.tar.gz %s/", + proj->uid.buffer, time(NULL), proj->bin_folder.buffer ); } bool vg_platform_posix( enum platform p ) @@ -238,135 +164,98 @@ bool vg_platform_posix( enum platform p ) } /* - * The project configurator and compiler. + * Project * -------------------------------------------------------------------------- */ -void vg_project_new_target( struct vg_project *proj, const char *name, - enum obj_type type ) +/* Initialize the project structure, proj, + * IN folder/name, + * CLEAR IF fresh + */ +void vg_project_init( struct vg_project *proj, + const char *folder, + const char *name, + bool fresh ) { - proj->type = type; - - vg_strnull( &proj->include, NULL, -1 ); - vg_strnull( &proj->library, NULL, -1 ); - vg_strnull( &proj->link, NULL, -1 ); - vg_strnull( &proj->sources, NULL, -1 ); - vg_strnull( &proj->target, NULL, -1 ); - - /* - * Setup target with appropriate extension - */ - vg_strcat( &proj->target, name ); - - if( proj->env->platform == k_platform_windows ) - { - if( type == k_obj_type_exe ) - vg_strcat( &proj->target, ".exe" ); - else if( type == k_obj_type_shared ) - vg_strcat( &proj->target, ".dll" ); - else if( type == k_obj_type_obj ) - vg_strcat( &proj->target, ".obj" ); - } - - - if( vg_platform_posix( proj->env->platform ) ) - { - if( type == k_obj_type_shared ) - vg_strcat( &proj->target, ".so" ); - else if( type == k_obj_type_obj ) - vg_strcat( &proj->target, ".o" ); - } - - /* - * Add some regular includes / library dirs - */ - if( type != k_obj_type_none ) - { - vg_include_dir( proj, "-I." ); - vg_include_dir( proj, "-I./vg" ); -#if 0 - vg_library_dir( proj, "-L." ); - vg_library_dir( proj, "-L/usr/lib" ); -#endif - } - - vg_info( " New target: %s\n", name ); + vg_strnull( &proj->uid, NULL, 0 ); + vg_strcat( &proj->uid, name ); + + vg_strnull( &proj->bin_folder, NULL, 0 ); + vg_strcat( &proj->bin_folder, folder ); + vg_strcat( &proj->bin_folder, "/" ); + vg_strcat( &proj->bin_folder, proj->uid.buffer ); + + vg_info( "project_init: %s (fresh: %s)\n (%s)\n", + name, + fresh? "yes":"no", + proj->bin_folder.buffer ); + + if( fresh ) + vg_syscall( "rm -rf %s", proj->bin_folder.buffer ); + vg_syscall( "mkdir -p %s", proj->bin_folder.buffer ); } -void vg_project_init( struct vg_project *proj, - struct vg_env *env, - const char *identifier ) +struct compile_result { - proj->env = env; - proj->type = k_obj_type_none; - - vg_strnull( &proj->uid, NULL, -1 ); - vg_strnull( &proj->compiled_objects, NULL, -1 ); + vg_str path, + rel_path; +}; +/* run a compiler.. return compiled object relative to project folder + */ +struct compile_result +vg_compiler_run( struct vg_project *project, + struct vg_compiler_env *env, + struct vg_compiler_conf *conf, + const char *sources, + const char *target_name, + enum obj_type type ) +{ /* check for problems in configuration */ if( env->libc != k_libc_version_native ) - { if( env->compiler != k_compiler_zigcc ) - { vg_fatal_error( "Cannot specify libc version using the '%s' compiler.\n", compiler_names[ env->compiler ] ); - } - } if( env->compiler == k_compiler_clang ) - { if( env->platform != k_platform_linux ) - { vg_fatal_error( "Cannot compile for '%s' using the '%s' compiler;" ); - } - } if( env->compiler == k_compiler_clang_android ) - { if( env->platform != k_platform_android ) - { vg_fatal_error( "Cannot compile for '%s' using the '%s' compiler;" ); - } - } - - vg_strcat( &proj->uid, identifier ); - vg_strcatch( &proj->uid, '-' ); - vg_strcat( &proj->uid, platform_names[ env->platform ] ); - vg_strcatch( &proj->uid, '-' ); - vg_strcat( &proj->uid, architecture_names[ env->arch ] ); - vg_strcatch( &proj->uid, '-' ); - vg_strcat( &proj->uid, compiler_names[ env->compiler ] ); - - if( proj->uid.i < 3 ) - vg_fatal_error( "failed to create project UID\n" ); - - vg_info( "project_init: %s (%s, %s, compiler: %s, opt:%u, fresh: %s)\n", - identifier, - platform_names[env->platform], - architecture_names[env->arch], - compiler_names[env->compiler], - env->optimization, - env->fresh? "yes":"no"); - - if( env->fresh ) - vg_syscall( "rm -rf bin/%s", proj->uid.buffer ); - vg_syscall( "mkdir -p bin/%s", proj->uid.buffer ); -} -void vg_compile_project( struct vg_project *proj ) -{ - vg_str cmd; - vg_strnull( &cmd, NULL, -1 ); + vg_str cmd = {0}; /* compiler specification */ vg_strcat( &cmd, "ccache " ); - vg_strcat( &cmd, compiler_paths[ proj->env->compiler ] ); + + if( env->compiler == k_compiler_zigcc ) + vg_strcat( &cmd, "zig cc " ); + else if( env->compiler == k_compiler_clang ) + vg_strcat( &cmd, "clang" ); + else if( env->compiler == k_compiler_clang_android ) + { + if( env->arch == k_architecture_armv7a ) + { + vg_strcat( &cmd, + "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "bin/armv7a-linux-androideabi22-clang \\\n" ); + } + else if( env->arch == k_architecture_aarch64 ) + { + vg_strcat( &cmd, + "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "bin/aarch64-linux-android22-clang \\\n" ); + } + } + vg_strcat( &cmd, " -std=gnu99 -D_REENTRANT \\\n" ); - if( proj->env->optimization ) + if( env->optimization ) { vg_strcat( &cmd, " -O" ); - vg_strcati32( &cmd, proj->env->optimization ); + vg_strcati32( &cmd, env->optimization ); vg_strcat( &cmd, " -flto \\\n" ); } else @@ -374,7 +263,7 @@ void vg_compile_project( struct vg_project *proj ) /* add debugger / asan information */ vg_strcat( &cmd, " -O0 -ggdb3 -fno-omit-frame-pointer " ); - if( (proj->env->compiler == k_compiler_clang) && proj->env->debug_asan ) + if( (env->compiler == k_compiler_clang) && env->debug_asan ) { vg_strcat( &cmd, " -rdynamic -fsanitize=address -fPIE " "-fstack-protector-strong " ); @@ -389,76 +278,104 @@ void vg_compile_project( struct vg_project *proj ) " -Wno-unused-command-line-argument -Wno-unused-but-set-variable\\\n" ); - if( proj->env->compiler != k_compiler_clang ) + if( env->compiler != k_compiler_clang ) vg_strcat( &cmd, " -Wno-format-truncation\\\n" ); + /* defines */ + vg_strcat( &cmd, " " ); + vg_strcat( &cmd, conf->defines.buffer ); + vg_strcat( &cmd, "\\\n" ); + /* include paths */ vg_strcat( &cmd, " " ); - vg_strcat( &cmd, proj->include.buffer ); + vg_strcat( &cmd, conf->include.buffer ); vg_strcat( &cmd, "\\\n" ); /* library paths */ vg_strcat( &cmd, " " ); - vg_strcat( &cmd, proj->library.buffer ); + vg_strcat( &cmd, conf->library.buffer ); vg_strcat( &cmd, "\\\n" ); /* sources */ vg_strcat( &cmd, " " ); - if( proj->type == k_obj_type_obj ) + if( type == k_obj_type_obj ) vg_strcat( &cmd, "-c -fPIC " ); - if( proj->type == k_obj_type_shared ) + if( type == k_obj_type_shared ) { vg_strcat( &cmd, "-shared -fPIC " ); - if( proj->env->platform == k_platform_android ) + if( env->platform == k_platform_android ) { vg_strcat( &cmd, "-Wl,-soname," ); - vg_strcat( &cmd, proj->target.buffer ); - vg_strcat( &cmd, " " ); + vg_strcat( &cmd, target_name ); + vg_strcat( &cmd, ".so " ); } } - vg_strcat( &cmd, proj->sources.buffer ); + vg_strcat( &cmd, sources ); vg_strcat( &cmd, "\\\n" ); - /* output */ - vg_strcat( &cmd, " -o bin/" ); - vg_strcat( &cmd, proj->uid.buffer ); - vg_strcat( &cmd, "/" ); - vg_strcat( &cmd, proj->target.buffer ); + struct compile_result res = {0}; + + vg_strcat( &res.rel_path, target_name ); + + if( env->platform == k_platform_windows ) + { + if( type == k_obj_type_exe ) + vg_strcat( &res.rel_path, ".exe" ); + else if( type == k_obj_type_shared ) + vg_strcat( &res.rel_path, ".dll" ); + else if( type == k_obj_type_obj ) + vg_strcat( &res.rel_path, ".obj" ); + } + + if( vg_platform_posix( env->platform ) ) + { + if( type == k_obj_type_shared ) + vg_strcat( &res.rel_path, ".so" ); + else if( type == k_obj_type_obj ) + vg_strcat( &res.rel_path, ".o" ); + } + + vg_strcat( &res.path, project->bin_folder.buffer ); + vg_strcat( &res.path, "/" ); + vg_strcat( &res.path, res.rel_path.buffer ); + + vg_strcat( &cmd, " -o " ); + vg_strcat( &cmd, res.path.buffer ); vg_strcat( &cmd, "\\\n" ); /* link */ vg_strcat( &cmd, " " ); - vg_strcat( &cmd, proj->link.buffer ); + vg_strcat( &cmd, conf->link.buffer ); vg_strcat( &cmd, "\\\n" ); - if( proj->type == k_obj_type_exe ) + if( type == k_obj_type_exe ) { vg_strcat( &cmd, " -Wl,-rpath=./\\\n" ); } - /* target platform specification (zig-cc only) */ - if( proj->env->compiler == k_compiler_zigcc ) + /* platform specification (zig-cc only) */ + if( env->compiler == k_compiler_zigcc ) { vg_strcat( &cmd, " -target " ); - vg_strcat( &cmd, architecture_names[proj->env->arch] ); + vg_strcat( &cmd, architecture_names[env->arch] ); vg_strcat( &cmd, "-" ); - vg_strcat( &cmd, platform_names[proj->env->platform] ); + vg_strcat( &cmd, platform_names[env->platform] ); - if( proj->env->platform == k_platform_linux ) + if( env->platform == k_platform_linux ) { vg_strcat( &cmd, "-gnu" ); - vg_strcat( &cmd, libc_names[proj->env->libc] ); + vg_strcat( &cmd, libc_names[env->libc] ); } - if( proj->env->platform == k_platform_windows ) + if( env->platform == k_platform_windows ) { /* we currently dont want pdb pretty much ever. goodbye! */ - if( proj->type == k_obj_type_exe ) + if( type == k_obj_type_exe ) { vg_strcat( &cmd, " /pdb:/dev/null" ); vg_strcat( &cmd, " /SUBSYSTEM:windows" ); @@ -467,14 +384,61 @@ void vg_compile_project( struct vg_project *proj ) } vg_syscall( cmd.buffer ); + return res; +} - /* add to results */ - vg_strcat( &proj->compiled_objects, "bin/" ); - vg_strcat( &proj->compiled_objects, proj->uid.buffer ); - vg_strcat( &proj->compiled_objects, "/" ); - vg_strcat( &proj->compiled_objects, proj->target.buffer ); - vg_strcat( &proj->compiled_objects, " \\\n " ); +#if 0 +void vg_android_pack( struct vg_project *proj ) +{ + vg_str AndroidManifest_xml; + vg_strcatf( &AndroidManifest_xml, +"\n" +"\n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +"\n" ); + + vg_syscall( "aapt package -vf \\\n" + "--target-sdk-version 22 \\\n" + "-F bin/temp.apk \\\n" + "-I /opt/android-sdk/platforms/android-22/android.jar \\\n" + "-M AndroidManifest.xml \\\n" + "-S resources/ \\\n" + "-A assets/ " + ); + vg_syscall( "aapt add -v \\\n" + "bin/temp.apk \\\n" + "%s", proj->compiled_objects.buffer ); + + /* sign */ +#if 0 +keytool -genkey -v -keystore debug.keystore -storepass android -alias \ +androiddebugkey -keypass android -keyalg RSA -keysize 2048 -validity 10000 \ +-dname "C=US, O=Android, CN=Android Debug" +#endif + vg_syscall( "/opt/android-sdk/build-tools/34.0.0/apksigner sign \\\n" + "--key-pass pass:android --ks-pass pass:android \\\n" + "--ks debug.keystore bin/temp.apk" + ); } +#endif /* * Standard VG includes & libraries which we use for games/graphics @@ -482,12 +446,16 @@ void vg_compile_project( struct vg_project *proj ) struct vg_engine_config { - bool use_3d, legacy_support_vg_msg1, log_source_info, steam_api, + bool use_3d, + legacy_support_vg_msg1, + log_source_info, + steam_api, custom_game_settings, custom_shaders; i32 fixed_update_hz; } -vg_engine_default_config = { +vg_engine_default_config = +{ .use_3d = 1, .fixed_update_hz = 60, .legacy_support_vg_msg1 = 0, @@ -497,40 +465,53 @@ vg_engine_default_config = { .custom_shaders = 0 }; -void vg_add_engine( struct vg_project *proj, struct vg_engine_config *config ) +/* add engine to build target. It will recompile the engine using compiler, + * and update the configuration, and build a list of sources to link with */ +void vg_add_engine( struct vg_project *proj, + struct vg_engine_config *vg_conf, + struct vg_compiler_env *env, + struct vg_compiler_conf *conf, + vg_str *sources ) { + struct vg_project vg_proj; + vg_project_init( &vg_proj, "bin", ".vg", 0 ); + /* building assets */ vg_build_default_font(); - if( !config ) config = &vg_engine_default_config; - vg_str config_string; - vg_strnull( &config_string, NULL, -1 ); - vg_strcat( &config_string, config->use_3d? "-DVG_3D \\\n": "-DVG_2D \\\n" ); - vg_strcat( &config_string, "-DVG_TIMESTEP_FIXED=\"(1.0/" ); - vg_strcati32( &config_string, config->fixed_update_hz ); - vg_strcat( &config_string, ".0)\" \\\n" ); - - if( config->legacy_support_vg_msg1 ) - vg_strcat( &config_string, "-DVG_MSG_V1_SUPPORT \\\n" ); - if( config->log_source_info ) - vg_strcat( &config_string, "-DVG_LOG_SOURCE_INFO \\\n" ); - if( config->custom_game_settings ) - vg_strcat( &config_string, "-DVG_GAME_SETTINGS \\\n" ); - if( config->custom_shaders ) - vg_strcat( &config_string, "-DVG_CUSTOM_SHADERS \\\n" ); - - if( proj->env->arch == k_architecture_i386 || - proj->env->arch == k_architecture_armv7a ) - vg_strcat( &config_string, "-DVG_32 \\\n" ); + /* add config defines to compiler config */ + if( !vg_conf ) vg_conf = &vg_engine_default_config; + vg_strcat( &conf->defines, vg_conf->use_3d? "-DVG_3D \\\n": "-DVG_2D \\\n" ); + vg_strcatf( &conf->defines, "-DVG_TIMESTEP_FIXED=\"(1.0/%d.0)\" \\\n", + vg_conf->fixed_update_hz ); + + if( vg_conf->legacy_support_vg_msg1 ) + vg_strcat( &conf->defines, "-DVG_MSG_V1_SUPPORT \\\n" ); + + if( vg_conf->log_source_info ) + vg_strcat( &conf->defines, "-DVG_LOG_SOURCE_INFO \\\n" ); + + if( vg_conf->custom_game_settings ) + vg_strcat( &conf->defines, "-DVG_GAME_SETTINGS \\\n" ); + + if( vg_conf->custom_shaders ) + vg_strcat( &conf->defines, "-DVG_CUSTOM_SHADERS \\\n" ); + + if( env->arch == k_architecture_i386 || + env->arch == k_architecture_armv7a ) + vg_strcat( &conf->defines, "-DVG_32 \\\n" ); else - vg_strcat( &config_string, "-DVG_64 \\\n" ); + vg_strcat( &conf->defines, "-DVG_64 \\\n" ); - if( proj->env->platform == k_platform_android ) + if( env->platform == k_platform_android ) { - vg_strcat( &config_string, "-DVG_ANDROID \\\n" ); - vg_strcat( &config_string, - "-DANDROID -DAPPNAME=\\\"carrot\\\" -DANDROID_FULLSCREEN \\\n" - "-DANDROIDVERSION=22 -mfloat-abi=softfp -m32 \\\n" ); + vg_strcat( &conf->defines, "-DVG_ANDROID \\\n" ); + + /* FIXME: -m32 womp womp */ + vg_strcatf( &conf->defines, + "-DANDROID -DAPPNAME=\\\"%s\\\" -DANDROID_FULLSCREEN \\\n" + "-DANDROIDVERSION=22 -mfloat-abi=softfp -m32 \\\n", + proj->uid.buffer ); #if 0 vg_strcat( &config_string, @@ -544,89 +525,86 @@ void vg_add_engine( struct vg_project *proj, struct vg_engine_config *config ) #endif } - vg_strcat( &config_string, "\\\n" ); + vg_strcat( &conf->defines, "\\\n" ); - /* compile heavy dependencies seperately */ - struct vg_project dep_proj; - struct vg_env env = *proj->env; - env.optimization = 3; - env.debug_asan = 0; + vg_strcat( &conf->include, "-I. -I./vg -I./vg/dep " ); - vg_project_init( &dep_proj, proj->env, "vg" ); + /* compile all the components + * ----------------------------------------------------------------------- */ + struct vg_compiler_env denv = *env; + denv.optimization = 3; + denv.debug_asan = 0; /* external dependencies */ - vg_project_new_target( &dep_proj, "vg_deps", k_obj_type_obj ); - vg_add_source( &dep_proj, config_string.buffer ); - vg_add_source( &dep_proj, "vg/vg_depencies.c" ); - vg_compile_project( &dep_proj ); + struct compile_result depencies = + vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_depencies.c", + "vg_deps", k_obj_type_obj ); + vg_strcatf( sources, "%s ", depencies.path ); /* glad */ - if( proj->env->platform != k_platform_android ) + if( env->platform != k_platform_android ) { - vg_project_new_target( &dep_proj, "vg_glad", k_obj_type_obj ); - vg_add_source( &dep_proj, "vg/dep/glad/glad.c" ); - vg_include_dir( &dep_proj, "-I./vg/dep " ); - vg_compile_project( &dep_proj ); + struct compile_result glad = + vg_compiler_run( &vg_proj, &denv, conf, "vg/dep/glad/glad.c", + "vg_glad", k_obj_type_obj ); + vg_strcatf( sources, "%s ", glad.path ); } /* core engine */ - vg_project_new_target( &dep_proj, "vg_engine_core", k_obj_type_obj ); - vg_add_source( &dep_proj, config_string.buffer ); - vg_add_source( &dep_proj, "vg/vg_engine.c" ); - vg_include_dir( &dep_proj, "-I./vg/dep " ); - vg_compile_project( &dep_proj ); + struct compile_result vg = + vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_engine.c", + "vg_engine_core", k_obj_type_obj ); + vg_strcatf( sources, "%s ", vg.path ); /* steamworks */ - if( config->steam_api ) + if( vg_conf->steam_api ) { - if( env.platform == k_platform_android ) + if( env->platform == k_platform_android ) { - vg_fatal_error( "Cannot use steam_api on android" ); + vg_warn( "Cannot use steam_api on android (build script mistake?)" ); } + else + { + struct compile_result steam = + vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_steam.c", + "vg_steam", k_obj_type_obj ); + vg_strcatf( sources, "%s ", steam.path ); - vg_project_new_target( &dep_proj, "vg_steam", k_obj_type_obj ); - vg_add_source( &dep_proj, "vg/vg_steam.c" ); - vg_compile_project( &dep_proj ); + if( env->platform == k_platform_linux ) + { + vg_add_blob( proj, "vg/dep/steam/libsteam_api.so", "" ); + vg_strcat( &conf->link, "-lsteam_api " ); + } + else if( env->platform == k_platform_windows ) + { + vg_add_blob( proj, "vg/dep/steam/steam_api64.dll", "" ); + vg_strcat( &conf->link, "vg/dep/steam/steam_api64.dll " ); + } - if( proj->env->platform == k_platform_linux ) - { - vg_add_blob( proj, "vg/dep/steam/libsteam_api.so", "" ); - vg_link( proj, "-lsteam_api " ); - } - else if( proj->env->platform == k_platform_windows ) - { - vg_add_blob( proj, "vg/dep/steam/steam_api64.dll", "" ); - vg_link( proj, "vg/dep/steam/steam_api64.dll " ); + vg_strcat( &conf->library, "-L./vg/dep/steam " ); } - - vg_library_dir( proj, "-L./vg/dep/steam " ); - vg_include_dir( proj, "-I./vg/dep " ); } - /* precipitate to the client project */ - - vg_link( proj, "-lm " ); - if( proj->env->platform == k_platform_linux ) + /* link */ + vg_strcat( &conf->link, "-lm " ); + if( env->platform == k_platform_linux ) { - vg_link( proj, "-lSDL2 -lGL -lX11 -lXxf86vm " - "-lXrandr -lXi -ldl -pthread " ); + vg_strcat( &conf->link, "-lSDL2 -lGL -lX11 -lXxf86vm " + "-lXrandr -lXi -ldl -pthread " ); } - else if( proj->env->platform == k_platform_windows ) + else if( env->platform == k_platform_windows ) { - vg_link( proj, "-lSDL2main -lSDL2 -lopengl32 \\\n" ); - vg_link( proj, "vg/dep/sdl/SDL2.dll " ); + vg_strcat( &conf->link, "-lSDL2main -lSDL2 -lopengl32 \\\n" ); + vg_strcat( &conf->link, "vg/dep/sdl/SDL2.dll " ); vg_add_blob( proj, "vg/dep/sdl/SDL2.dll ", "" ); - vg_library_dir( proj, "-L./vg/dep/sdl " ); + vg_strcat( &conf->library, "-L./vg/dep/sdl " ); } - else if( proj->env->platform == k_platform_android ) + else if( env->platform == k_platform_android ) { - vg_link( proj, "-lGLESv3 -lEGL -lOpenSLES -pthread -landroid -llog " ); + vg_strcat( &conf->link, + "-lGLESv3 -lEGL -lOpenSLES -pthread -landroid -llog " + "-uANativeActivity_onCreate "); } - - vg_add_source( proj, config_string.buffer ); - vg_add_source( proj, dep_proj.compiled_objects.buffer ); - vg_add_source( proj, "\\\n" ); - vg_include_dir( proj, "-I./vg/dep " ); } void vg_add_controller_database( struct vg_project *proj ) diff --git a/vg_build2.h b/vg_build2.h new file mode 100644 index 0000000..7ecab7c --- /dev/null +++ b/vg_build2.h @@ -0,0 +1,12 @@ +#include +#include +#include +#include +#include +#include "vg_opt.h" +#include "vg_log.h" +#include "vg_string.h" +#include "vg_build_font.h" + +/* we dont free dynamic vg_strs in this program. so, we dont care.. */ +const char *__asan_default_options() { return "detect_leaks=0"; } diff --git a/vg_build_utils_shader.h b/vg_build_utils_shader.h index 1e1c8b1..64a524b 100644 --- a/vg_build_utils_shader.h +++ b/vg_build_utils_shader.h @@ -158,9 +158,9 @@ int vg_build_shader( char *src_vert, /* path/to/vert.vs */ { if( !vg_shaderbuild.init ) { - vg_strnull( &vg_shaderbuild.code_link, NULL, -1 ); - vg_strnull( &vg_shaderbuild.code_register, NULL, -1 ); - vg_strnull( &vg_shaderbuild.code_function_body, NULL, -1 ); + vg_strnull( &vg_shaderbuild.code_link, NULL, 0 ); + vg_strnull( &vg_shaderbuild.code_register, NULL, 0 ); + vg_strnull( &vg_shaderbuild.code_function_body, NULL, 0 ); vg_shaderbuild.init = 1; } diff --git a/vg_platform/android/build.c b/vg_platform/android/build.c new file mode 100644 index 0000000..8643622 --- /dev/null +++ b/vg_platform/android/build.c @@ -0,0 +1,108 @@ +#include "vg/vg_tool.h" +#include "vg/vg_platform.h" +#include "vg/vg_log.h" +#include "vg/vg_opt.h" +#include "vg/vg_build.h" +#include "vg/vg_build_utils_shader.h" +#include "vg/vg_msg.h" + +/* + * Scripts + * -------------------------------------------------------------------------- */ + +void s_testing_build(void) +{ + vg_info( "running script: s_testing_build(void)\n" ); + + /* build 64 bit*/ + vg_syscall( "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "bin/aarch64-linux-android22-clang \\\n" + "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "sysroot/usr/include \\\n" + "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "sysroot/usr/include/android \\\n" + "-I.\\\n" + "-Wall -fPIC \\\n" + "-DANDROID -DAPPNAME=\\\"carrot\\\" -DANDROID_FULLSCREEN \\\n" + "-DANDROIDVERSION=22 -m64 \\\n" + "main.c android_native_app_glue.c \\\n" + "-o lib/arm64-v8a/libcarrot.so \\\n" + "-L /opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "sysroot/usr/lib/aarch64-linux-android/22 \\\n" + "-lm -lGLESv3 -lEGL -landroid -llog -lOpenSLES -shared \\\n" + "-uANativeActivity_onCreate " + ); + + /* build 32 bit*/ + vg_syscall( "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "bin/armv7a-linux-androideabi22-clang \\\n" + "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "sysroot/usr/include \\\n" + "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "sysroot/usr/include/android \\\n" + "-I.\\\n" + "-Wall -fPIC \\\n" + "-DANDROID -DAPPNAME=\\\"carrot\\\" -DANDROID_FULLSCREEN \\\n" + "-DANDROIDVERSION=22 -mfloat-abi=softfp -m32 \\\n" + "main.c android_native_app_glue.c \\\n" + "-o lib/armeabi-v7a/libcarrot.so \\\n" + "-L /opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/" + "sysroot/usr/lib/arm-linux-androideabi/22 \\\n" + "-lm -lGLESv3 -lEGL -landroid -llog -lOpenSLES -shared \\\n" + "-uANativeActivity_onCreate " + ); + + /* pack */ + vg_syscall( "/opt/android-sdk/build-tools/34.0.0/aapt package -vf \\\n" + "--target-sdk-version 22 \\\n" + "-F bin/temp.apk \\\n" + "-I /opt/android-sdk/platforms/android-22/android.jar \\\n" + "-M AndroidManifest.xml \\\n" + "-S resources/ \\\n" + "-A assets/ " + ); + vg_syscall( "/opt/android-sdk/build-tools/34.0.0/aapt add -v \\\n" + "bin/temp.apk \\\n" + "lib/arm64-v8a/libcarrot.so \\\n" + ); + vg_syscall( "/opt/android-sdk/build-tools/34.0.0/aapt add -v \\\n" + "bin/temp.apk \\\n" + "lib/armeabi-v7a/libcarrot.so \\\n" + ); + + /* sign */ +#if 0 +keytool -genkey -v -keystore debug.keystore -storepass android -alias \ +androiddebugkey -keypass android -keyalg RSA -keysize 2048 -validity 10000 \ +-dname "C=US, O=Android, CN=Android Debug" +#endif + vg_syscall( "/opt/android-sdk/build-tools/34.0.0/apksigner sign \\\n" + "--key-pass pass:android --ks-pass pass:android \\\n" + "--ks debug.keystore bin/temp.apk" + ); + + /* push */ + vg_syscall( "/opt/android-sdk/platform-tools/adb install -r \\\n" + "bin/temp.apk " + ); + + /* run */ + vg_syscall( "/opt/android-sdk/platform-tools/adb shell am start -n \\\n" + "org.mtzero.carrot/android.app.NativeActivity " + ); +} + +int main( int argc, char *argv[] ) +{ + char *arg; + while( vg_argp( argc, argv ) ) + { + if( vg_long_opt( "testing-build" ) ) + s_testing_build(); + + if( vg_opt('r') ) + vg_test_env.optimization = 3; + } + + vg_success( "All scripts completed\n" ); +} diff --git a/vg_string.c b/vg_string.c index ef29ef3..f6c7344 100644 --- a/vg_string.c +++ b/vg_string.c @@ -6,8 +6,10 @@ i32 vg_str_storage( vg_str *str ) { - if( str->len == -1 ){ - if( str->buffer ){ + if( str->len == 0 ) + { + if( str->buffer ) + { vg_str_dynamic *arr = (vg_str_dynamic *)str->buffer; return (arr-1)->len; } @@ -17,26 +19,27 @@ i32 vg_str_storage( vg_str *str ) } /* - * Reset string. If len is -1 (dynamically allocated), buffer must be either + * Reset string. If len is 0 (dynamically allocated), buffer must be either * NULL or be acquired from malloc or realloc */ void vg_strnull( vg_str *str, char *buffer, i32 len ) { + if( len == -1 ) vg_fatal_error( "waaaa" ); + str->buffer = buffer; if( buffer ) str->buffer[0] = '\0'; str->i = 0; str->len = len; - - if( len == 0 ) - vg_fatal_error( "0 length string allocation\n" ); } void vg_strfree( vg_str *str ) { - if( str->len == -1 ){ - if( str->buffer ){ + if( str->len == 0 ) + { + if( str->buffer ) + { vg_str_dynamic *arr = (vg_str_dynamic *)str->buffer; free( arr-1 ); @@ -52,7 +55,8 @@ void vg_strfree( vg_str *str ) */ static i32 vg_str_dynamic_grow( vg_str *str ) { - if( str->buffer ){ + if( str->buffer ) + { vg_str_dynamic *hdr = ((vg_str_dynamic *)str->buffer) - 1; i32 total = (hdr->len + sizeof(vg_str_dynamic)) * 2; hdr = realloc( hdr, total ); @@ -60,7 +64,8 @@ static i32 vg_str_dynamic_grow( vg_str *str ) str->buffer = (char *)(hdr+1); return hdr->len; } - else { + else + { vg_str_dynamic *hdr = malloc(16); hdr->len = 16-sizeof(vg_str_dynamic); str->buffer = (char *)(hdr+1); @@ -76,7 +81,7 @@ static void _vg_strcatch( vg_str *str, char c ) i32 max = vg_str_storage( str ); if( str->i == max ) { - if( str->len == -1 ) + if( str->len == 0 ) max = vg_str_dynamic_grow( str ); else { @@ -119,10 +124,12 @@ void vg_strcatch( vg_str *str, char c ) */ void vg_strcati32( vg_str *str, i32 value ) { - if( value ){ + if( value ) + { char temp[32]; int i=0; - while( value && (i<31) ){ + while( value && (i<31) ) + { temp[ i ++ ] = '0' + (value % 10); value /= 10; } @@ -142,7 +149,8 @@ void vg_strcati32r( vg_str *str, i32 value, i32 n, char alt ) { char temp[32]; i32 i=0; - while( value ){ + while( value ) + { if( i>=n ) break; @@ -180,17 +188,21 @@ char *vg_strch( vg_str *str, char c ) u32 vg_strncpy( const char *src, char *dst, u32 len, enum strncpy_behaviour behaviour ) { - for( u32 i=0; i