def set_rc_flags(self, kw, ctx): rc_defines = [ 'RESOURCE_COMPILER', 'FORCE_STANDARD_ASSERT', '_CRT_SECURE_NO_DEPRECATE=1', '_CRT_NONSTDC_NO_DEPRECATE=1' ] append_unique_kw_entry(kw, 'defines', rc_defines) append_unique_kw_entry(kw, 'win_defines', 'WIN32')
def set_rc_flags(self, kw, ctx): prepend_kw_entry(kw,'includes',['.', self.CreateRootRelativePath('Code/CryEngine/CryCommon'), self.CreateRootRelativePath('Code/Sandbox/Plugins/EditorCommon')]) rc_defines = ['RESOURCE_COMPILER', 'FORCE_STANDARD_ASSERT', '_CRT_SECURE_NO_DEPRECATE=1', '_CRT_NONSTDC_NO_DEPRECATE=1'] append_unique_kw_entry(kw, 'defines', rc_defines) append_unique_kw_entry(kw, 'win_defines', 'WIN32')
def apply_gem_to_kw(ctx, kw, gem): """ Apply a gem to the kw """ gem_include_path = gem.get_include_path() if os.path.exists(gem_include_path): append_unique_kw_entry(kw, 'includes', gem_include_path) for module in gem.modules: if module.requires_linking(ctx): append_unique_kw_entry(kw, 'use', module.target_name) if (gem.export_uselibs or ctx.is_monolithic_build()) and len(gem.local_uselibs) > 0: configuration = ctx.env['CONFIGURATION'] if not (gem.local_uselib_non_release and configuration.lower() in [ "release", "release_dedicated", "performance", "performance_dedicated" ]): append_unique_kw_entry(kw, 'uselib', gem.local_uselibs)
def apply_gems_to_kw(ctx, kw, gems, game_name): """ Apply gems to the kw """ for gem in gems: gem_include_path = gem.get_include_path() if os.path.exists(gem_include_path): append_unique_kw_entry(kw, 'includes', gem_include_path) if (gem.export_uselibs or ctx.is_monolithic_build()) and len(gem.local_uselibs) > 0: configuration = ctx.env['CONFIGURATION'] if not (gem.local_uselib_non_release and configuration.lower() in [ "release", "release_dedicated", "performance", "performance_dedicated" ]): append_unique_kw_entry(kw, 'uselib', gem.local_uselibs) append_unique_kw_entry(kw, 'use', _get_linked_module_targets(gems, game_name, ctx))
def DefineGem(ctx, *k, **kw): """ Gems behave very similarly to engine modules, but with a few extra options """ manager = GemManager.GetInstance(ctx) gem = manager.get_gem_by_path(ctx.path.parent.abspath()) if not gem: ctx.cry_error( "DefineGem must be called by a wscript file in a Gem's 'Code' folder. Called from: {}" .format(ctx.path.abspath())) manager.current_gem = gem # Generate list of resolved dependencies dependency_objects = [] for dep_id in gem.dependencies: dep = manager.get_gem_by_spec(dep_id) if not dep: unmet_name = find_gem_name_by_id(ctx, dep_id) if unmet_name is None: ctx.cry_error( 'Gem {}({}) has an unmet dependency with ID {} (Unable to locate in disk).' .format(gem.id, gem.name, dep_id)) else: ctx.cry_error( 'Gem {}({}) has an unmet dependency with ID {}({}). Please use the Project Configurator to correct this.' .format(gem.id, gem.name, dep_id, unmet_name)) continue dependency_objects.append(dep) # Applies dependencies to args list def apply_dependencies(args): for dep in dependency_objects: dep_include = dep.get_include_path() if os.path.exists(dep_include): append_to_unique_list(args['includes'], dep_include) for module in dep.modules: if module.requires_linking(ctx): append_to_unique_list(args['use'], module.target_name) # Iterate over each module and setup build for module in gem.modules: if module.name: module_kw = kw.get(module.name, None) # If no based on name, try lowercasing if module_kw == None: module_kw = kw.get(module.name.lower(), None) # If still no kw, error if module_kw == None: ctx.cry_error( "Gem {0}'s wscript missing definition for module {1} (valid dict names are {1} and {2}." .format(gem.name, module.name, module.name.lower())) else: module_kw = kw module_file_list_base = module.target_name.replace('.', '_').lower() # Set default properties default_settings = { 'target': module.target_name, 'output_file_name': module.file_name, 'vs_filter': gem.name if gem.is_game_gem else 'Gems', 'file_list': ["{}.waf_files".format(module_file_list_base)], 'platforms': ['all'], 'configurations': ['all'], 'defines': [], 'includes': [], 'export_includes': [], 'lib': [], 'libpath': [], 'features': [], 'use': [], 'uselib': [] } # Builders have some special settings if module.type in [ Gem.Module.Type.Builder, Gem.Module.Type.EditorModule ]: default_settings['platforms'] = ['win', 'darwin'] default_settings['configurations'] = [ 'debug', 'debug_test', 'profile', 'profile_test' ] if module.parent: parent_module = None for parent_module_itr in gem.modules: if (parent_module_itr.name == module.parent or (module.parent == 'GameModule' and parent_module_itr.type == Gem.Module.Type.GameModule and parent_module_itr.name == None)): parent_module = parent_module_itr break if not parent_module: ctx.cry_error( '{}\'s Gem.json Module "{}" "Extends" non-existent module {}.' .format(gem.name, module.name, module.parent)) parent_kw = getattr(parent_module, 'kw', None) if not parent_kw: ctx.cry_error( '{}\'s wscript defines module {} before parent {}, please reverse the order.' .format(gem.name, module.name, module.parent)) EXTENDABLE_FIELDS = [ 'file_list', 'defines', 'includes', 'features', 'lib', 'libpath', 'use', 'uselib' ] INHERITABLE_FIELDS = [ 'pch', ] for field in EXTENDABLE_FIELDS: default_settings[field].extend(parent_kw.get(field, [])) for field in INHERITABLE_FIELDS: parent_value = parent_kw.get(field, None) if parent_value: default_settings[field] = parent_value # Apply defaults to the project for key, value in default_settings.iteritems(): if key not in module_kw: module_kw[key] = value # Make it so gems can be replaced while executable is still running append_to_unique_list(module_kw['features'], ['link_running_program']) # Add tools stuff to the editor modules if module.type == Gem.Module.Type.EditorModule: append_unique_kw_entry(module_kw, 'features', ['qt5']) append_unique_kw_entry(module_kw, 'use', ['AzToolsFramework', 'AzQtComponents']) append_unique_kw_entry( module_kw, 'uselib', ['QT5CORE', 'QT5QUICK', 'QT5GUI', 'QT5WIDGETS']) # If the Gem is a game gem, we may need to apply enabled gems for all of the enabled game projects so it will build if gem.is_game_gem and module.type != Gem.Module.Type.Builder: # We need to let cryengine_modules.RunTaskGenerator know that this is a game gem and must be built always setattr(ctx, 'is_game_gem', True) # The gem only builds once, so we need apply the union of all non-game-gem gems enabled for all enabled game projects unique_gems = [] enabled_projects = ctx.get_enabled_game_project_list() for enabled_project in enabled_projects: gems_for_project = ctx.get_game_gems(enabled_project) for gem_for_project in gems_for_project: if gem_for_project.name != gem.name and not gem_for_project.is_game_gem: append_to_unique_list(unique_gems, gem_for_project) is_android = ctx.is_android_platform(ctx.env['PLATFORM']) for unique_gem in unique_gems: if unique_gem.id in gem.dependencies or unique_gem.is_required or is_android: apply_gem_to_kw(ctx, kw, unique_gem) working_path = ctx.path.abspath() dir_contents = os.listdir(working_path) # Setup PCH if disable_pch is false (default), and pch is not set (default) if not module_kw.get('disable_pch', False) and module_kw.get( 'pch', None) == None: # default casing for the relative path to the pch file source_dir = 'Source' pch_file = 'StdAfx.cpp' for entry in dir_contents: if entry.lower() == 'source': source_dir = entry break source_contents = os.listdir(os.path.join(working_path, source_dir)) # see if they have a legacy stdafx precompiled header for entry in source_contents: if entry.lower() == 'stdafx.cpp': pch_file = entry break # if they have a precompiled file then we will prefer that for entry in source_contents: if entry.lower().endswith('precompiled.cpp'): pch_file = entry break # has to be forward slash because the pch is string compared with files # in the waf_files which use forward slashes module_kw['pch'] = "{}/{}".format(source_dir, pch_file) # Apply any additional 3rd party uselibs if len(gem.local_uselibs) > 0: append_unique_kw_entry(module_kw, 'uselib', gem.local_uselibs) # Link the auto-registration symbols so that Flow Node registration will work if module.type in [ Gem.Module.Type.GameModule, Gem.Module.Type.EditorModule ]: append_unique_kw_entry(module_kw, 'use', ['CryAction_AutoFlowNode', 'AzFramework']) append_unique_kw_entry(module_kw, 'features', ['link_running_program']) # If disable_tests=False or disable_tests isn't specified, enable Google test disable_test_settings = ctx.GetPlatformSpecificSettings( module_kw, 'disable_tests', ctx.env['PLATFORM'], ctx.env['CONFIGURATION']) disable_tests = module_kw.get('disable_tests', False) or any(disable_test_settings) # Disable tests when doing monolithic build, except when doing project generation (which is always monolithic) disable_tests = disable_tests or ( ctx.env['PLATFORM'] != 'project_generator' and ctx.spec_monolithic_build()) # Disable tests on non-test configurations, except when doing project generation disable_tests = disable_tests or ( ctx.env['PLATFORM'] != 'project_generator' and 'test' not in ctx.env['CONFIGURATION']) if not disable_tests: append_unique_kw_entry(module_kw, 'use', 'AzTest') test_waf_files = "{}_tests.waf_files".format(module_file_list_base) if ctx.path.find_node(test_waf_files): append_unique_kw_entry(module_kw, 'file_list', test_waf_files) # Setup includes include_paths = [] # Most gems use the upper case directories, however some have lower case source directories. # This will add the correct casing of those include directories local_includes = [ entry for entry in dir_contents if entry.lower() in ['include', 'source'] ] # Add local includes for local_path in local_includes: node = ctx.path.find_node(local_path) if node: include_paths.append(node) # if the gem includes aren't already in the list, ensure they are prepended in order gem_includes = [] for include_path in include_paths: if not include_path in module_kw['includes']: gem_includes.append(include_path) module_kw['includes'] = gem_includes + module_kw['includes'] # Take the gems include folder if it exists and add it to the export_includes in case the gem is being 'used' export_include_node = ctx.path.find_node('Include') if export_include_node: module_kw['export_includes'] = [export_include_node.abspath() ] + module_kw['export_includes'] apply_dependencies(module_kw) # Save the build settings so we can access them later module.kw = module_kw append_unique_kw_entry(module_kw, 'is_gem', True) if gem.is_game_gem and ctx.is_monolithic_build( ) and ctx.is_android_platform( ctx.env['PLATFORM'] ) and module.type == Gem.Module.Type.GameModule: # Special case for android & monolithic builds. If this is the game gem for the project, it needs to apply the # enabled gems here instead of the launcher where its normally applied. (see cryengine_modules.CryLauncher_Impl # for details). In legacy game projects, this the game dll is declared as a CryEngineModule setattr(ctx, 'game_project', gem.name) ctx.CryEngineModule(**module_kw) else: if module.type in [ Gem.Module.Type.GameModule, Gem.Module.Type.EditorModule ]: ctx.CryEngineSharedLibrary(**module_kw) elif module.type == Gem.Module.Type.StaticLib: ctx.CryEngineStaticLibrary(**module_kw) elif module.type == Gem.Module.Type.Builder: ctx.BuilderPlugin(**module_kw) # INTERNAL USE ONLY # Apply export_defines to ENTIRE BUILD. USE LIGHTLY. if module.type == Gem.Module.Type.GameModule: export_defines = module_kw.get( 'export_defines', []) + ctx.GetPlatformSpecificSettings( module_kw, 'export_defines', ctx.env['PLATFORM'], ctx.env['CONFIGURATION']) append_to_unique_list(ctx.env['DEFINES'], export_defines) manager.current_gem = None