1679 lines
61 KiB
Python
1679 lines
61 KiB
Python
import string
|
|
import os
|
|
import time
|
|
import sys
|
|
from distutils import sysconfig
|
|
import SCons.Script
|
|
|
|
appname = ''
|
|
playername = ''
|
|
|
|
if hex(sys.hexversion) < 0x2030000:
|
|
print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
|
|
print
|
|
print "You need at least Python 2.3 to build Blender with SCons"
|
|
print
|
|
print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
|
|
sys.exit()
|
|
|
|
if sys.platform != 'win32':
|
|
sys.stdout = os.popen("tee build.log", "w")
|
|
sys.stderr = sys.stdout
|
|
|
|
if sys.platform == 'darwin':
|
|
appname = 'blender'
|
|
playername = 'blenderplayer'
|
|
else:
|
|
appname = 'blender$PROGSUFFIX'
|
|
playername = 'blenderplayer$PROGSUFFIX'
|
|
|
|
# This is a flag to determine whether to read all sconscripts and
|
|
# set up the build environments or not
|
|
# when issuing 'scons clean' this is set to 1
|
|
# and all reading is skipped and a 'clean' target
|
|
# will clean the root_build_dir from all
|
|
# object files
|
|
enable_clean = 0
|
|
|
|
all_args = sys.argv[1:]
|
|
parser = SCons.Script.OptParser()
|
|
options, targets = parser.parse_args(all_args)
|
|
if ('clean' in targets):
|
|
enable_clean = 1
|
|
|
|
# Build directory.
|
|
root_build_dir = '..' + os.sep + 'build' + os.sep + sys.platform + os.sep
|
|
|
|
# Create the build directory. SCons does this automatically, but since we
|
|
# don't want to put scons-generated .sconsign files in the source tree, but in
|
|
# the root_build_dir, we have to create that dir ourselves before SCons tries
|
|
# to access/create the file containing .sconsign data.
|
|
if os.path.isdir (root_build_dir) == 0:
|
|
os.makedirs (root_build_dir)
|
|
|
|
# User configurable options file. This can be controlled by the user by running
|
|
# scons with the following argument: CONFIG=user_config_options_file
|
|
config_file = ARGUMENTS.get('CONFIG', 'config.opts')
|
|
|
|
# Blender version.
|
|
version='2.33a'
|
|
shortversion = '233a' # for wininst target -> nsis installer creation
|
|
|
|
sdl_env = Environment ()
|
|
freetype_env = Environment ()
|
|
env = Environment ()
|
|
|
|
if sys.platform == 'linux2' or sys.platform == 'linux-i386':
|
|
use_international = 'false'
|
|
use_gameengine = 'true'
|
|
use_openal = 'false'
|
|
use_fmod = 'false'
|
|
use_quicktime = 'false'
|
|
use_sumo = 'true'
|
|
use_ode = 'false'
|
|
use_buildinfo = 'true'
|
|
build_blender_dynamic = 'true'
|
|
build_blender_static = 'false'
|
|
build_blender_player = 'true'
|
|
build_blender_plugin = 'false'
|
|
release_flags = ['-O2']
|
|
debug_flags = ['-O2', '-g']
|
|
extra_flags = ['-pipe', '-funsigned-char']
|
|
cxxflags = []
|
|
defines = []
|
|
warn_flags = ['-Wall', '-W']
|
|
window_system = 'X11'
|
|
platform_libs = ['m', 'util', 'stdc++']
|
|
platform_libpath = []
|
|
platform_linkflags = ['-pthread']
|
|
extra_includes = []
|
|
# z library information
|
|
z_lib = ['z']
|
|
z_libpath = ['/usr/lib']
|
|
z_include = ['/usr/include']
|
|
# png library information
|
|
png_lib = ['png']
|
|
png_libpath = ['/usr/lib']
|
|
png_include = ['/usr/include']
|
|
# jpeg library information
|
|
jpeg_lib = ['jpeg']
|
|
jpeg_libpath = ['/usr/lib']
|
|
jpeg_include = ['/usr/include']
|
|
# OpenGL library information
|
|
opengl_lib = ['GL', 'GLU']
|
|
opengl_static = ['/usr/lib/libGL.a', '/usr/lib/libGLU.a']
|
|
opengl_libpath = ['/usr/lib', '/usr/X11R6/lib']
|
|
opengl_include = ['/usr/include']
|
|
# SDL library information
|
|
sdl_env.ParseConfig ('sdl-config --cflags --libs')
|
|
sdl_cflags = sdl_env.Dictionary()['CCFLAGS']
|
|
sdl_include = sdl_env.Dictionary()['CPPPATH']
|
|
sdl_libpath = sdl_env.Dictionary()['LIBPATH']
|
|
sdl_lib = sdl_env.Dictionary()['LIBS']
|
|
# SOLID library information
|
|
solid_lib = [] # TODO
|
|
solid_libpath = [] # TODO
|
|
solid_include = ['#extern/solid']
|
|
qhull_lib = [] # TODO
|
|
qhull_libpath = [] # TODO
|
|
qhull_include = ['#extern/qhull/include']
|
|
# ODE library information
|
|
ode_lib = ['ode']
|
|
ode_libpath = ['#../lib/linux-glibc2.2.5-i386/ode/lib']
|
|
ode_include = ['#../lib/linux-glibc2.2.5-i386/ode/include']
|
|
# Python library information
|
|
python_lib = ['python%d.%d' % sys.version_info[0:2]]
|
|
python_libpath = [sysconfig.get_python_lib (0, 1) + '/config']
|
|
python_include = [sysconfig.get_python_inc ()]
|
|
python_linkflags = Split (sysconfig.get_config_var('LINKFORSHARED'))
|
|
# International support information
|
|
ftgl_lib = ['ftgl']
|
|
ftgl_libpath = ['#../lib/linux-glibc2.2.5-i386/ftgl/lib']
|
|
ftgl_include = ['#../lib/linux-glibc2.2.5-i386/ftgl/include']
|
|
freetype_env.ParseConfig ('pkg-config --cflags --libs freetype2 2>/dev/null || freetype-config --cflags --libs 2>/dev/null')
|
|
freetype_lib = freetype_env.Dictionary()['LIBS']
|
|
freetype_libpath = freetype_env.Dictionary()['LIBPATH']
|
|
freetype_include = freetype_env.Dictionary()['CPPPATH']
|
|
gettext_lib = []
|
|
gettext_libpath = []
|
|
gettext_include = []
|
|
# OpenAL library information
|
|
openal_lib = ['openal']
|
|
openal_libpath = ['/usr/lib']
|
|
openal_include = ['/usr/include']
|
|
|
|
elif sys.platform == 'darwin':
|
|
use_international = 'true'
|
|
use_gameengine = 'true'
|
|
use_openal = 'true'
|
|
use_fmod = 'false'
|
|
use_quicktime = 'true'
|
|
use_precomp = 'true'
|
|
use_sumo = 'true'
|
|
use_ode = 'false'
|
|
use_buildinfo = 'true'
|
|
build_blender_dynamic = 'true'
|
|
build_blender_static = 'false'
|
|
build_blender_player = 'true'
|
|
build_blender_plugin = 'false'
|
|
# TODO: replace darwin-6.1-powerpc with the actual directiory on the
|
|
# build machine
|
|
# darwin-6.1 is the name of cvs precomp folder
|
|
# a symbolic link named darwin-X.Y-powerpc must be manually done
|
|
#for now. X-Y is darwin kernel rev number
|
|
darwin_precomp = '#../lib/darwin-6.1-powerpc/'
|
|
fink_path = '/sw/'
|
|
# TODO : try -mpowerpc -mpowerpc-gopt -mpowerpc-gfxopt optims
|
|
# doing actual profiling
|
|
extra_flags = ['-pipe', '-fPIC', '-funsigned-char', '-ffast-math', '-mpowerpc']
|
|
|
|
# , '-malign-natural'] malign is causing problems with jpeg lib but worth a 1-2% speedup
|
|
#'-force_cpusubtype_ALL', '-mpowerpc-gpopt',
|
|
cxxflags = []
|
|
defines = ['_THREAD_SAFE' ]
|
|
if use_quicktime == 'true':
|
|
defines += ['WITH_QUICKTIME']
|
|
warn_flags = ['-Wall'] # , '-W'
|
|
release_flags = ['-O3']
|
|
debug_flags = ['-g']
|
|
window_system = 'CARBON'
|
|
# z library information
|
|
z_lib = ['z']
|
|
z_libpath = []
|
|
z_include = []
|
|
# TODO : add a flag to allow each lib to be build from fink or precomp
|
|
# without having to have to specify the path manually in config.opts.
|
|
# png library information
|
|
png_lib = ['libpng']
|
|
png_libpath = [darwin_precomp + 'png/lib']
|
|
png_include = [darwin_precomp + 'png/include']
|
|
# jpeg library information
|
|
jpeg_lib = ['libjpeg']
|
|
jpeg_libpath = [darwin_precomp + 'jpeg/lib']
|
|
jpeg_include = [darwin_precomp + 'jpeg/include']
|
|
# OpenGL library information
|
|
opengl_lib = ['GL', 'GLU']
|
|
opengl_static = []
|
|
opengl_libpath = []
|
|
opengl_include = []
|
|
# SDL specific stuff.
|
|
sdl_env.ParseConfig ('sdl-config --cflags --libs')
|
|
sdl_cflags = sdl_env.Dictionary()['CCFLAGS']
|
|
# Want to use precompiled libraries?
|
|
if use_precomp == 'true':
|
|
sdl_include = [darwin_precomp + 'sdl/include']
|
|
sdl_libpath = [darwin_precomp + 'sdl/lib']
|
|
sdl_lib = ['libSDL.a']
|
|
platform_libs = ['stdc++']
|
|
extra_includes = ['/sw/include']
|
|
platform_libpath = ['/System/Library/Frameworks/OpenGL.framework/Libraries']
|
|
platform_linkflags = []
|
|
# SOLID library information
|
|
solid_lib = ['libsolid']
|
|
solid_libpath = [darwin_precomp + 'solid/lib']
|
|
solid_include = [darwin_precomp + 'solid/include']
|
|
qhull_lib = ['libqhull']
|
|
qhull_libpath = [darwin_precomp + 'qhull/lib']
|
|
qhull_include = [darwin_precomp + 'qhull/include']
|
|
# ODE library information
|
|
ode_lib = ['libode']
|
|
ode_libpath = [darwin_precomp + 'ode/lib']
|
|
ode_include = [darwin_precomp + 'ode/include/ode']
|
|
# Python variables.
|
|
# TODO : fill vars differently if we are on 10.2 or 10.3
|
|
# python_lib = ['python%d.%d' % sys.version_info[0:2]]
|
|
# python_libpath = [sysconfig.get_python_lib (0, 1) + '/config']
|
|
# python_include = [sysconfig.get_python_inc ()]
|
|
# python_linkflags = Split (sysconfig.get_config_var('LINKFORSHARED'))
|
|
python_lib = []
|
|
python_libpath = ['/System/Library/Frameworks/Python.framework/Versions/2.3/lib/python2.3/config']
|
|
python_include = ['/System/Library/Frameworks/Python.framework/Versions/2.3/include/python2.3']
|
|
python_linkflags = ['-u', '__dummy', '-u', '_PyMac_Error',
|
|
'-framework', 'System',
|
|
'-framework', 'Python',
|
|
'-framework', 'CoreServices',
|
|
'-framework', 'Foundation',
|
|
'-framework', 'OpenGL']
|
|
# International stuff
|
|
ftgl_lib = ['ftgl']
|
|
ftgl_libpath = [darwin_precomp + 'ftgl/lib']
|
|
ftgl_include = [darwin_precomp + 'ftgl/include']
|
|
freetype_lib = ['libfreetype']
|
|
freetype_libpath = [darwin_precomp + 'freetype/lib']
|
|
freetype_include = [darwin_precomp + 'freetype/include']
|
|
gettext_lib = ['libintl']
|
|
gettext_libpath = [darwin_precomp + 'gettext/lib']
|
|
gettext_include = [darwin_precomp + 'gettext/include']
|
|
# OpenAL library information
|
|
openal_lib = ['libopenal']
|
|
openal_libpath = [darwin_precomp + 'openal/lib']
|
|
openal_include = [darwin_precomp + 'openal/include']
|
|
|
|
elif sys.platform == 'cygwin':
|
|
use_international = 'false'
|
|
use_gameengine = 'false'
|
|
use_openal = 'false'
|
|
use_fmod = 'false'
|
|
use_quicktime = 'false'
|
|
use_sumo = 'false'
|
|
use_ode = 'false'
|
|
use_buildinfo = 'false'
|
|
build_blender_dynamic = 'true'
|
|
build_blender_static = 'false'
|
|
build_blender_player = 'false'
|
|
build_blender_plugin = 'false'
|
|
release_flags = ['-O2']
|
|
debug_flags = ['-O2', '-g']
|
|
extra_flags = ['-pipe', '-mno-cygwin', '-mwindows', '-funsigned-char']
|
|
cxxflags = []
|
|
defines = ['FREE_WINDOWS']
|
|
warn_flags = ['-Wall', '-Wno-char-subscripts']
|
|
platform_libs = ['png', 'jpeg', 'netapi32',
|
|
'opengl32', 'glu32', 'winmm',
|
|
'mingw32']
|
|
platform_libpath = ['/usr/lib/w32api', '/lib/w32api']
|
|
platform_linkflags = ['-mwindows', '-mno-cygwin', '-mconsole']
|
|
window_system = 'WIN32'
|
|
extra_includes = []
|
|
# z library information
|
|
z_lib = ['z']
|
|
z_libpath = ['#../lib/windows/zlib/lib']
|
|
z_include = ['#../lib/windows/zlib/include']
|
|
# png library information
|
|
png_lib = ['png']
|
|
png_libpath = ['#../lib/windows/png/lib']
|
|
png_include = ['#../lib/windows/png/include']
|
|
# jpeg library information
|
|
jpeg_lib = ['jpeg']
|
|
jpeg_libpath = ['#../lib/windows/jpeg/lib']
|
|
jpeg_include = ['#../lib/windows/jpeg/include']
|
|
# OpenGL library information
|
|
opengl_lib = ['opengl32', 'glu32']
|
|
opengl_static = []
|
|
opengl_libpath = []
|
|
opengl_include = []
|
|
# SDL specific stuff.
|
|
sdl_include = ['#../lib/windows/sdl/include']
|
|
sdl_libpath = ['#../lib/windows/sdl/lib']
|
|
sdl_lib = ['SDL']
|
|
sdl_cflags = []
|
|
#sdl_cflags = '-DWIN32'
|
|
# SOLID library information
|
|
solid_lib = [] # TODO
|
|
solid_libpath = [] # TODO
|
|
solid_include = ['#extern/solid']
|
|
qhull_lib = [] # TODO
|
|
qhull_libpath = [] # TODO
|
|
qhull_include = ['#extern/qhull/include']
|
|
# ODE library information
|
|
ode_lib = ['ode']
|
|
ode_libpath = ['#../lib/windows/gcc/ode/lib']
|
|
ode_include = ['#../lib/windows/gcc/ode/include']
|
|
# Python library information
|
|
python_include = ['#../lib/windows/python/include/python2.2']
|
|
python_libpath = ['#../lib/windows/python/lib']
|
|
python_lib = ['python22']
|
|
python_linkflags = []
|
|
# International stuff
|
|
ftgl_lib = ['ftgl']
|
|
ftgl_libpath = ['#../lib/windows/gcc/ftgl/lib']
|
|
ftgl_include = ['#../lib/windows/gcc/ftgl/include']
|
|
freetype_lib = ['freetype']
|
|
freetype_libpath = ['#../lib/windows/gcc/freetype/lib']
|
|
freetype_include = ['#../lib/windows/gcc/freetype/include']
|
|
gettext_lib = []
|
|
gettext_libpath = []
|
|
gettext_include = []
|
|
# OpenAL library information
|
|
openal_lib = []
|
|
openal_libpath = []
|
|
openal_include = []
|
|
|
|
elif sys.platform == 'win32':
|
|
use_international = 'true'
|
|
use_gameengine = 'true'
|
|
use_openal = 'true'
|
|
use_fmod = 'false'
|
|
use_quicktime = 'true'
|
|
use_sumo = 'true'
|
|
use_ode = 'false'
|
|
use_buildinfo = 'true'
|
|
build_blender_dynamic = 'true'
|
|
build_blender_static = 'false'
|
|
build_blender_player = 'true'
|
|
build_blender_plugin = 'false'
|
|
release_flags = ['/Og', '/Ot', '/Ob1', '/Op', '/G6']
|
|
debug_flags = ['/Zi', '/Fr${TARGET.base}.sbr']
|
|
extra_flags = ['/EHsc', '/J', '/W3', '/Gd', '/MT']
|
|
cxxflags = []
|
|
defines = ['WIN32', '_CONSOLE']
|
|
defines += ['WITH_QUICKTIME']
|
|
defines += ['_LIB', 'USE_OPENAL']
|
|
defines += ['FTGL_LIBRARY_STATIC']
|
|
warn_flags = []
|
|
platform_libs = [ 'qtmlClient', 'soundsystem',
|
|
'ws2_32', 'dxguid', 'vfw32', 'winmm',
|
|
'iconv', 'kernel32', 'user32', 'gdi32',
|
|
'winspool', 'comdlg32', 'advapi32', 'shell32',
|
|
'ole32', 'oleaut32', 'uuid', 'odbc32', 'odbccp32',
|
|
'libcmt', 'libc']
|
|
platform_libpath = ['#../lib/windows/iconv/lib',
|
|
'#../lib/windows/QTDevWin/Libraries']
|
|
platform_linkflags = [
|
|
'/SUBSYSTEM:CONSOLE',
|
|
'/MACHINE:IX86',
|
|
'/ENTRY:mainCRTStartup',
|
|
'/INCREMENTAL:NO',
|
|
'/NODEFAULTLIB:"msvcprt.lib"',
|
|
'/NODEFAULTLIB:"glut32.lib"',
|
|
'/NODEFAULTLIB:"libcd.lib"',
|
|
#'/NODEFAULTLIB:"libc.lib"',
|
|
'/NODEFAULTLIB:"libcpd.lib"',
|
|
'/NODEFAULTLIB:"libcp.lib"',
|
|
'/NODEFAULTLIB:"libcmtd.lib"',
|
|
]
|
|
window_system = 'WIN32'
|
|
extra_includes = []
|
|
if use_quicktime == 'true':
|
|
extra_includes += ['#../lib/windows/QTDevWin/CIncludes']
|
|
# z library information
|
|
z_lib = ['libz_st']
|
|
z_libpath = ['#../lib/windows/zlib/lib']
|
|
z_include = ['#../lib/windows/zlib/include']
|
|
# png library information
|
|
png_lib = ['libpng_st']
|
|
png_libpath = ['#../lib/windows/png/lib']
|
|
png_include = ['#../lib/windows/png/include']
|
|
# jpeg library information
|
|
jpeg_lib = ['libjpeg']
|
|
jpeg_libpath = ['#../lib/windows/jpeg/lib']
|
|
jpeg_include = ['#../lib/windows/jpeg/include']
|
|
# OpenGL library information
|
|
opengl_lib = ['opengl32', 'glu32']
|
|
opengl_static = []
|
|
opengl_libpath = []
|
|
opengl_include = ['/usr/include']
|
|
# SDL library information
|
|
sdl_include = ['#../lib/windows/sdl/include']
|
|
sdl_libpath = ['#../lib/windows/sdl/lib']
|
|
sdl_lib = ['SDL']
|
|
sdl_cflags = []
|
|
window_system = 'WIN32'
|
|
# SOLID library information
|
|
solid_lib = ['extern/solid']
|
|
solid_libpath = ['#../lib/windows/solid/lib']
|
|
solid_include = ['#extern/solid']
|
|
qhull_lib = ['qhull']
|
|
qhull_libpath = ['#../lib/windows/qhull/lib']
|
|
qhull_include = ['#extern/qhull/include']
|
|
# ODE library information
|
|
ode_lib = [] # TODO
|
|
ode_libpath = ['#../lib/windows/ode/lib']
|
|
ode_include = ['#../lib/windows/ode/include']
|
|
# Python lib name
|
|
python_include = ['#../lib/windows/python/include/python2.3']
|
|
python_libpath = ['#../lib/windows/python/lib']
|
|
python_lib = ['python23']
|
|
python_linkflags = []
|
|
# International stuff
|
|
ftgl_lib = ['ftgl_static_ST']
|
|
ftgl_libpath = ['#../lib/windows/ftgl/lib']
|
|
ftgl_include = ['#../lib/windows/ftgl/include']
|
|
freetype_lib = ['freetype2ST']
|
|
freetype_libpath = ['#../lib/windows/freetype/lib']
|
|
freetype_include = ['#../lib/windows/freetype/include']
|
|
gettext_lib = ['gnu_gettext']
|
|
gettext_libpath = ['#../lib/windows/gettext/lib']
|
|
gettext_include = ['#../lib/windows/gettext/include']
|
|
# OpenAL library information
|
|
openal_lib = ['openal_static']
|
|
openal_libpath = ['#../lib/windows/openal/lib']
|
|
openal_include = ['#../lib/windows/openal/include']
|
|
|
|
elif string.find (sys.platform, 'sunos') != -1:
|
|
use_international = 'true'
|
|
use_gameengine = 'false'
|
|
use_openal = 'false'
|
|
use_fmod = 'false'
|
|
use_quicktime = 'false'
|
|
use_sumo = 'false'
|
|
use_ode = 'false'
|
|
use_buildinfo = 'false'
|
|
build_blender_dynamic = 'true'
|
|
build_blender_static = 'false'
|
|
build_blender_player = 'false'
|
|
build_blender_plugin = 'false'
|
|
release_flags = ['-O2']
|
|
debug_flags = ['-O2', '-g']
|
|
extra_flags = ['-pipe', '-fPIC', '-funsigned-char', '-DSUN_OGL_NO_VERTEX_MACROS']
|
|
cxxflags = []
|
|
defines = []
|
|
warn_flags = ['-Wall', '-W']
|
|
window_system = 'X11'
|
|
platform_libs = ['stdc++', 'dl', 'm']
|
|
platform_libpath = []
|
|
platform_linkflags = []
|
|
extra_includes = []
|
|
# z library information
|
|
z_lib = ['z']
|
|
z_libpath = []
|
|
z_include = []
|
|
# png library information
|
|
png_lib = ['png']
|
|
png_libpath = []
|
|
png_include = []
|
|
# jpeg library information
|
|
jpeg_lib = ['jpeg']
|
|
jpeg_libpath = []
|
|
jpeg_include = []
|
|
# OpenGL library information
|
|
opengl_lib = ['GL', 'GLU', 'X11']
|
|
opengl_static = []
|
|
opengl_libpath = ['/usr/openwin/include']
|
|
opengl_include = ['/usr/openwin/lib']
|
|
# SDL library information
|
|
sdl_env.ParseConfig ('sdl-config --cflags --libs')
|
|
sdl_cflags = sdl_env.Dictionary()['CCFLAGS']
|
|
sdl_include = sdl_env.Dictionary()['CPPPATH']
|
|
sdl_libpath = sdl_env.Dictionary()['LIBPATH']
|
|
sdl_lib = sdl_env.Dictionary()['LIBS']
|
|
# SOLID library information
|
|
solid_lib = [] # TODO
|
|
solid_libpath = [] # TODO
|
|
solid_include = ['#extern/solid']
|
|
qhull_lib = [] # TODO
|
|
qhull_libpath = [] # TODO
|
|
qhull_include = ['#extern/qhull/include']
|
|
# ODE library information
|
|
ode_lib = [] # TODO
|
|
ode_libpath = [] # TODO
|
|
ode_include = ['#extern/ode/dist/include/ode']
|
|
# Python variables.
|
|
python_lib = ['python%d.%d' % sys.version_info[0:2]]
|
|
python_libpath = [sysconfig.get_python_lib (0, 1) + '/config']
|
|
python_include = [sysconfig.get_python_inc ()]
|
|
python_linkflags = []
|
|
# International support information
|
|
ftgl_lib = ['ftgl']
|
|
ftgl_libpath = ['#../lib/solaris-2.8-sparc/ftgl/lib']
|
|
ftgl_include = ['#../lib/solaris-2.8-sparc/ftgl/include']
|
|
freetype_lib = ['freetype']
|
|
freetype_libpath = ['#../lib/solaris-2.8-sparc/freetype/lib']
|
|
freetype_include = ['#../lib/solaris-2.8-sparc/freetype/include']
|
|
gettext_lib = []
|
|
gettext_libpath = []
|
|
gettext_include = []
|
|
# OpenAL library information
|
|
openal_lib = []
|
|
openal_libpath = []
|
|
openal_include = []
|
|
|
|
elif string.find (sys.platform, 'irix') != -1:
|
|
use_international = 'false'
|
|
use_gameengine = 'false'
|
|
use_openal = 'false'
|
|
use_fmod = 'false'
|
|
use_quicktime = 'false'
|
|
use_sumo = 'false'
|
|
use_ode = 'false'
|
|
use_buildinfo = 'false'
|
|
build_blender_dynamic = 'true'
|
|
build_blender_static = 'false'
|
|
build_blender_player = 'false'
|
|
build_blender_plugin = 'false'
|
|
irix_precomp = '#../lib/irix-6.5-mips'
|
|
extra_flags = ['-n32', '-mips3', '-Xcpluscomm']
|
|
cxxflags = ['-n32', '-mips3', '-Xcpluscomm', '-LANG:std']
|
|
cxxflags += ['-LANG:libc_in_namespace_std=off']
|
|
|
|
window_system = 'X11'
|
|
release_flags = ['-O2', '-OPT:Olimit=0']
|
|
debug_flags = ['-O2', '-g']
|
|
defines = []
|
|
warn_flags = ['-fullwarn', '-woff', '1001,1110,1201,1209,1355,1424,1681,3201']
|
|
platform_libs = ['movieGL', 'Xmu', 'Xext', 'X11',
|
|
'c', 'm', 'dmedia', 'cl', 'audio',
|
|
'Cio', 'pthread']
|
|
platform_libpath = ['/usr/lib32/mips3',
|
|
'/lib/freeware/lib32',
|
|
'/usr/lib32']
|
|
platform_linkflags = ['-mips3', '-n32']
|
|
extra_includes = ['/usr/freeware/include',
|
|
'/usr/include']
|
|
# z library information
|
|
z_lib = ['z']
|
|
z_libpath = []
|
|
z_include = []
|
|
# png library information
|
|
png_lib = ['png']
|
|
png_libpath = [irix_precomp + '/png/lib']
|
|
png_include = [irix_precomp + '/png/include']
|
|
# jpeg library information
|
|
jpeg_lib = ['jpeg']
|
|
jpeg_libpath = [irix_precomp + '/jpeg/lib']
|
|
jpeg_include = [irix_precomp + '/jpeg/include']
|
|
# OpenGL library information
|
|
opengl_lib = ['GL', 'GLU']
|
|
opengl_static = []
|
|
opengl_libpath = []
|
|
opengl_include = []
|
|
# SDL library information
|
|
sdl_cflags = []
|
|
sdl_include = [irix_precomp + '/sdl/include/SDL']
|
|
sdl_libpath = [irix_precomp + '/sdl/lib']
|
|
sdl_lib = ['SDL', 'libSDL.a']
|
|
# SOLID library information
|
|
solid_lib = [] # TODO
|
|
solid_libpath = [] # TODO
|
|
solid_include = [irix_precomp + '/solid/include']
|
|
qhull_lib = [] # TODO
|
|
qhull_libpath = [] # TODO
|
|
qhull_include = ['#extern/qhull/include']
|
|
# ODE library information
|
|
ode_lib = [] # TODO
|
|
ode_libpath = [] # TODO
|
|
ode_include = [irix_precomp + '/ode/include']
|
|
# Python library information
|
|
python_libpath = [irix_precomp + '/python/lib/python2.2/config']
|
|
python_include = [irix_precomp + '/python/include/python2.2']
|
|
python_lib = ['python2.2']
|
|
python_linkflags = []
|
|
# International support information
|
|
ftgl_lib = ['ftgl']
|
|
ftgl_libpath = [irix_precomp + '/ftgl/lib']
|
|
ftgl_include = [irix_precomp + '/ftgl/include']
|
|
freetype_lib = ['freetype']
|
|
freetype_libpath = [irix_precomp + '/freetype/lib']
|
|
freetype_include = [irix_precomp + '/freetype/include']
|
|
gettext_lib = []
|
|
gettext_libpath = []
|
|
gettext_include = []
|
|
# OpenAL library information
|
|
openal_lib = []
|
|
openal_libpath = []
|
|
openal_include = []
|
|
|
|
elif string.find (sys.platform, 'hp-ux') != -1:
|
|
window_system = 'X11'
|
|
defines = []
|
|
|
|
elif sys.platform=='openbsd3':
|
|
print "Building for OpenBSD 3.x"
|
|
use_international = 'false'
|
|
use_gameengine = 'false'
|
|
use_openal = 'false'
|
|
use_fmod = 'false'
|
|
use_quicktime = 'false'
|
|
use_sumo = 'false'
|
|
use_ode = 'false'
|
|
use_buildinfo = 'true'
|
|
build_blender_dynamic = 'true'
|
|
build_blender_static = 'false'
|
|
build_blender_player = 'false'
|
|
build_blender_plugin = 'false'
|
|
release_flags = ['-O2']
|
|
debug_flags = ['-O2', '-g']
|
|
extra_flags = ['-pipe', '-fPIC', '-funsigned-char']
|
|
cxxflags = []
|
|
defines = []
|
|
warn_flags = ['-Wall','-W']
|
|
window_system = 'X11'
|
|
platform_libs = ['m', 'stdc++', 'pthread', 'util']
|
|
platform_libpath = []
|
|
platform_linkflags = []
|
|
extra_includes = []
|
|
z_lib = ['z']
|
|
z_libpath = ['/usr/lib']
|
|
z_include = ['/usr/include']
|
|
# png library information
|
|
png_lib = ['png']
|
|
png_libpath = ['/usr/local/lib']
|
|
png_include = ['/usr/local/include']
|
|
# jpeg library information
|
|
jpeg_lib = ['jpeg']
|
|
jpeg_libpath = ['/usr/local/lib']
|
|
jpeg_include = ['/usr/local/include']
|
|
# OpenGL library information
|
|
opengl_lib = ['GL', 'GLU']
|
|
opengl_static = ['/usr/lib/libGL.a', '/usr/lib/libGLU.a']
|
|
opengl_libpath = ['/usr/lib', '/usr/X11R6/lib']
|
|
opengl_include = ['/usr/X11R6/include/']
|
|
# SDL library information
|
|
sdl_env.ParseConfig ('sdl-config --cflags --libs')
|
|
sdl_cflags = sdl_env.Dictionary()['CCFLAGS']
|
|
sdl_include = sdl_env.Dictionary()['CPPPATH']
|
|
sdl_libpath = sdl_env.Dictionary()['LIBPATH']
|
|
sdl_lib = sdl_env.Dictionary()['LIBS']
|
|
# SOLID library information
|
|
solid_lib = [] # TODO
|
|
solid_libpath = [] # TODO
|
|
solid_include = ['#extern/solid']
|
|
qhull_lib = [] # TODO
|
|
qhull_libpath = [] # TODO
|
|
qhull_include = ['#extern/qhull/include']
|
|
# ODE library information
|
|
ode_lib = ['ode']
|
|
ode_libpath = ['#../lib/linux-glibc2.2.5-i386/ode/lib']
|
|
ode_include = ['#../lib/linux-glibc2.2.5-i386/ode/include']
|
|
# Python library information
|
|
python_lib = ['python%d.%d' % sys.version_info[0:2]]
|
|
python_libpath = [sysconfig.get_python_lib (0, 1) + '/config']
|
|
python_include = [sysconfig.get_python_inc ()]
|
|
python_linkflags = []
|
|
# International support information
|
|
ftgl_lib = ['ftgl']
|
|
ftgl_libpath = ['#../lib/linux-glibc2.2.5-i386/ftgl/lib']
|
|
ftgl_include = ['#../lib/linux-glibc2.2.5-i386/ftgl/include']
|
|
freetype_env.ParseConfig('pkg-config --cflags --libs freetype2')
|
|
freetype_lib = freetype_env.Dictionary()['LIBS']
|
|
freetype_libpath = freetype_env.Dictionary()['LIBPATH']
|
|
freetype_include = freetype_env.Dictionary()['CPPPATH']
|
|
gettext_lib = []
|
|
gettext_libpath = []
|
|
gettext_include = []
|
|
# OpenAL library information
|
|
openal_lib = ['openal']
|
|
openal_libpath = ['/usr/lib']
|
|
openal_include = ['/usr/include']
|
|
|
|
else:
|
|
print "Unknown platform %s"%sys.platform
|
|
exit
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# End of platform specific section
|
|
#-----------------------------------------------------------------------------
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# User configurable options to be saved in a config file.
|
|
#-----------------------------------------------------------------------------
|
|
# Checking for an existing config file - use that one if it exists,
|
|
# otherwise create one.
|
|
my_defines = []
|
|
my_ccflags = []
|
|
my_cxxflags = []
|
|
my_ldflags = []
|
|
if os.path.exists (config_file):
|
|
print "Using config file: " + config_file
|
|
else:
|
|
print "Creating new config file: " + config_file
|
|
env_dict = env.Dictionary()
|
|
config=open (config_file, 'w')
|
|
config.write ("# Configuration file containing user definable options.\n")
|
|
config.write ("VERSION = '2.33-cvs'\n")
|
|
config.write ("BUILD_BINARY = 'release'\n")
|
|
config.write ("USE_BUILDINFO = %r\n"%(use_buildinfo))
|
|
config.write ("BUILD_BLENDER_DYNAMIC = %r\n"%(build_blender_dynamic))
|
|
config.write ("BUILD_BLENDER_STATIC = %r\n"%(build_blender_static))
|
|
config.write ("BUILD_BLENDER_PLAYER = %r\n"%(build_blender_player))
|
|
config.write ("BUILD_BLENDER_PLUGIN = %r\n"%(build_blender_plugin))
|
|
config.write ("BUILD_DIR = %r\n"%(root_build_dir))
|
|
|
|
config.write ("\n# Extra compiler flags can be defined here.\n")
|
|
config.write ("DEFINES = %s\n"%(my_defines))
|
|
config.write ("CCFLAGS = %s\n"%(my_ccflags))
|
|
config.write ("CXXFLAGS = %s\n"%(my_cxxflags))
|
|
config.write ("LDFLAGS = %s\n"%(my_ldflags))
|
|
|
|
config.write ("USE_INTERNATIONAL = %r\n"%(use_international))
|
|
config.write ("BUILD_GAMEENGINE = %r\n"%(use_gameengine))
|
|
if use_ode == 'true':
|
|
config.write ("USE_PHYSICS = 'ode'\n")
|
|
else:
|
|
config.write ("USE_PHYSICS = 'solid'\n")
|
|
config.write ("USE_OPENAL = %r\n"%(use_openal))
|
|
config.write ("USE_FMOD = %r\n"%(use_fmod))
|
|
config.write ("USE_QUICKTIME = %r\n"%(use_quicktime))
|
|
config.write ("\n# Compiler information.\n")
|
|
config.write ("HOST_CC = %r\n"%(env_dict['CC']))
|
|
config.write ("HOST_CXX = %r\n"%(env_dict['CXX']))
|
|
config.write ("TARGET_CC = %r\n"%(env_dict['CC']))
|
|
config.write ("TARGET_CXX = %r\n"%(env_dict['CXX']))
|
|
config.write ("TARGET_AR = %r\n"%(env_dict['AR']))
|
|
config.write ("PATH = %r\n"%(os.environ['PATH']))
|
|
config.write ("\n# External library information.\n")
|
|
config.write ("PLATFORM_LIBS = %r\n"%(platform_libs))
|
|
config.write ("PLATFORM_LIBPATH = %r\n"%(platform_libpath))
|
|
config.write ("PLATFORM_LINKFLAGS = %r\n"%(platform_linkflags))
|
|
config.write ("PYTHON_INCLUDE = %r\n"%(python_include))
|
|
config.write ("PYTHON_LIBPATH = %r\n"%(python_libpath))
|
|
config.write ("PYTHON_LIBRARY = %r\n"%(python_lib))
|
|
config.write ("PYTHON_LINKFLAGS = %r\n"%(python_linkflags))
|
|
config.write ("SDL_CFLAGS = %r\n"%(sdl_cflags))
|
|
config.write ("SDL_INCLUDE = %r\n"%(sdl_include))
|
|
config.write ("SDL_LIBPATH = %r\n"%(sdl_libpath))
|
|
config.write ("SDL_LIBRARY = %r\n"%(sdl_lib))
|
|
config.write ("Z_INCLUDE = %r\n"%(z_include))
|
|
config.write ("Z_LIBPATH = %r\n"%(z_libpath))
|
|
config.write ("Z_LIBRARY = %r\n"%(z_lib))
|
|
config.write ("PNG_INCLUDE = %r\n"%(png_include))
|
|
config.write ("PNG_LIBPATH = %r\n"%(png_libpath))
|
|
config.write ("PNG_LIBRARY = %r\n"%(png_lib))
|
|
config.write ("JPEG_INCLUDE = %r\n"%(jpeg_include))
|
|
config.write ("JPEG_LIBPATH = %r\n"%(jpeg_libpath))
|
|
config.write ("JPEG_LIBRARY = %r\n"%(jpeg_lib))
|
|
config.write ("OPENGL_INCLUDE = %r\n"%(opengl_include))
|
|
config.write ("OPENGL_LIBPATH = %r\n"%(opengl_libpath))
|
|
config.write ("OPENGL_LIBRARY = %r\n"%(opengl_lib))
|
|
config.write ("OPENGL_STATIC = %r\n"%(opengl_static))
|
|
config.write ("\n# The following information is only necessary when you've enabled support for\n")
|
|
config.write ("# the game engine.\n")
|
|
config.write ("SOLID_INCLUDE = %r\n"%(solid_include))
|
|
config.write ("SOLID_LIBPATH = %r\n"%(solid_libpath))
|
|
config.write ("SOLID_LIBRARY = %r\n"%(solid_lib))
|
|
config.write ("QHULL_INCLUDE = %r\n"%(qhull_include))
|
|
config.write ("QHULL_LIBPATH = %r\n"%(qhull_libpath))
|
|
config.write ("QHULL_LIBRARY = %r\n"%(qhull_lib))
|
|
config.write ("ODE_INCLUDE = %r\n"%(ode_include))
|
|
config.write ("ODE_LIBPATH = %r\n"%(ode_libpath))
|
|
config.write ("ODE_LIBRARY = %r\n"%(ode_lib))
|
|
config.write ("OPENAL_INCLUDE = %r\n"%(openal_include))
|
|
config.write ("OPENAL_LIBPATH = %r\n"%(openal_libpath))
|
|
config.write ("OPENAL_LIBRARY = %r\n"%(openal_lib))
|
|
config.write ("\n# The following information is only necessary when building with\n")
|
|
config.write ("# internationalization support.\n");
|
|
config.write ("FTGL_INCLUDE = %r\n"%(ftgl_include))
|
|
config.write ("FTGL_LIBPATH = %r\n"%(ftgl_libpath))
|
|
config.write ("FTGL_LIBRARY = %r\n"%(ftgl_lib))
|
|
config.write ("FREETYPE_INCLUDE = %r\n"%(freetype_include))
|
|
config.write ("FREETYPE_LIBPATH = %r\n"%(freetype_libpath))
|
|
config.write ("FREETYPE_LIBRARY = %r\n"%(freetype_lib))
|
|
config.write ("GETTEXT_INCLUDE = %r\n"%(gettext_include))
|
|
config.write ("GETTEXT_LIBPATH = %r\n"%(gettext_libpath))
|
|
config.write ("GETTEXT_LIBRARY = %r\n"%(gettext_lib))
|
|
config.close ()
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Read the options from the config file and update the various necessary flags
|
|
#-----------------------------------------------------------------------------
|
|
list_opts = []
|
|
user_options_env = Environment ()
|
|
user_options = Options (config_file)
|
|
user_options.AddOptions (
|
|
('VERSION', 'Blender version', version),
|
|
(EnumOption ('BUILD_BINARY', 'release',
|
|
'Select a release or debug binary.',
|
|
allowed_values = ('release', 'debug'))),
|
|
(BoolOption ('USE_BUILDINFO',
|
|
'Set to 1 if you want to add build information.',
|
|
'false')),
|
|
(BoolOption ('BUILD_BLENDER_DYNAMIC',
|
|
'Set to 1 if you want to build blender with hardware accellerated OpenGL support.',
|
|
'true')),
|
|
(BoolOption ('BUILD_BLENDER_STATIC',
|
|
'Set to 1 if you want to build blender with software OpenGL support.',
|
|
'false')),
|
|
(BoolOption ('BUILD_BLENDER_PLAYER',
|
|
'Set to 1 if you want to build the blender player.',
|
|
'false')),
|
|
(BoolOption ('BUILD_BLENDER_PLUGIN',
|
|
'Set to 1 if you want to build the blender plugin.',
|
|
'false')),
|
|
('BUILD_DIR', 'Target directory for intermediate files.',
|
|
root_build_dir),
|
|
(BoolOption ('USE_INTERNATIONAL',
|
|
'Set to 1 to have international support.',
|
|
'false')),
|
|
(EnumOption ('USE_PHYSICS', 'solid',
|
|
'Select which physics engine to use.',
|
|
allowed_values = ('ode', 'solid'))),
|
|
(BoolOption ('BUILD_GAMEENGINE',
|
|
'Set to 1 to build blender with game engine support.',
|
|
'false')),
|
|
(BoolOption ('USE_OPENAL',
|
|
'Set to 1 to build the game engine with OpenAL support.',
|
|
'false')),
|
|
(BoolOption ('USE_FMOD',
|
|
'Set to 1 to build the game engine with FMod support.',
|
|
'false')),
|
|
(BoolOption ('USE_QUICKTIME',
|
|
'Set to 1 to add support for QuickTime.',
|
|
'false')),
|
|
('HOST_CC', 'C compiler for the host platfor. This is the same as target platform when not cross compiling.'),
|
|
('HOST_CXX', 'C++ compiler for the host platform. This is the same as target platform when not cross compiling.'),
|
|
('TARGET_CC', 'C compiler for the target platform.'),
|
|
('TARGET_CXX', 'C++ compiler for the target platform.'),
|
|
('TARGET_AR', 'Linker command for linking libraries.'),
|
|
('PATH', 'Standard search path'),
|
|
('PLATFORM_LIBS', 'Platform specific libraries.'),
|
|
('PLATFORM_LIBPATH', 'Platform specific library link path.'),
|
|
('PLATFORM_LINKFLAGS', 'Platform specific linkflags'),
|
|
('PYTHON_INCLUDE', 'Include directory for Python header files.'),
|
|
('PYTHON_LIBPATH', 'Library path where the Python lib is located.'),
|
|
('PYTHON_LIBRARY', 'Python library name.'),
|
|
('PYTHON_LINKFLAGS', 'Python specific linkflags.'),
|
|
('SDL_CFLAGS', 'Necessary CFLAGS when using sdl functionality.'),
|
|
('SDL_INCLUDE', 'Include directory for SDL header files.'),
|
|
('SDL_LIBPATH', 'Library path where the SDL library is located.'),
|
|
('SDL_LIBRARY', 'SDL library name.'),
|
|
('Z_INCLUDE', 'Include directory for zlib header files.'),
|
|
('Z_LIBPATH', 'Library path where the zlib library is located.'),
|
|
('Z_LIBRARY', 'Z library name.'),
|
|
('PNG_INCLUDE', 'Include directory for png header files.'),
|
|
('PNG_LIBPATH', 'Library path where the png library is located.'),
|
|
('PNG_LIBRARY', 'png library name.'),
|
|
('JPEG_INCLUDE', 'Include directory for jpeg header files.'),
|
|
('JPEG_LIBPATH', 'Library path where the jpeg library is located.'),
|
|
('JPEG_LIBRARY', 'jpeg library name.'),
|
|
('OPENGL_INCLUDE', 'Include directory for OpenGL header files.'),
|
|
('OPENGL_LIBPATH', 'Library path where the OpenGL libraries are located.'),
|
|
('OPENGL_LIBRARY', 'OpenGL library names.'),
|
|
('OPENGL_STATIC', 'Linker flags for static linking of Open GL.'),
|
|
('SOLID_INCLUDE', 'Include directory for SOLID header files.'),
|
|
('SOLID_LIBPATH', 'Library path where the SOLID library is located.'),
|
|
('SOLID_LIBRARY', 'SOLID library name.'),
|
|
('QHULL_INCLUDE', 'Include directory for QHULL header files.'),
|
|
('QHULL_LIBPATH', 'Library path where the QHULL library is located.'),
|
|
('QHULL_LIBRARY', 'QHULL library name.'),
|
|
('ODE_INCLUDE', 'Include directory for ODE header files.'),
|
|
('ODE_LIBPATH', 'Library path where the ODE library is located.'),
|
|
('ODE_LIBRARY', 'ODE library name.'),
|
|
('OPENAL_INCLUDE', 'Include directory for OpenAL header files.'),
|
|
('OPENAL_LIBPATH', 'Library path where the OpenAL library is located.'),
|
|
('OPENAL_LIBRARY', 'OpenAL library name.'),
|
|
('FTGL_INCLUDE', 'Include directory for ftgl header files.'),
|
|
('FTGL_LIBPATH', 'Library path where the ftgl library is located.'),
|
|
('FTGL_LIBRARY', 'ftgl library name.'),
|
|
('FREETYPE_INCLUDE', 'Include directory for freetype2 header files.'),
|
|
('FREETYPE_LIBPATH', 'Library path where the freetype2 library is located.'),
|
|
('FREETYPE_LIBRARY', 'Freetype2 library name.'),
|
|
('GETTEXT_INCLUDE', 'Include directory for gettext header files.'),
|
|
('GETTEXT_LIBPATH', 'Library path where the gettext library is located.'),
|
|
('GETTEXT_LIBRARY', 'gettext library name.'),
|
|
|
|
('DEFINES', 'Extra Preprocessor defines.'),
|
|
('CCFLAGS', 'Extra C Compiler flags.'),
|
|
('CXXFLAGS','Extra C++ Compiler flags.'),
|
|
('LDFLAGS', 'Extra Linker flags.')
|
|
)
|
|
user_options.Update (user_options_env)
|
|
user_options_dict = user_options_env.Dictionary()
|
|
|
|
root_build_dir = user_options_dict['BUILD_DIR']
|
|
|
|
if user_options_dict['BUILD_GAMEENGINE'] == 1:
|
|
defines += ['GAMEBLENDER=1']
|
|
if user_options_dict['USE_PHYSICS'] == 'ode':
|
|
defines += ['USE_ODE']
|
|
else:
|
|
defines += ['USE_SUMO_SOLID']
|
|
else:
|
|
defines += ['GAMEBLENDER=0']
|
|
|
|
if user_options_dict['BUILD_BINARY'] == 'release':
|
|
cflags = extra_flags + release_flags + warn_flags
|
|
defines += ['NDEBUG']
|
|
else:
|
|
cflags = extra_flags + debug_flags + warn_flags
|
|
if sys.platform == 'win32':
|
|
#defines += ['_DEBUG'] specifying this makes msvc want to link to python22_d.lib??
|
|
platform_linkflags += ['/DEBUG','/PDB:blender.pdb']
|
|
|
|
defines += user_options_dict['DEFINES']
|
|
cflags += user_options_dict['CCFLAGS']
|
|
cxxflags += user_options_dict['CXXFLAGS']
|
|
platform_linkflags += user_options_dict['LDFLAGS']
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Generic library generation environment. This one is the basis for each
|
|
# library.
|
|
#-----------------------------------------------------------------------------
|
|
library_env = env.Copy ()
|
|
library_env.Replace (CC = user_options_dict['TARGET_CC'])
|
|
library_env.Replace (CXX = user_options_dict['TARGET_CXX'])
|
|
library_env.Replace (PATH = user_options_dict['PATH'])
|
|
library_env.Replace (AR = user_options_dict['TARGET_AR'])
|
|
library_env.Append (CCFLAGS = cflags)
|
|
library_env.Append (CXXFLAGS = cxxflags)
|
|
library_env.Append (CPPDEFINES = defines)
|
|
library_env.SConsignFile (root_build_dir+'scons-signatures')
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Settings to be exported to other SConscript files
|
|
#-----------------------------------------------------------------------------
|
|
|
|
if enable_clean==0: # only read SConscripts when not cleaning, this to cut overhead
|
|
Export ('cflags')
|
|
Export ('defines')
|
|
Export ('window_system')
|
|
Export ('extra_includes')
|
|
Export ('user_options_dict')
|
|
Export ('library_env')
|
|
|
|
BuildDir (root_build_dir+'/extern', 'extern', duplicate=0)
|
|
SConscript (root_build_dir+'extern/SConscript')
|
|
BuildDir (root_build_dir+'/intern', 'intern', duplicate=0)
|
|
SConscript (root_build_dir+'intern/SConscript')
|
|
BuildDir (root_build_dir+'/source', 'source', duplicate=0)
|
|
SConscript (root_build_dir+'source/SConscript')
|
|
|
|
libpath = (['#'+root_build_dir+'/lib'])
|
|
|
|
link_env = library_env.Copy ()
|
|
link_env.Append (LIBPATH=libpath)
|
|
|
|
|
|
def common_libs(env):
|
|
"""
|
|
Append to env all libraries that are common to Blender and Blenderplayer
|
|
"""
|
|
env.Append (LIBS=[
|
|
'blender_blenloader',
|
|
'blender_readblenfile',
|
|
'blender_img',
|
|
'blender_blenkernel',
|
|
'blender_blenpluginapi',
|
|
'blender_imbuf',
|
|
'blender_avi',
|
|
'blender_blenlib',
|
|
'blender_makesdna',
|
|
'blender_kernel',
|
|
'blender_GHOST',
|
|
'blender_STR',
|
|
'blender_guardedalloc',
|
|
'blender_CTR',
|
|
'blender_MEM',
|
|
'blender_MT',
|
|
'blender_BMF',
|
|
'soundsystem'])
|
|
if user_options_dict['USE_QUICKTIME'] == 1:
|
|
env.Append (LIBS=['blender_quicktime'])
|
|
|
|
|
|
def international_libs(env):
|
|
"""
|
|
Append international font support libraries
|
|
"""
|
|
if user_options_dict['USE_INTERNATIONAL'] == 1:
|
|
env.Append (LIBS=user_options_dict['FREETYPE_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['FREETYPE_LIBPATH'])
|
|
env.Append (LIBS=['blender_FTF'])
|
|
env.Append (LIBS=user_options_dict['FTGL_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['FTGL_LIBPATH'])
|
|
env.Append (LIBS=user_options_dict['FREETYPE_LIBRARY'])
|
|
|
|
def blender_libs(env):
|
|
"""
|
|
Blender only libs (not in player)
|
|
"""
|
|
env.Append( LIBS=['blender_creator',
|
|
'blender_blendersrc',
|
|
'blender_render',
|
|
'blender_yafray',
|
|
'blender_renderconverter',
|
|
'blender_radiosity',
|
|
'blender_LOD',
|
|
'blender_BSP',
|
|
'blender_blenkernel',
|
|
'blender_IK',
|
|
'blender_ONL'])
|
|
|
|
def ketsji_libs(env):
|
|
"""
|
|
Game Engine libs
|
|
"""
|
|
if user_options_dict['BUILD_GAMEENGINE'] == 1:
|
|
env.Append (LIBS=['KX_blenderhook',
|
|
'KX_converter',
|
|
'PHY_Dummy',
|
|
'PHY_Physics',
|
|
'KX_ketsji',
|
|
'SCA_GameLogic',
|
|
'RAS_rasterizer',
|
|
'RAS_OpenGLRasterizer',
|
|
'blender_expressions',
|
|
'SG_SceneGraph',
|
|
'blender_MT',
|
|
'KX_blenderhook',
|
|
'KX_network',
|
|
'blender_kernel',
|
|
'NG_network',
|
|
'NG_loopbacknetwork'])
|
|
if user_options_dict['USE_PHYSICS'] == 'solid':
|
|
env.Append (LIBS=['PHY_Sumo', 'PHY_Physics', 'blender_MT', 'extern_solid', 'extern_qhull'])
|
|
else:
|
|
env.Append (LIBS=['PHY_Ode',
|
|
'PHY_Physics'])
|
|
env.Append (LIBS=user_options_dict['ODE_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['ODE_LIBPATH'])
|
|
|
|
def player_libs(env):
|
|
"""
|
|
Player libraries
|
|
"""
|
|
env.Append (LIBS=['GPG_ghost',
|
|
'GPC_common'])
|
|
|
|
def player_libs2(env):
|
|
"""
|
|
Link order shenannigans: these libs are added after common_libs
|
|
"""
|
|
env.Append (LIBS=['blender_blenkernel_blc',
|
|
'soundsystem'])
|
|
|
|
def winblenderres(env):
|
|
"""
|
|
build the windows icon resource file
|
|
"""
|
|
if sys.platform == 'win32':
|
|
env.RES(['source/icons/winblender.rc'])
|
|
|
|
def system_libs(env):
|
|
"""
|
|
System libraries: Python, SDL, PNG, JPEG, Gettext, OpenAL, Carbon
|
|
"""
|
|
env.Append (LIBS=['blender_python'])
|
|
env.Append (LIBS=user_options_dict['PYTHON_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['PYTHON_LIBPATH'])
|
|
env.Append (LINKFLAGS=user_options_dict['PYTHON_LINKFLAGS'])
|
|
env.Append (LIBS=user_options_dict['SDL_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['SDL_LIBPATH'])
|
|
env.Append (LIBS=user_options_dict['PNG_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['PNG_LIBPATH'])
|
|
env.Append (LIBS=user_options_dict['JPEG_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['JPEG_LIBPATH'])
|
|
env.Append (LIBS=user_options_dict['GETTEXT_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['GETTEXT_LIBPATH'])
|
|
env.Append (LIBS=user_options_dict['Z_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['Z_LIBPATH'])
|
|
if user_options_dict['USE_OPENAL'] == 1:
|
|
env.Append (LIBS=user_options_dict['OPENAL_LIBRARY'])
|
|
env.Append (LIBPATH=user_options_dict['OPENAL_LIBPATH'])
|
|
env.Append (LIBS=user_options_dict['PLATFORM_LIBS'])
|
|
env.Append (LIBPATH=user_options_dict['PLATFORM_LIBPATH'])
|
|
if sys.platform == 'darwin':
|
|
env.Append (LINKFLAGS='-framework')
|
|
env.Append (LINKFLAGS='Carbon')
|
|
env.Append (LINKFLAGS='-framework')
|
|
env.Append (LINKFLAGS='AGL')
|
|
env.Append (LINKFLAGS='-framework')
|
|
env.Append (LINKFLAGS='AudioUnit')
|
|
env.Append (LINKFLAGS='-framework')
|
|
env.Append (LINKFLAGS='AudioToolbox')
|
|
env.Append (LINKFLAGS='-framework')
|
|
env.Append (LINKFLAGS='CoreAudio')
|
|
if user_options_dict['USE_QUICKTIME'] == 1:
|
|
env.Append (LINKFLAGS='-framework')
|
|
env.Append (LINKFLAGS='QuickTime')
|
|
else:
|
|
env.Append (LINKFLAGS=user_options_dict['PLATFORM_LINKFLAGS'])
|
|
env.BuildDir (root_build_dir, '.', duplicate=0)
|
|
|
|
def buildinfo(env, build_type):
|
|
"""
|
|
Generate a buildinfo object
|
|
"""
|
|
build_date = time.strftime ("%Y-%m-%d")
|
|
build_time = time.strftime ("%H:%M:%S")
|
|
obj = []
|
|
if user_options_dict['USE_BUILDINFO'] == 1:
|
|
if sys.platform=='win32':
|
|
build_info_file = open("source/creator/winbuildinfo.h", 'w')
|
|
build_info_file.write("char *build_date=\"%s\";\n"%build_date)
|
|
build_info_file.write("char *build_time=\"%s\";\n"%build_time)
|
|
build_info_file.write("char *build_platform=\"win32\";\n")
|
|
build_info_file.write("char *build_type=\"%s\";\n"%build_type)
|
|
build_info_file.close()
|
|
env.Append (CPPDEFINES = ['NAN_BUILDINFO', 'BUILD_DATE'])
|
|
else:
|
|
env.Append (CPPDEFINES = ['BUILD_TIME=\'"%s"\''%(build_time),
|
|
'BUILD_DATE=\'"%s"\''%(build_date),
|
|
'BUILD_TYPE=\'"dynamic"\'',
|
|
'NAN_BUILDINFO',
|
|
'BUILD_PLATFORM=\'"%s"\''%(sys.platform)])
|
|
obj = [env.Object (root_build_dir+'source/creator/%s_buildinfo'%build_type,
|
|
[root_build_dir+'source/creator/buildinfo.c'])]
|
|
return obj
|
|
|
|
def cleanCVS():
|
|
"""
|
|
walks the dist dir and removes all CVS dirs
|
|
"""
|
|
|
|
try:
|
|
import shutil
|
|
except:
|
|
print "no shutil available"
|
|
print "make sure you use python 2.3"
|
|
print
|
|
return 0
|
|
|
|
startdir = os.getcwd()
|
|
|
|
for root, dirs, files in os.walk("dist", topdown=False):
|
|
for name in dirs:
|
|
if name in ['CVS']:
|
|
if os.path.isdir(root + "/" + name):
|
|
shutil.rmtree(root + "/" + name)
|
|
|
|
os.chdir(startdir)
|
|
|
|
return 1
|
|
|
|
def preparedist():
|
|
"""
|
|
Prepare a directory for creating either archives or the installer
|
|
"""
|
|
|
|
try:
|
|
import shutil
|
|
except:
|
|
print "no shutil available"
|
|
print "make sure you use python 2.3"
|
|
print
|
|
return 0
|
|
|
|
startdir = os.getcwd()
|
|
|
|
if os.path.isdir("dist") == 0:
|
|
os.makedirs("dist")
|
|
else:
|
|
shutil.rmtree("dist") # make sure we don't get old cruft
|
|
os.makedirs("dist")
|
|
|
|
# first copy binaries
|
|
|
|
if sys.platform == 'win32':
|
|
shutil.copy("blender.exe", "dist/blender.exe")
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
shutil.copy("blenderplayer.exe", "dist/blenderplayer.exe")
|
|
shutil.copy("../lib/windows/python/lib/python23.dll", "dist/python23.dll")
|
|
shutil.copy("../lib/windows/sdl/lib/SDL.dll", "dist/SDL.dll")
|
|
shutil.copy("../lib/windows/gettext/lib/gnu_gettext.dll", "dist/gnu_gettext.dll")
|
|
elif sys.platform in ['linux2', 'linux-i386']:
|
|
shutil.copy("blender", "dist/blender")
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
shutil.copy("blenderplayer", "dist/blenderplayer")
|
|
else:
|
|
print "update preparedist() for your platform!"
|
|
return 0
|
|
|
|
# now copy .blender and necessary extras for it
|
|
if os.path.isdir("dist/.blender"):
|
|
shutil.rmtree("dist/.blender")
|
|
os.chdir("bin")
|
|
shutil.copytree(".blender/", "../dist/.blender")
|
|
os.chdir(startdir)
|
|
if os.path.isdir("dist/.blender/scripts"):
|
|
shutil.rmtree("dist/.blender/scripts")
|
|
if os.path.isdir("dist/.blender/bpydata"):
|
|
shutil.rmtree("dist/.blender/bpydata")
|
|
|
|
os.makedirs("dist/.blender/bpydata")
|
|
shutil.copy("release/bpydata/readme.txt", "dist/.blender/bpydata/readme.txt")
|
|
|
|
os.chdir("release")
|
|
shutil.copytree("scripts/", "../dist/.blender/scripts")
|
|
|
|
# finally copy auxiliaries (readme, license, etc.)
|
|
if sys.platform == 'win32':
|
|
shutil.copy("windows/extra/Help.url", "../dist/Help.url")
|
|
shutil.copy("text/copyright.txt", "../dist/copyright.txt")
|
|
shutil.copy("text/blender.html", "../dist/blender.html")
|
|
shutil.copy("text/GPL-license.txt", "../dist/GPL-license.txt")
|
|
shutil.copy("text/Python-license.txt", "../dist/Python-lisence.txt")
|
|
|
|
reltext = "release_" + string.join(version.split("."), '') + ".txt"
|
|
shutil.copy("text/" + reltext, "../dist/" + reltext)
|
|
|
|
os.chdir(startdir)
|
|
|
|
if cleanCVS()==0:
|
|
return 0
|
|
|
|
return 1
|
|
|
|
def finalisedist(zipname):
|
|
"""
|
|
Fetch the package created and remove temp dir
|
|
"""
|
|
|
|
try:
|
|
import shutil
|
|
except:
|
|
print "no shutil available"
|
|
print "make sure you use python 2.3"
|
|
print
|
|
return 0
|
|
|
|
shutil.copy("dist/" + zipname, zipname)
|
|
shutil.rmtree("dist")
|
|
|
|
return 1
|
|
|
|
def add2arc(arc, file):
|
|
if sys.platform == 'win32':
|
|
arc.write(file)
|
|
else:
|
|
arc.add(file)
|
|
|
|
|
|
def appit(target, source, env):
|
|
if sys.platform == 'darwin':
|
|
import shutil
|
|
import commands
|
|
import os.path
|
|
|
|
target = 'blender'
|
|
sourceinfo = "source/darwin/%s.app/Contents/Info.plist"%target
|
|
targetinfo = "%s.app/Contents/Info.plist"%target
|
|
|
|
cmd = '%s.app'%target
|
|
if os.path.isdir(cmd):
|
|
shutil.rmtree('%s.app'%target)
|
|
shutil.copytree("source/darwin/%s.app"%target, '%s.app'%target)
|
|
cmd = "cat %s | sed s/VERSION/`cat release/VERSION`/ | sed s/DATE/`date +'%%Y-%%b-%%d'`/ > %s"%(sourceinfo,targetinfo)
|
|
commands.getoutput(cmd)
|
|
cmd = 'cp %s %s.app/Contents/MacOS/%s'%(target, target, target)
|
|
commands.getoutput(cmd)
|
|
cmd = 'strip -u -r %s.app/Contents/MacOS/%s'%(target, target)
|
|
commands.getoutput(cmd)
|
|
cmd = '%s.app/Contents/Resources/'%target
|
|
shutil.copy('bin/.blender/.bfont.ttf', cmd)
|
|
shutil.copy('bin/.blender/.Blanguages', cmd)
|
|
cmd = 'cp -R bin/.blender/locale %s.app/Contents/Resources/'%target
|
|
commands.getoutput(cmd)
|
|
cmd = 'cp -R release/bpydata %s.app/Contents/Resources/'%target + \
|
|
commands.getoutput(cmd)
|
|
cmd = 'cp -R release/scripts %s.app/Contents/Resources/'%target + \
|
|
commands.getoutput(cmd)
|
|
cmd = 'cp -R release/plugins %s.app/Contents/Resources/'%target
|
|
commands.getoutput(cmd)
|
|
cmd = 'chmod +x %s.app/Contents/MacOS/%s'%(target, target)
|
|
commands.getoutput(cmd)
|
|
cmd = 'find %s.app -name CVS -prune -exec rm -rf {} \;'%target
|
|
commands.getoutput(cmd)
|
|
cmd = 'find %s.app -name .DS_Store -exec rm -rf {} \;'%target
|
|
commands.getoutput(cmd)
|
|
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
target = 'blenderplayer'
|
|
sourceinfo = "source/darwin/%s.app/Contents/Info.plist"%target
|
|
targetinfo = "%s.app/Contents/Info.plist"%target
|
|
|
|
cmd = '%s.app'%target
|
|
if os.path.isdir(cmd):
|
|
shutil.rmtree('%s.app'%target)
|
|
shutil.copytree("source/darwin/%s.app"%target, '%s.app'%target)
|
|
cmd = "cat %s | sed s/VERSION/`cat release/VERSION`/ | sed s/DATE/`date +'%%Y-%%b-%%d'`/ > %s"%(sourceinfo,targetinfo)
|
|
commands.getoutput(cmd)
|
|
cmd = 'cp %s %s.app/Contents/MacOS/%s'%(target, target, target)
|
|
commands.getoutput(cmd)
|
|
if user_options_dict['BUILD_BINARY'] == 'debug':
|
|
print "building debug"
|
|
else :
|
|
cmd = 'strip -u -r %s.app/Contents/MacOS/%s'%(target, target)
|
|
commands.getoutput(cmd)
|
|
cmd = '%s.app/Contents/Resources/'%target
|
|
shutil.copy('bin/.blender/.bfont.ttf', cmd)
|
|
shutil.copy('bin/.blender/.Blanguages', cmd)
|
|
cmd = 'cp -R bin/.blender/locale %s.app/Contents/Resources/'%target
|
|
commands.getoutput(cmd)
|
|
cmd = 'cp -R release/bpydata %s.app/Contents/Resources/'%target + \
|
|
commands.getoutput(cmd)
|
|
cmd = 'cp -R release/scripts %s.app/Contents/Resources/'%target + \
|
|
commands.getoutput(cmd)
|
|
cmd = 'cp -R release/plugins %s.app/Contents/Resources/'%target
|
|
commands.getoutput(cmd)
|
|
cmd = 'chmod +x %s.app/Contents/MacOS/%s'%(target, target)
|
|
commands.getoutput(cmd)
|
|
cmd = 'find %s.app -name CVS -prune -exec rm -rf {} \;'%target
|
|
commands.getoutput(cmd)
|
|
cmd = 'find %s.app -name .DS_Store -exec rm -rf {} \;'%target
|
|
commands.getoutput(cmd)
|
|
|
|
else:
|
|
print "This target is for the Os X platform only"
|
|
|
|
def zipit(env, target, source):
|
|
try:
|
|
if sys.platform == 'win32':
|
|
import zipfile
|
|
else:
|
|
import tarfile
|
|
except:
|
|
if sys.platform == 'win32':
|
|
print "no zipfile module found"
|
|
else:
|
|
print "no tarfile module found"
|
|
print "make sure you use python 2.3"
|
|
print
|
|
return
|
|
|
|
import glob
|
|
import time
|
|
|
|
startdir = os.getcwd()
|
|
pf=""
|
|
zipext = ""
|
|
zipname = ""
|
|
|
|
today = time.strftime("%Y%m%d", time.gmtime()) # get time in the form 20040714
|
|
|
|
if preparedist()==0:
|
|
print "check output for error"
|
|
return
|
|
|
|
os.chdir(startdir + "/dist")
|
|
|
|
if sys.platform == 'win32':
|
|
zipext += ".zip"
|
|
pf = "windows"
|
|
elif sys.platform == 'linux2' or sys.platform == 'linux-i386':
|
|
zipext += ".tar.gz"
|
|
pf = "linux"
|
|
|
|
zipname = "bf_blender_" + pf+ "_" + today + zipext
|
|
|
|
print
|
|
if sys.platform == 'win32':
|
|
print "Create the zip!"
|
|
elif sys.platform == 'linux2' or sys.platform == 'linux-i386':
|
|
print "Create the tarball!"
|
|
print
|
|
|
|
if sys.platform == 'win32':
|
|
thezip = zipfile.ZipFile(zipname, 'w', zipfile.ZIP_DEFLATED)
|
|
else:
|
|
thezip = tarfile.open(zipname, 'w:gz')
|
|
|
|
for root, dirs, files in os.walk(".", topdown=False):
|
|
for name in files:
|
|
if name in [zipname]:
|
|
print "skipping self"
|
|
else:
|
|
file = root + "/" + name
|
|
print "adding: " + file
|
|
add2arc(thezip, file)
|
|
|
|
thezip.close()
|
|
|
|
os.chdir(startdir)
|
|
|
|
if finalisedist(zipname)==0:
|
|
print "encountered an error in finalisedist"
|
|
print
|
|
return
|
|
|
|
print
|
|
print "Blender has been successfully packaged"
|
|
print "You can find the file %s in the root source directory"%zipname
|
|
print
|
|
|
|
|
|
def printadd(env, target, source):
|
|
"""
|
|
Print warning message if platform hasn't been added to zipit() yet
|
|
"""
|
|
|
|
print
|
|
print "############"
|
|
print
|
|
print "Make sure zipit() works for your platform:"
|
|
print " - binaries to copy (naming?)"
|
|
print " - possible libraries?"
|
|
print " - archive format?"
|
|
print
|
|
print "After you've corrected zipit() for your"
|
|
print "platform, be sure to add a proper elif"
|
|
print "at the end of BlenderRelease"
|
|
print
|
|
print "Blender is now ready and can be found in"
|
|
print "root of the source distribution, but it"
|
|
print "hasn't been packaged neatly. Make sure you"
|
|
print "get the right files"
|
|
print
|
|
print "/jesterKing"
|
|
print
|
|
|
|
|
|
def noaction(env, target, source):
|
|
print "Empty action"
|
|
|
|
def DoClean(dir2clean):
|
|
"""
|
|
Do a removal of the root_build_dir the fast way
|
|
"""
|
|
|
|
import shutil
|
|
print
|
|
print "start the clean"
|
|
dirs = os.listdir(dir2clean)
|
|
for dir in dirs:
|
|
if os.path.isdir(dir2clean + "/" + dir) == 1:
|
|
print "clean dir %s"%(dir2clean+"/" + dir)
|
|
shutil.rmtree(dir2clean+"/" + dir)
|
|
print "done"
|
|
|
|
def BlenderDefault(target):
|
|
"""
|
|
The default Blender build.
|
|
"""
|
|
def_env = Environment()
|
|
default = def_env.Command('nozip', 'blender$PROGSUFFIX', noaction)
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
def_env.Depends(default, 'blenderplayer$PROGSUFFIX')
|
|
def_env.Alias(".", default)
|
|
|
|
def donsis(env, target, source):
|
|
"""
|
|
Create a Windows installer with NSIS
|
|
"""
|
|
print
|
|
print "Creating the Windows installer"
|
|
print
|
|
|
|
startdir = os.getcwd()
|
|
|
|
if preparedist()==0:
|
|
print "check output for error"
|
|
return
|
|
|
|
os.chdir("release/windows/installer")
|
|
|
|
nsis = open("00.sconsblender.nsi", 'r')
|
|
nsis_cnt = str(nsis.read())
|
|
nsis.close()
|
|
|
|
# do root
|
|
rootlist = []
|
|
rootdir = os.listdir(startdir + "\\dist")
|
|
for rootitem in rootdir:
|
|
if os.path.isdir(startdir + "\\dist\\" + rootitem) == 0:
|
|
rootlist.append("File " + startdir + "\\dist\\" + rootitem)
|
|
rootstring = string.join(rootlist, "\n ")
|
|
rootstring += "\n\n"
|
|
nsis_cnt = string.replace(nsis_cnt, "[ROOTDIRCONTS]", rootstring)
|
|
|
|
# do scripts
|
|
scriptlist = []
|
|
scriptdir = os.listdir(startdir + "\\dist\\.blender\\scripts")
|
|
for scriptitem in scriptdir:
|
|
if os.path.isdir(startdir + "\\dist\\.blender\\scripts\\" + scriptitem) == 0:
|
|
scriptlist.append("File " + startdir + "\\dist\\.blender\\scripts\\" + scriptitem)
|
|
scriptstring = string.join(scriptlist, "\n ")
|
|
scriptstring += "\n\n"
|
|
nsis_cnt = string.replace(nsis_cnt, "[SCRIPTCONTS]", scriptstring)
|
|
|
|
# do dotblender
|
|
dotblendlist = []
|
|
dotblenddir = os.listdir(startdir+"\\dist\\.blender")
|
|
for dotblenditem in dotblenddir:
|
|
if os.path.isdir(startdir + "\\dist\\.blender\\" + dotblenditem) == 0:
|
|
dotblendlist.append("File " + startdir + "\\dist\\.blender\\" + dotblenditem)
|
|
dotblendstring = string.join(dotblendlist, "\n ")
|
|
dotblendstring += "\n\n"
|
|
nsis_cnt = string.replace(nsis_cnt, "[DOTBLENDERCONTS]", dotblendstring)
|
|
|
|
# do language files
|
|
langlist = []
|
|
langdir = os.listdir(startdir + "\\dist\\.blender\\locale")
|
|
for langitem in langdir:
|
|
if os.path.isdir(startdir + "\\dist\\.blender\\locale\\" + langitem) == 1:
|
|
langlist.append("File " + startdir + "\\dist\\.blender\\locale\\" + langitem + "\\LC_MESSAGES\\blender.mo")
|
|
langstring = string.join(langlist, "\n ")
|
|
langstring += "\n\n"
|
|
nsis_cnt = string.replace(nsis_cnt, "[LANGUAGECONTS]", langstring)
|
|
|
|
# var replacements
|
|
nsis_cnt = string.replace(nsis_cnt, "DISTDIR", startdir + "\\dist")
|
|
nsis_cnt = string.replace(nsis_cnt, "SHORTVER", shortversion)
|
|
nsis_cnt = string.replace(nsis_cnt, "VERSION", version)
|
|
|
|
new_nsis = open("00.blender_tmp.nsi", 'w')
|
|
new_nsis.write(nsis_cnt)
|
|
new_nsis.close()
|
|
|
|
sys.stdout = os.popen("makensis 00.blender_tmp.nsi", 'w')
|
|
|
|
os.chdir(startdir)
|
|
|
|
|
|
def BlenderNSIS(target):
|
|
"""
|
|
Entry for creating Windows installer
|
|
"""
|
|
if sys.platform == 'win32':
|
|
inst_env = Environment()
|
|
nsis_inst = inst_env.Command('nsisinstaller', 'blender$PROGSUFFIX', donsis)
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
inst_env.Depends(nsis_inst, 'blenderplayer$PROGSUFFIX')
|
|
inst_env.Alias("wininst", nsis_inst)
|
|
else:
|
|
print "This target is for the win32 platform only "
|
|
|
|
def BlenderRelease(target):
|
|
"""
|
|
Make a Release package (tarball, zip, bundle).
|
|
|
|
target = Name of package to make (string)
|
|
eg: BlenderRelease('blender')
|
|
"""
|
|
|
|
if sys.platform == 'darwin':
|
|
app_env = Environment()
|
|
Mappit = app_env.Command('appit', appname, appit)
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
app_env.Depends(Mappit, playername)
|
|
app_env.Alias("release", Mappit)
|
|
elif sys.platform in ['win32', 'linux2', 'linux-i386']:
|
|
release_env = Environment()
|
|
releaseit = release_env.Command('blenderrelease', appname, zipit)
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
release_env.Depends(releaseit, playername)
|
|
release_env.Alias("release", releaseit)
|
|
else:
|
|
release_env = Environment()
|
|
releaseit = release_env.Command('blender.tar.gz', appname, printadd)
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
release_env.Depends(releaseit, playername)
|
|
release_env.Alias("release", releaseit)
|
|
|
|
if enable_clean == 0:
|
|
|
|
|
|
if user_options_dict['BUILD_BLENDER_DYNAMIC'] == 1:
|
|
dy_blender = link_env.Copy ()
|
|
if sys.platform=='win32':
|
|
winblenderres(dy_blender)
|
|
blender_libs(dy_blender)
|
|
common_libs(dy_blender)
|
|
international_libs(dy_blender)
|
|
ketsji_libs(dy_blender)
|
|
system_libs(dy_blender)
|
|
dy_blender.Append (LIBS=user_options_dict['OPENGL_LIBRARY'])
|
|
dy_blender.Append (LIBPATH=user_options_dict['OPENGL_LIBPATH'])
|
|
dy_blender.Append (CPPPATH=user_options_dict['OPENGL_INCLUDE'])
|
|
d_obj = buildinfo(dy_blender, "dynamic")
|
|
if sys.platform == 'win32':
|
|
dy_blender.Program (target='blender',
|
|
source=d_obj + ['source/icons/winblender.res'])
|
|
else:
|
|
if sys.platform == 'cygwin':
|
|
dy_blender.Replace (CC='g++')
|
|
dy_blender.Program (target='blender', source=d_obj)
|
|
|
|
if user_options_dict['BUILD_BLENDER_STATIC'] == 1:
|
|
st_blender = link_env.Copy ()
|
|
if sys.platform=='win32':
|
|
winblenderres(st_blender)
|
|
blender_libs(st_blender)
|
|
common_libs(st_blender)
|
|
international_libs(st_blender)
|
|
ketsji_libs(st_blender)
|
|
system_libs(st_blender)
|
|
# The next line is to make sure that the LINKFLAGS are appended at the end
|
|
# of the link command. This 'trick' is needed because the GL and GLU static
|
|
# libraries need to be at the end of the command.
|
|
st_blender.Replace(LINKCOM="$LINK -o $TARGET $SOURCES $_LIBDIRFLAGS $_LIBFLAGS $LINKFLAGS")
|
|
s_obj = buildinfo(st_blender, "static")
|
|
st_blender.Append (LINKFLAGS=user_options_dict['OPENGL_STATIC'])
|
|
st_blender.Append (CPPPATH=user_options_dict['OPENGL_INCLUDE'])
|
|
st_blender.Prepend (LIBPATH=['/usr/lib/opengl/xfree/lib'])
|
|
st_blender.Program (target='blenderstatic', source=s_obj)
|
|
|
|
if sys.platform=='win32':
|
|
if user_options_dict['BUILD_BINARY']=='debug':
|
|
browser = Environment()
|
|
browser_tmp = root_build_dir+'bscmake.tmp'
|
|
browser.Command ('blender.bsc', 'blender$PROGSUFFIX',
|
|
['dir /b/s '+root_build_dir+'*.sbr >'+browser_tmp,
|
|
'bscmake /nologo /n /oblender.bsc @'+browser_tmp,
|
|
'del '+browser_tmp])
|
|
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1 and user_options_dict['BUILD_GAMEENGINE'] == 1:
|
|
player_blender = link_env.Copy()
|
|
player_libs(player_blender)
|
|
common_libs(player_blender)
|
|
international_libs(player_blender)
|
|
ketsji_libs(player_blender)
|
|
player_libs2(player_blender)
|
|
system_libs(player_blender)
|
|
player_blender.Append (LIBS=user_options_dict['OPENGL_LIBRARY'])
|
|
player_blender.Append (LIBPATH=user_options_dict['OPENGL_LIBPATH'])
|
|
player_blender.Append (CPPPATH=user_options_dict['OPENGL_INCLUDE'])
|
|
d_obj = buildinfo(player_blender, "player")
|
|
if sys.platform == 'win32':
|
|
player_blender.Program (target='blenderplayer',
|
|
source=d_obj + ['source/icons/winblender.res'])
|
|
else:
|
|
if sys.platform == 'cygwin':
|
|
player_blender.Replace (CC='g++')
|
|
player_blender.Program (target='blenderplayer', source=d_obj)
|
|
if sys.platform=='win32':
|
|
if user_options_dict['BUILD_BINARY']=='debug':
|
|
browser = Environment()
|
|
browser_tmp = root_build_dir+'bscmake.tmp'
|
|
browser.Command ('blenderplayer.bsc', 'blenderplayer$PROGSUFFIX',
|
|
['dir /b/s '+root_build_dir+'*.sbr >'+browser_tmp,
|
|
'bscmake /nologo /n /oblenderplayer.bsc @'+browser_tmp,
|
|
'del '+browser_tmp])
|
|
|
|
release_target = env.Alias("release", BlenderRelease(appname))
|
|
default_target = env.Alias("default", BlenderDefault(appname))
|
|
wininst_target = env.Alias("winist", BlenderNSIS(appname))
|
|
|
|
else: # only clean target to prevent any building
|
|
clean_target = env.Alias("clean", DoClean(root_build_dir))
|
|
Default("clean")
|
|
|
|
if enable_clean == 0: # only set up dependencies when not cleaning
|
|
if sys.platform == 'darwin':
|
|
Default("release")
|
|
else:
|
|
Default("default")
|
|
|
|
if sys.platform == 'win32':
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
env.Depends(wininst_target, playername)
|
|
env.Depends(wininst_target, appname)
|
|
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
env.Depends(release_target, playername)
|
|
env.Depends(release_target, appname)
|
|
|
|
if user_options_dict['BUILD_BLENDER_PLAYER'] == 1:
|
|
env.Depends(default_target, playername)
|
|
env.Depends(default_target, appname)
|
|
|