@ -774,161 +774,6 @@ def add_to_vs_project(env, sources):
env . vs_srcs + = [ basename + " .cpp " ]
def generate_vs_project ( env , original_args , project_name = " godot " ) :
batch_file = find_visual_c_batch_file ( env )
filtered_args = original_args . copy ( )
# Ignore the "vsproj" option to not regenerate the VS project on every build
filtered_args . pop ( " vsproj " , None )
# The "platform" option is ignored because only the Windows platform is currently supported for VS projects
filtered_args . pop ( " platform " , None )
# The "target" option is ignored due to the way how targets configuration is performed for VS projects (there is a separate project configuration for each target)
filtered_args . pop ( " target " , None )
# The "progress" option is ignored as the current compilation progress indication doesn't work in VS
filtered_args . pop ( " progress " , None )
if batch_file :
class ModuleConfigs ( Mapping ) :
# This version information (Win32, x64, Debug, Release) seems to be
# required for Visual Studio to understand that it needs to generate an NMAKE
# project. Do not modify without knowing what you are doing.
PLATFORMS = [ " Win32 " , " x64 " ]
PLATFORM_IDS = [ " x86_32 " , " x86_64 " ]
CONFIGURATIONS = [ " editor " , " template_release " , " template_debug " ]
DEV_SUFFIX = " .dev " if env [ " dev_build " ] else " "
@staticmethod
def for_every_variant ( value ) :
return [ value for _ in range ( len ( ModuleConfigs . CONFIGURATIONS ) * len ( ModuleConfigs . PLATFORMS ) ) ]
def __init__ ( self ) :
shared_targets_array = [ ]
self . names = [ ]
self . arg_dict = {
" variant " : [ ] ,
" runfile " : shared_targets_array ,
" buildtarget " : shared_targets_array ,
" cpppaths " : [ ] ,
" cppdefines " : [ ] ,
" cmdargs " : [ ] ,
}
self . add_mode ( ) # default
def add_mode (
self ,
name : str = " " ,
includes : str = " " ,
cli_args : str = " " ,
defines = None ,
) :
if defines is None :
defines = [ ]
self . names . append ( name )
self . arg_dict [ " variant " ] + = [
f ' { config } { f " _[ { name } ] " if name else " " } | { platform } '
for config in ModuleConfigs . CONFIGURATIONS
for platform in ModuleConfigs . PLATFORMS
]
self . arg_dict [ " runfile " ] + = [
f ' bin \\ godot.windows. { config } { ModuleConfigs . DEV_SUFFIX } { " .double " if env [ " precision " ] == " double " else " " } . { plat_id } { f " . { name } " if name else " " } .exe '
for config in ModuleConfigs . CONFIGURATIONS
for plat_id in ModuleConfigs . PLATFORM_IDS
]
self . arg_dict [ " cpppaths " ] + = ModuleConfigs . for_every_variant ( env [ " CPPPATH " ] + [ includes ] )
self . arg_dict [ " cppdefines " ] + = ModuleConfigs . for_every_variant ( list ( env [ " CPPDEFINES " ] ) + defines )
self . arg_dict [ " cmdargs " ] + = ModuleConfigs . for_every_variant ( cli_args )
def build_commandline ( self , commands ) :
configuration_getter = (
" $(Configuration "
+ " " . join ( [ f ' .Replace( " { name } " , " " ) ' for name in self . names [ 1 : ] ] )
+ ' .Replace( " _[] " , " " ) '
+ " ) "
)
common_build_prefix = [
' cmd /V /C set " plat=$(PlatformTarget) " ' ,
' (if " $(PlatformTarget) " == " x64 " (set " plat=x86_amd64 " )) ' ,
' call " ' + batch_file + ' " !plat! ' ,
]
# Windows allows us to have spaces in paths, so we need
# to double quote off the directory. However, the path ends
# in a backslash, so we need to remove this, lest it escape the
# last double quote off, confusing MSBuild
common_build_postfix = [
" --directory= \" $(ProjectDir.TrimEnd( ' \\ ' )) \" " ,
" platform=windows " ,
f " target= { configuration_getter } " ,
" progress=no " ,
]
for arg , value in filtered_args . items ( ) :
common_build_postfix . append ( f " { arg } = { value } " )
result = " ^& " . join ( common_build_prefix + [ " " . join ( [ commands ] + common_build_postfix ) ] )
return result
# Mappings interface definitions
def __iter__ ( self ) - > Iterator [ str ] :
for x in self . arg_dict :
yield x
def __len__ ( self ) - > int :
return len ( self . names )
def __getitem__ ( self , k : str ) :
return self . arg_dict [ k ]
add_to_vs_project ( env , env . core_sources )
add_to_vs_project ( env , env . drivers_sources )
add_to_vs_project ( env , env . main_sources )
add_to_vs_project ( env , env . modules_sources )
add_to_vs_project ( env , env . scene_sources )
add_to_vs_project ( env , env . servers_sources )
if env [ " tests " ] :
add_to_vs_project ( env , env . tests_sources )
if env . editor_build :
add_to_vs_project ( env , env . editor_sources )
for header in glob_recursive ( " **/*.h " ) :
env . vs_incs . append ( str ( header ) )
module_configs = ModuleConfigs ( )
if env . get ( " module_mono_enabled " ) :
mono_defines = [ ( " GD_MONO_HOT_RELOAD " , ) ] if env . editor_build else [ ]
module_configs . add_mode (
" mono " ,
cli_args = " module_mono_enabled=yes " ,
defines = mono_defines ,
)
scons_cmd = " scons "
path_to_venv = os . getenv ( " VIRTUAL_ENV " )
path_to_scons_exe = Path ( str ( path_to_venv ) ) / " Scripts " / " scons.exe "
if path_to_venv and path_to_scons_exe . exists ( ) :
scons_cmd = str ( path_to_scons_exe )
env [ " MSVSBUILDCOM " ] = module_configs . build_commandline ( scons_cmd )
env [ " MSVSREBUILDCOM " ] = module_configs . build_commandline ( f " { scons_cmd } vsproj=yes " )
env [ " MSVSCLEANCOM " ] = module_configs . build_commandline ( f " { scons_cmd } --clean " )
if not env . get ( " MSVS " ) :
env [ " MSVS " ] [ " PROJECTSUFFIX " ] = " .vcxproj "
env [ " MSVS " ] [ " SOLUTIONSUFFIX " ] = " .sln "
env . MSVSProject (
target = [ " # " + project_name + env [ " MSVSPROJECTSUFFIX " ] ] ,
incs = env . vs_incs ,
srcs = env . vs_srcs ,
auto_build_solution = 1 ,
* * module_configs ,
)
else :
print ( " Could not locate Visual Studio batch file to set up the build environment. Not generating VS project. " )
def precious_program ( env , program , sources , * * args ) :
program = env . ProgramOriginal ( program , sources , * * args )
env . Precious ( program )
@ -1229,3 +1074,456 @@ def dump(env):
with open ( " .scons_env.json " , " w " ) as f :
dump ( env . Dictionary ( ) , f , indent = 4 , default = non_serializable )
# Custom Visual Studio project generation logic that supports any platform that has a msvs.py
# script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
# Invoked with scons vsproj=yes
#
# Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
# Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
# will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
# on the active build target.
#
# Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
# but will have the files and configuration for the windows editor target.
#
# To generate build configuration files for all platforms+targets+arch combinations, users can call
# scons vsproj=yes
# for each combination of platform+target+arch. This will generate the relevant vs project files but
# skip the build process. This lets project files be quickly generated even if there are build errors.
#
# To generate AND build from the command line:
# scons vsproj=yes vsproj_gen_only=yes
def generate_vs_project ( env , original_args , project_name = " godot " ) :
# Augmented glob_recursive that also fills the dirs argument with traversed directories that have content.
def glob_recursive_2 ( pattern , dirs , node = " . " ) :
from SCons import Node
from SCons . Script import Glob
results = [ ]
for f in Glob ( str ( node ) + " /* " , source = True ) :
if type ( f ) is Node . FS . Dir :
results + = glob_recursive_2 ( pattern , dirs , f )
r = Glob ( str ( node ) + " / " + pattern , source = True )
if len ( r ) > 0 and not str ( node ) in dirs :
d = " "
for part in str ( node ) . split ( " \\ " ) :
d + = part
if not d in dirs :
dirs . append ( d )
d + = " \\ "
results + = r
return results
def get_bool ( args , option , default ) :
from SCons . Variables . BoolVariable import _text2bool
val = args . get ( option , default )
if val is not None :
try :
return _text2bool ( val )
except :
return default
else :
return default
def format_key_value ( v ) :
if type ( v ) in [ tuple , list ] :
return v [ 0 ] if len ( v ) == 1 else f " { v [ 0 ] } = { v [ 1 ] } "
return v
filtered_args = original_args . copy ( )
# Ignore the "vsproj" option to not regenerate the VS project on every build
filtered_args . pop ( " vsproj " , None )
# This flag allows users to regenerate the proj files but skip the building process.
# This lets projects be regenerated even if there are build errors.
filtered_args . pop ( " vsproj_gen_only " , None )
# The "progress" option is ignored as the current compilation progress indication doesn't work in VS
filtered_args . pop ( " progress " , None )
# We add these three manually because they might not be explicitly passed in, and it's important to always set them.
filtered_args . pop ( " platform " , None )
filtered_args . pop ( " target " , None )
filtered_args . pop ( " arch " , None )
platform = env [ " platform " ]
target = env [ " target " ]
arch = env [ " arch " ]
vs_configuration = { }
common_build_prefix = [ ]
confs = [ ]
for x in sorted ( glob . glob ( " platform/* " ) ) :
# Only platforms that opt in to vs proj generation are included.
if not os . path . isdir ( x ) or not os . path . exists ( x + " /msvs.py " ) :
continue
tmppath = " ./ " + x
sys . path . insert ( 0 , tmppath )
import msvs
vs_plats = [ ]
vs_confs = [ ]
try :
platform_name = x [ 9 : ]
vs_plats = msvs . get_platforms ( )
vs_confs = msvs . get_configurations ( )
val = [ ]
for plat in vs_plats :
val + = [ { " platform " : plat [ 0 ] , " architecture " : plat [ 1 ] } ]
vsconf = { " platform " : platform_name , " targets " : vs_confs , " arches " : val }
confs + = [ vsconf ]
# Save additional information about the configuration for the actively selected platform,
# so we can generate the platform-specific props file with all the build commands/defines/etc
if platform == platform_name :
common_build_prefix = msvs . get_build_prefix ( env )
vs_configuration = vsconf
except Exception :
pass
sys . path . remove ( tmppath )
sys . modules . pop ( " msvs " )
headers = [ ]
headers_dirs = [ ]
for file in glob_recursive_2 ( " *.h " , headers_dirs ) :
headers . append ( str ( file ) . replace ( " / " , " \\ " ) )
for file in glob_recursive_2 ( " *.hpp " , headers_dirs ) :
headers . append ( str ( file ) . replace ( " / " , " \\ " ) )
sources = [ ]
sources_dirs = [ ]
for file in glob_recursive_2 ( " *.cpp " , sources_dirs ) :
sources . append ( str ( file ) . replace ( " / " , " \\ " ) )
for file in glob_recursive_2 ( " *.c " , sources_dirs ) :
sources . append ( str ( file ) . replace ( " / " , " \\ " ) )
others = [ ]
others_dirs = [ ]
for file in glob_recursive_2 ( " *.natvis " , others_dirs ) :
others . append ( str ( file ) . replace ( " / " , " \\ " ) )
for file in glob_recursive_2 ( " *.glsl " , others_dirs ) :
others . append ( str ( file ) . replace ( " / " , " \\ " ) )
skip_filters = False
import hashlib
import json
md5 = hashlib . md5 (
json . dumps ( headers + headers_dirs + sources + sources_dirs + others + others_dirs , sort_keys = True ) . encode (
" utf-8 "
)
) . hexdigest ( )
if os . path . exists ( f " { project_name } .vcxproj.filters " ) :
existing_filters = open ( f " { project_name } .vcxproj.filters " , " r " ) . read ( )
match = re . search ( r " (?ms)^<!-- CHECKSUM$.([0-9a-f] {32} ) " , existing_filters )
if match is not None and md5 == match . group ( 1 ) :
skip_filters = True
import uuid
# Don't regenerate the filters file if nothing has changed, so we keep the existing UUIDs.
if not skip_filters :
print ( f " Regenerating { project_name } .vcxproj.filters " )
filters_template = open ( " misc/msvs/vcxproj.filters.template " , " r " ) . read ( )
for i in range ( 1 , 10 ) :
filters_template = filters_template . replace ( f " %%UUID { i } %% " , str ( uuid . uuid4 ( ) ) )
filters = " "
for d in headers_dirs :
filters + = f ' <Filter Include= " Header Files \\ { d } " ><UniqueIdentifier> {{ { str ( uuid . uuid4 ( ) ) } }} </UniqueIdentifier></Filter> \n '
for d in sources_dirs :
filters + = f ' <Filter Include= " Source Files \\ { d } " ><UniqueIdentifier> {{ { str ( uuid . uuid4 ( ) ) } }} </UniqueIdentifier></Filter> \n '
for d in others_dirs :
filters + = f ' <Filter Include= " Other Files \\ { d } " ><UniqueIdentifier> {{ { str ( uuid . uuid4 ( ) ) } }} </UniqueIdentifier></Filter> \n '
filters_template = filters_template . replace ( " %% FILTERS %% " , filters )
filters = " "
for file in headers :
filters + = (
f ' <ClInclude Include= " { file } " ><Filter>Header Files \\ { os . path . dirname ( file ) } </Filter></ClInclude> \n '
)
filters_template = filters_template . replace ( " %% INCLUDES %% " , filters )
filters = " "
for file in sources :
filters + = (
f ' <ClCompile Include= " { file } " ><Filter>Source Files \\ { os . path . dirname ( file ) } </Filter></ClCompile> \n '
)
filters_template = filters_template . replace ( " %% COMPILES %% " , filters )
filters = " "
for file in others :
filters + = f ' <None Include= " { file } " ><Filter>Other Files \\ { os . path . dirname ( file ) } </Filter></None> \n '
filters_template = filters_template . replace ( " %% OTHERS %% " , filters )
filters_template = filters_template . replace ( " %% HASH %% " , md5 )
with open ( f " { project_name } .vcxproj.filters " , " w " ) as f :
f . write ( filters_template )
envsources = [ ]
envsources + = env . core_sources
envsources + = env . drivers_sources
envsources + = env . main_sources
envsources + = env . modules_sources
envsources + = env . scene_sources
envsources + = env . servers_sources
if env . editor_build :
envsources + = env . editor_sources
envsources + = env . platform_sources
headers_active = [ ]
sources_active = [ ]
others_active = [ ]
for x in envsources :
fname = " "
if type ( x ) == type ( " " ) :
fname = env . File ( x ) . path
else :
# Some object files might get added directly as a File object and not a list.
try :
fname = env . File ( x ) [ 0 ] . path
except :
fname = x . path
pass
if fname :
fname = fname . replace ( " \\ \\ " , " / " )
parts = os . path . splitext ( fname )
basename = parts [ 0 ]
ext = parts [ 1 ]
idx = fname . find ( env [ " OBJSUFFIX " ] )
if ext in [ " .h " , " .hpp " ] :
headers_active + = [ fname ]
elif ext in [ " .c " , " .cpp " ] :
sources_active + = [ fname ]
elif idx > 0 :
basename = fname [ : idx ]
if os . path . isfile ( basename + " .h " ) :
headers_active + = [ basename + " .h " ]
elif os . path . isfile ( basename + " .hpp " ) :
headers_active + = [ basename + " .hpp " ]
elif basename . endswith ( " .gen " ) and os . path . isfile ( basename [ : - 4 ] + " .h " ) :
headers_active + = [ basename [ : - 4 ] + " .h " ]
if os . path . isfile ( basename + " .c " ) :
sources_active + = [ basename + " .c " ]
elif os . path . isfile ( basename + " .cpp " ) :
sources_active + = [ basename + " .cpp " ]
else :
fname = os . path . relpath ( os . path . abspath ( fname ) , env . Dir ( " " ) . abspath )
others_active + = [ fname ]
all_items = [ ]
properties = [ ]
activeItems = [ ]
extraItems = [ ]
set_headers = set ( headers_active )
set_sources = set ( sources_active )
set_others = set ( others_active )
for file in headers :
all_items . append ( f ' <ClInclude Include= " { file } " > ' )
all_items . append (
f " <ExcludedFromBuild Condition= \" !$(ActiveProjectItemList.Contains( ' ; { file } ; ' )) \" >true</ExcludedFromBuild> "
)
all_items . append ( " </ClInclude> " )
if file in set_headers :
activeItems . append ( file )
for file in sources :
all_items . append ( f ' <ClCompile Include= " { file } " > ' )
all_items . append (
f " <ExcludedFromBuild Condition= \" !$(ActiveProjectItemList.Contains( ' ; { file } ; ' )) \" >true</ExcludedFromBuild> "
)
all_items . append ( " </ClCompile> " )
if file in set_sources :
activeItems . append ( file )
for file in others :
all_items . append ( f ' <None Include= " { file } " > ' )
all_items . append (
f " <ExcludedFromBuild Condition= \" !$(ActiveProjectItemList.Contains( ' ; { file } ; ' )) \" >true</ExcludedFromBuild> "
)
all_items . append ( " </None> " )
if file in set_others :
activeItems . append ( file )
if vs_configuration :
vsconf = " "
for a in vs_configuration [ " arches " ] :
if arch == a [ " architecture " ] :
vsconf = f ' { target } | { a [ " platform " ] } '
break
condition = " ' $(Configuration)|$(Platform) ' == ' " + vsconf + " ' "
properties . append ( " <ActiveProjectItemList>; " + " ; " . join ( activeItems ) + " ;</ActiveProjectItemList> " )
output = f ' bin \\ godot { env [ " PROGSUFFIX " ] } '
props_template = open ( " misc/msvs/props.template " , " r " ) . read ( )
props_template = props_template . replace ( " %% VSCONF %% " , vsconf )
props_template = props_template . replace ( " %% CONDITION %% " , condition )
props_template = props_template . replace ( " %% PROPERTIES %% " , " \n " . join ( properties ) )
props_template = props_template . replace ( " %% EXTRA_ITEMS %% " , " \n " . join ( extraItems ) )
props_template = props_template . replace ( " %% OUTPUT %% " , output )
props_template = props_template . replace (
" %% DEFINES %% " , " ; " . join ( [ format_key_value ( v ) for v in list ( env [ " CPPDEFINES " ] ) ] )
)
props_template = props_template . replace ( " %% INCLUDES %% " , " ; " . join ( [ str ( j ) for j in env [ " CPPPATH " ] ] ) )
props_template = props_template . replace (
" %% OPTIONS %% " ,
" " . join ( env [ " CCFLAGS " ] ) + " " + " " . join ( [ x for x in env [ " CXXFLAGS " ] if not x . startswith ( " $ " ) ] ) ,
)
# Windows allows us to have spaces in paths, so we need
# to double quote off the directory. However, the path ends
# in a backslash, so we need to remove this, lest it escape the
# last double quote off, confusing MSBuild
common_build_postfix = [
" --directory="$(ProjectDir.TrimEnd(' \\ '))" " ,
" progress=no " ,
f " platform= { platform } " ,
f " target= { target } " ,
f " arch= { arch } " ,
]
for arg , value in filtered_args . items ( ) :
common_build_postfix . append ( f " { arg } = { value } " )
cmd_rebuild = [
" vsproj=yes " ,
f " vsproj_name= { project_name } " ,
] + common_build_postfix
cmd_clean = [
" --clean " ,
] + common_build_postfix
commands = " scons "
if len ( common_build_prefix ) == 0 :
commands = " echo Starting SCons && cmd /V /C " + commands
else :
common_build_prefix [ 0 ] = " echo Starting SCons && cmd /V /C " + common_build_prefix [ 0 ]
cmd = " ^& " . join ( common_build_prefix + [ " " . join ( [ commands ] + common_build_postfix ) ] )
props_template = props_template . replace ( " %% BUILD %% " , cmd )
cmd = " ^& " . join ( common_build_prefix + [ " " . join ( [ commands ] + cmd_rebuild ) ] )
props_template = props_template . replace ( " %% REBUILD %% " , cmd )
cmd = " ^& " . join ( common_build_prefix + [ " " . join ( [ commands ] + cmd_clean ) ] )
props_template = props_template . replace ( " %% CLEAN %% " , cmd )
with open ( f " { project_name } . { platform } . { target } . { arch } .generated.props " , " w " ) as f :
f . write ( props_template )
proj_uuid = str ( uuid . uuid4 ( ) )
sln_uuid = str ( uuid . uuid4 ( ) )
if os . path . exists ( f " { project_name } .sln " ) :
for line in open ( f " { project_name } .sln " , " r " ) . read ( ) . splitlines ( ) :
if line . startswith ( ' Project( " { 8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942} " ) ' ) :
proj_uuid = re . search (
r " \" { ( \ b[0-9a-fA-F] {8} \ b-[0-9a-fA-F] {4} -[0-9a-fA-F] {4} -[0-9a-fA-F] {4} - \ b[0-9a-fA-F] {12} \ b)} \" $ " ,
line ,
) . group ( 1 )
elif line . strip ( ) . startswith ( " SolutionGuid = " ) :
sln_uuid = re . search (
r " { ( \ b[0-9a-fA-F] {8} \ b-[0-9a-fA-F] {4} -[0-9a-fA-F] {4} -[0-9a-fA-F] {4} - \ b[0-9a-fA-F] {12} \ b)} " , line
) . group ( 1 )
break
configurations = [ ]
imports = [ ]
properties = [ ]
section1 = [ ]
section2 = [ ]
for conf in confs :
godot_platform = conf [ " platform " ]
for p in conf [ " arches " ] :
sln_plat = p [ " platform " ]
proj_plat = sln_plat
godot_arch = p [ " architecture " ]
# Redirect editor configurations for non-Windows platforms to the Windows one, so the solution has all the permutations
# and VS doesn't complain about missing project configurations.
# These configurations are disabled, so they show up but won't build.
if godot_platform != " windows " :
section1 + = [ f " editor| { sln_plat } = editor| { proj_plat } " ]
section2 + = [
f " {{ { proj_uuid } }} .editor| { proj_plat } .ActiveCfg = editor| { proj_plat } " ,
]
for t in conf [ " targets " ] :
godot_target = t
# Windows x86 is a special little flower that requires a project platform == Win32 but a solution platform == x86.
if godot_platform == " windows " and godot_target == " editor " and godot_arch == " x86_32 " :
sln_plat = " x86 "
configurations + = [
f ' <ProjectConfiguration Include= " { godot_target } | { proj_plat } " > ' ,
f " <Configuration> { godot_target } </Configuration> " ,
f " <Platform> { proj_plat } </Platform> " ,
" </ProjectConfiguration> " ,
]
if godot_platform != " windows " :
configurations + = [
f ' <ProjectConfiguration Include= " editor| { proj_plat } " > ' ,
f " <Configuration>editor</Configuration> " ,
f " <Platform> { proj_plat } </Platform> " ,
" </ProjectConfiguration> " ,
]
p = f " { project_name } . { godot_platform } . { godot_target } . { godot_arch } .generated.props "
imports + = [
f ' <Import Project= " $(MSBuildProjectDirectory) \\ { p } " Condition= " Exists( \' $(MSBuildProjectDirectory) \\ { p } \' ) " /> '
]
section1 + = [ f " { godot_target } | { sln_plat } = { godot_target } | { sln_plat } " ]
section2 + = [
f " {{ { proj_uuid } }} . { godot_target } | { sln_plat } .ActiveCfg = { godot_target } | { proj_plat } " ,
f " {{ { proj_uuid } }} . { godot_target } | { sln_plat } .Build.0 = { godot_target } | { proj_plat } " ,
]
section1 = sorted ( section1 )
section2 = sorted ( section2 )
proj_template = open ( " misc/msvs/vcxproj.template " , " r " ) . read ( )
proj_template = proj_template . replace ( " %% UUID %% " , proj_uuid )
proj_template = proj_template . replace ( " %% CONFS %% " , " \n " . join ( configurations ) )
proj_template = proj_template . replace ( " %% IMPORTS %% " , " \n " . join ( imports ) )
proj_template = proj_template . replace ( " %% DEFAULT_ITEMS %% " , " \n " . join ( all_items ) )
proj_template = proj_template . replace ( " %% PROPERTIES %% " , " \n " . join ( properties ) )
with open ( f " { project_name } .vcxproj " , " w " ) as f :
f . write ( proj_template )
sln_template = open ( " misc/msvs/sln.template " , " r " ) . read ( )
sln_template = sln_template . replace ( " %% NAME %% " , project_name )
sln_template = sln_template . replace ( " %% UUID %% " , proj_uuid )
sln_template = sln_template . replace ( " %% SLNUUID %% " , sln_uuid )
sln_template = sln_template . replace ( " %% SECTION1 %% " , " \n " . join ( section1 ) )
sln_template = sln_template . replace ( " %% SECTION2 %% " , " \n " . join ( section2 ) )
with open ( f " { project_name } .sln " , " w " ) as f :
f . write ( sln_template )
if get_bool ( original_args , " vsproj_gen_only " , True ) :
sys . exit ( )
Rémi Verschelde