-/* zig cc scripting tools */
-
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
/* 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
{
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<path> */
- library, /* -L<path> */
- 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,
};
/*
[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
* -------------------------------------------------------------------------- */
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 );
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 )
}
/*
- * 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
/* 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 " );
" -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" );
}
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,
+"<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n"
+"<manifest \n"
+" xmlns:tools=\"http://schemas.android.com/tools\" \n"
+" xmlns:android=\"http://schemas.android.com/apk/res/android\" \n"
+" package=\"org.mtzero.carrot\">\n"
+" <uses-sdk android:minSdkVersion=\"22\" android:targetSdkVersion=\"22\" />\n"
+" <uses-permission android:name=\"android.permission.SET_RELEASE_APP\" />\n"
+" <uses-feature android:glEsVersion=\"0x00030002\" android:required=\"true\" />\n"
+" <application android:debuggable=\"true\" android:hasCode=\"false\" \n"
+" android:label=\"carrot\" \n"
+" tools:replace=\"android:icon,android:theme,android:allowBackup,label\" \n"
+" android:icon=\"@mipmap/icon\">\n"
+" <activity android:configChanges=\"keyboardHidden|orientation\" \n"
+" android:label=\"carrot\" android:name=\"android.app.NativeActivity\">\n"
+" <meta-data android:name=\"android.app.lib_name\" android:value=\"carrot\"/>\n"
+" <intent-filter>\n"
+" <action android:name=\"android.intent.action.MAIN\"/>\n"
+" <category android:name=\"android.intent.category.LAUNCHER\"/>\n"
+" </intent-filter>\n"
+" </activity>\n"
+" </application>\n"
+"</manifest>\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
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,
.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,
#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 )
projects / vg.git / commitdiff