SCons build system files added.

You'll need SCons (www.scons.org) to build.
Platforms currently working:
* Linux (me)
  - options for quicktime, openal and international disabled
  - uses the system libs and include files for building - no option to build
    with the precompiled libraries yet.
* Windows (jesterKing)
  - builds with quicktime (optional)
  - builds with openal (optional)
  - builds with international support (optional)
  - Use the DOS box to build
  - builds with precompiled libraries
* Irix (Hos)
  - Uses default Irix compiler
  - Not all optimization levels correct yet
  - options for quicktime, openal and international disabled
  - builds with precompiled libraries
* Cygwin (me)
  - has a problem in the linking stage
  - uses free build tools (gcc)
  - options for quicktime, openal and international disabled
  - uses the system libs and include files for building - no option to build
    with the precompiled libraries yet.
* MacOS (sgefant)
  - builds with quicktime (optional)
  - options for openal and international disabled
  - builds a nice bundle
  - builds with precompiled libraries

Thanks to IanWill for a bugfix in the Linux build.
Note: This is a work in progress. A lot still has to be done - for example the
      optional parts are only to be enabled by directly setting 'true' or
      'false' in the SConstruct file. This needs to be moved to a user config
      file. Also, the .o/.obj files are stored in the source tree. This needs
      to be fixed as well.
      The game engine is not yet built.
This commit is contained in:
Michel Selten 2004-01-04 21:11:59 +00:00
parent 2572db0bf0
commit d3e1fc8870
36 changed files with 1423 additions and 0 deletions

338
SConstruct Normal file

@ -0,0 +1,338 @@
import string
import os
import sys
from distutils import sysconfig
# Setting up default environment variables for all platforms
sdl_cenv = Environment ()
sdl_lenv = Environment ()
link_env = Environment ()
if sys.platform == 'linux2':
use_international = 'false'
use_gameengine = 'false'
use_openal = 'false'
use_fmod = 'false'
use_quicktime = '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', 'z', 'GL', 'GLU', 'png', 'jpeg', 'util']
platform_libpath = []
platform_linkflags = []
extra_includes = []
# SDL specific stuff.
sdl_cenv.ParseConfig ('sdl-config --cflags')
sdl_lenv.ParseConfig ('sdl-config --libs')
sdl_cdict = sdl_cenv.Dictionary()
sdl_ldict = sdl_lenv.Dictionary()
sdl_cflags = string.join(sdl_cdict['CCFLAGS'])
sdl_include = sdl_cdict['CPPPATH'][0]
link_env.Append (LIBS=sdl_ldict['LIBS'])
link_env.Append (LIBPATH=sdl_ldict['LIBPATH'])
# Python variables.
python_include = sysconfig.get_python_inc ()
python_libpath = sysconfig.get_python_lib (0, 1) + '/config'
python_lib = 'python%d.%d' % sys.version_info[0:2]
elif sys.platform == 'darwin':
use_international = 'false'
use_gameengine = 'false'
use_openal = 'false'
use_fmod = 'false'
use_quicktime = 'true'
# TODO: replace darwin-6.8-powerpc with the actual directiory on the
# build machine
darwin_precomp = '#../lib/darwin-6.8-powerpc'
extra_flags = ['-pipe', '-fPIC', '-funsigned-char']
cxxflags = []
defines = ['_THREAD_SAFE']
warn_flags = ['-Wall', '-W']
release_flags = []
debug_flags = ['-g']
window_system = 'CARBON'
# SDL specific stuff.
sdl_cdict = sdl_cenv.Dictionary()
sdl_ldict = sdl_lenv.Dictionary()
sdl_cflags = string.join(sdl_cdict['CCFLAGS'])
sdl_include = darwin_precomp + '/sdl/include'
link_env.Append (LIBS=['libSDL.a'])
link_env.Append (LIBPATH=[darwin_precomp + '/sdl/lib'])
platform_libs = ['z', 'GL', 'GLU', 'png', 'jpeg', 'stdc++']
extra_includes = ['/sw/include']
platform_libpath = ['/System/Library/Frameworks/OpenGL.framework/Libraries']
platform_linkflags = []
# 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 ()
elif sys.platform == 'cygwin':
use_international = 'false'
use_gameengine = 'false'
use_openal = 'false'
use_fmod = 'false'
use_quicktime = 'false'
release_flags = ['-O2']
debug_flags = ['-O2', '-g']
extra_flags = ['-pipe', '-mno-cygwin', '-mwindows', '-funsigned-char']
defines = ['FREE_WINDOWS', 'NDEBUG']
cxxflags = []
warn_flags = ['-Wall', '-Wno-char-subscripts']
platform_libs = ['png', 'jpeg', 'netapi32',
'opengl32', 'glu32', 'winmm',
'mingw32', 'z']
platform_libpath = ['/usr/lib/w32api', '/lib/w32api']
platform_linkflags = ['-mwindows', '-mno-cygwin', '-mconsole']
window_system = 'WIN32'
extra_includes = ['/usr/include']
# SDL specific stuff.
sdl_cenv.ParseConfig ('sdl-config --cflags')
sdl_lenv.ParseConfig ('sdl-config --libs')
sdl_cdict = sdl_cenv.Dictionary()
sdl_ldict = sdl_lenv.Dictionary()
sdl_cflags = '-DWIN32'
sdl_include = sdl_cdict['CPPPATH'][0]
link_env.Append (LIBS=sdl_ldict['LIBS'])
link_env.Append (LIBPATH=sdl_ldict['LIBPATH'])
# We need to force the Cygwin environment to use the g++ linker.
link_env.Replace (CC='g++')
# Python variables.
python_include = sysconfig.get_python_inc ()
python_libpath = sysconfig.get_python_lib (0, 1) + '/config'
python_lib = 'python%d.%d' % sys.version_info[0:2]
elif sys.platform == 'win32':
use_international = 'true'
use_gameengine = 'false'
use_openal = 'true'
use_fmod = 'false'
use_quicktime = 'true'
release_flags = ['/G6', '/GF']
debug_flags = []
extra_flags = ['/EHsc', '/J', '/W3', '/Gd', '/MT']
cxxflags = []
defines = ['WIN32', 'NDEBUG', '_CONSOLE', 'FTGL_STATIC_LIBRARY']
defines += ['GAME_BLENDER=0', 'INTERNATIONAL', 'WITH_QUICKTIME']
warn_flags = []
platform_libs = ['SDL', 'freetype2ST', 'ftgl_static_ST', 'gnu_gettext',
'qtmlClient', 'odelib', 'openal_static', 'soundsystem',
'ws2_32', 'dxguid', 'opengl32', 'libjpeg', 'glu32',
'vfw32', 'winmm', 'libpng_st', 'libz_st', 'solid',
'qhull', 'iconv', 'kernel32', 'user32', 'gdi32',
'winspool', 'comdlg32', 'advapi32', 'shell32',
'ole32', 'oleaut32', 'uuid', 'odbc32', 'odbccp32',
'libcmt', 'libc']
platform_libpath = ['#../lib/windows/ftgl/lib',
'#../lib/windows/freetype/lib',
'#../lib/windows/gettext/lib',
'#../lib/windows/iconv/lib',
'#../lib/windows/jpeg/lib',
'#../lib/windows/QTDevWin/Libraries',
'#../lib/windows/ode/lib',
'#../lib/windows/openal/lib',
'#../lib/windows/png/lib',
'#../lib/windows/zlib/lib',
'#../lib/windows/solid/lib',
'#../lib/windows/qhull/lib',
'#../lib/windows/sdl/lib']
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 = ['#../lib/windows/zlib/include',
'#../lib/windows/jpeg/include',
'#../lib/windows/png/include']
if use_international == 'true':
extra_includes += ['#../lib/windows/ftgl/include',
'#../lib/windows/freetype/include',
'#../lib/windows/gettext/include']
if use_quicktime == 'true':
extra_includes += ['#../lib/windows/QTDevWin/CIncludes']
if use_openal == 'true':
extra_includes += ['#../lib/windows/openal/include']
sdl_include = '#../lib/windows/sdl/include'
sdl_cflags = ''
window_system = 'WIN32'
# Python lib name
python_libpath = '#../lib/windows/python/include'
python_libpath = '#../lib/windows/python/lib'
python_lib = 'python22'
elif string.find (sys.platform, 'sunos') != -1:
window_system = 'X11'
elif string.find (sys.platform, 'irix') != -1:
use_international = 'false'
use_gameengine = 'false'
use_openal = 'false'
use_fmod = 'false'
use_quicktime = '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']
sdl_cflags = ''
sdl_include = irix_precomp + '/sdl/include/SDL'
link_env.Append (LIBS=['libSDL.a'])
link_env.Append (LIBPATH=[irix_precomp + '/sdl/lib'])
python_libpath = irix_precomp + '/python/lib/python2.2/config'
python_include = irix_precomp + '/python/include/python2.2'
python_lib = 'python2.2'
platform_libs = ['SDL', 'movieGL', 'GLU', 'GL', 'Xmu', 'Xext', 'X11',
'c', 'm', 'dmedia', 'cl', 'audio',
'Cio', 'png', 'jpeg', 'z', 'pthread']
platform_libpath = [irix_precomp + '/png/lib',
irix_precomp + '/jpeg/lib',
'/usr/lib32', '/lib/freeware/lib32']
platform_linkflags = ['-mips3']
extra_includes = [irix_precomp + '/jpeg/include',
irix_precomp + '/png/include',
'/usr/freeware/include',
'/usr/include']
elif string.find (sys.platform, 'hp-ux') != -1:
window_system = 'X11'
else:
print "Unknown platform"
#-----------------------------------------------------------------------------
# End of platform specific section
#-----------------------------------------------------------------------------
cflags = extra_flags + release_flags + warn_flags
Export ('use_international')
Export ('use_gameengine')
Export ('use_openal')
Export ('use_fmod')
Export ('use_quicktime')
Export ('python_include')
Export ('cflags')
Export ('defines')
Export ('cxxflags')
Export ('window_system')
Export ('sdl_cflags')
Export ('sdl_include')
Export ('extra_includes')
Export ('platform_libs')
Export ('platform_libpath')
Export ('platform_linkflags')
SConscript(['intern/SConscript',
'source/SConscript'])
libpath = (['lib'])
libraries = (['blender_render',
'blender_blendersrc',
'blender_renderconverter',
'blender_blenloader',
'blender_writestreamglue',
'blender_deflate',
'blender_writeblenfile',
'blender_readblenfile',
'blender_readstreamglue',
'blender_inflate',
'blender_img',
'blender_radiosity',
'blender_blenkernel',
'blender_blenpluginapi',
'blender_imbuf',
'blender_avi',
'blender_blenlib',
'blender_python',
'blender_makesdna',
'blender_kernel',
'blender_BSP',
'blender_LOD',
'blender_GHOST',
'blender_STR',
'blender_guardedalloc',
'blender_BMF',
'blender_CTR',
'blender_MEM',
'blender_IK',
'blender_MT',
'soundsystem'])
link_env.Append (LIBS=libraries)
link_env.Append (LIBPATH=libpath)
if use_international == 'true':
link_env.Append (LIBS=['blender_FTF'])
if use_quicktime == 'true':
link_env.Append (LIBS=['blender_quicktime'])
link_env.Append (LIBS=python_lib)
link_env.Append (LIBPATH=python_libpath)
link_env.Append (LIBS=platform_libs)
link_env.Append (LIBPATH=platform_libpath)
if sys.platform == 'darwin':
link_env.Append (LINKFLAGS=' -framework Carbon')
link_env.Append (LINKFLAGS=' -framework AGL')
if use_quicktime == 'true':
link_env.Append (LINKFLAGS=' -framework QuickTime')
else:
link_env.Append (LINKFLAGS=platform_linkflags)
source_files = ['source/creator/buildinfo.c',
'source/creator/creator.c']
include_paths = ['#/intern/guardedalloc',
'#/source/blender/makesdna',
'#/source/blender/blenkernel',
'#/source/blender/blenloader',
'#/source/blender/python',
'#/source/blender/blenlib',
'#/source/blender/renderconverter',
'#/source/blender/render/extern/include',
'#/source/kernel/gen_messaging',
'#/source/kernel/gen_system',
'#/source/blender/include',
'#/source/blender/imbuf']
link_env.Append (CPPPATH=include_paths)
link_env.Program (target='blender', source=source_files, CCFLAGS=cflags)
if sys.platform == 'darwin':
bundle = Environment ()
blender_app = 'blender'
bundle.Depends ('#/blender.app/Contents/MacOS/' + blender_app, blender_app)
bundle.Command ('dummy1', '#/blender.app', 'rm -rf $SOURCE')
bundle.Command ('dummy2', '#/source/darwin/blender.app', 'cp -R $SOURCE .')
bundle.Command ('#/blender.app/Contents/Info.plist',
'#/source/darwin/blender.app/Contents/Info.plist',
"cat $SOURCE | sed s/VERSION/`cat release/VERSION`/ | \
sed s/DATE/`date +'%Y-%b-%d'`/ \
> $TARGET")
bundle.Command ('dummy3', blender_app,
'cp $SOURCE blender.app/Contents/MacOS')
bundle.Command ('dummy4', '#/blender.app/Contents/MacOS/' + blender_app,
'chmod +x $SOURCE')
bundle.Command ('dummy5', 'blender.app',
'find $SOURCE -name CVS -prune -exec rm -rf {} \;')
bundle.Command ('dummy6', 'blender.app',
'find $SOURCE -name .DS_Store -exec rm -rf {} \;')

11
intern/SConscript Normal file

@ -0,0 +1,11 @@
SConscript(['SoundSystem/SConscript',
'string/SConscript',
'ghost/SConscript',
'guardedalloc/SConscript',
'bmfont/SConscript',
'moto/SConscript',
'container/SConscript',
'memutil/SConscript/',
'decimation/SConscript',
'bsp/SConscript',
'iksolver/SConscript'])

@ -0,0 +1,52 @@
# TODO: Add the options for building with fmod and/or OpenAL
import sys
soundsys_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('use_openal')
Import ('use_fmod')
Import ('extra_includes')
soundsys_env.Append (CCFLAGS = cflags)
soundsys_env.Append (CXXFLAGS = cxxflags)
soundsys_env.Append (CPPDEFINES = defines)
source_files = ['dummy/SND_DummyDevice.cpp',
'intern/SND_AudioDevice.cpp',
'intern/SND_C-api.cpp',
'intern/SND_CDObject.cpp',
'intern/SND_DeviceManager.cpp',
'intern/SND_IdObject.cpp',
'intern/SND_Scene.cpp',
'intern/SND_SoundListener.cpp',
'intern/SND_SoundObject.cpp',
'intern/SND_Utils.cpp',
'intern/SND_WaveCache.cpp',
'intern/SND_WaveSlot.cpp']
soundsys_env.Append (CPPPATH = ['.',
'intern',
'../moto/include',
'../string',
'dummy',
'openal'])
if use_openal == 'true':
source_files += ['openal/SND_OpenALDevice.cpp',
'openal/pthread_cancel.cpp']
if sys.platform=='win32':
cflags += ' /D_LIB'
if use_fmod == 'true':
source_files += ['fmod/SND_FmodDevice.cpp']
if use_openal == 'false' and use_fmod == 'false':
soundsys_env.Append (CPPDEFINES = 'NO_SOUND')
soundsys_env.Append (CPPPATH = extra_includes)
soundsys_env.Library (target='#/lib/soundsystem', source=source_files)

26
intern/bmfont/SConscript Normal file

@ -0,0 +1,26 @@
bmfont_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
bmfont_env.Append (CCFLAGS = cflags)
bmfont_env.Append (CXXFLAGS = cxxflags)
bmfont_env.Append (CPPDEFINES = defines)
source_files = ['intern/BMF_Api.cpp',
'intern/BMF_BitmapFont.cpp',
'intern/BMF_font_helv10.cpp',
'intern/BMF_font_helv12.cpp',
'intern/BMF_font_helvb10.cpp',
'intern/BMF_font_helvb12.cpp',
'intern/BMF_font_helvb14.cpp',
'intern/BMF_font_helvb8.cpp',
'intern/BMF_font_scr12.cpp',
'intern/BMF_font_scr14.cpp',
'intern/BMF_font_scr15.cpp']
bmfont_env.Append (CPPPATH = ['.',
'intern'])
bmfont_env.Library (target='#/lib/blender_BMF', source=source_files)

29
intern/bsp/SConscript Normal file

@ -0,0 +1,29 @@
bsp_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
bsp_env.Append (CCFLAGS = cflags)
bsp_env.Append (CXXFLAGS = cxxflags)
bsp_env.Append (CPPDEFINES = defines)
source_files = ['intern/BSP_CSGHelper.cpp',
'intern/BSP_CSGMesh.cpp',
'intern/BSP_CSGMeshBuilder.cpp',
'intern/BSP_CSGMeshSplitter.cpp',
'intern/BSP_CSGNCMeshSplitter.cpp',
'intern/BSP_CSGUserData.cpp',
'intern/BSP_FragNode.cpp',
'intern/BSP_FragTree.cpp',
'intern/BSP_MeshFragment.cpp',
'intern/BSP_MeshPrimitives.cpp',
'intern/BSP_Triangulate.cpp',
'intern/CSG_BooleanOps.cpp']
bsp_env.Append (CPPPATH = ['intern',
'../container',
'../moto/include',
'../memutil'])
bsp_env.Library (target='#/lib/blender_BSP', source=source_files)

@ -0,0 +1,15 @@
cont_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
cont_env.Append (CCFLAGS = cflags)
cont_env.Append (CXXFLAGS = cxxflags)
cont_env.Append (CPPDEFINES = defines)
source_files = ['intern/CTR_List.cpp']
cont_env.Append (CPPPATH = ['.'])
cont_env.Library (target='#/lib/blender_CTR', source=source_files)

@ -0,0 +1,26 @@
dec_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
dec_env.Append (CCFLAGS = cflags)
dec_env.Append (CXXFLAGS = cxxflags)
dec_env.Append (CPPDEFINES = defines)
source_files = ['intern/LOD_EdgeCollapser.cpp',
'intern/LOD_ExternNormalEditor.cpp',
'intern/LOD_FaceNormalEditor.cpp',
'intern/LOD_ManMesh2.cpp',
'intern/LOD_MeshPrimitives.cpp',
'intern/LOD_QSDecimator.cpp',
'intern/LOD_QuadricEditor.cpp',
'intern/LOD_decimation.cpp']
dec_env.Append (CPPPATH = ['intern',
'extern',
'../moto/include',
'../container',
'../memutil'])
dec_env.Library (target='#/lib/blender_LOD', source=source_files)

45
intern/ghost/SConscript Normal file

@ -0,0 +1,45 @@
ghost_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
ghost_env.Append (CCFLAGS = cflags)
ghost_env.Append (CXXFLAGS = cxxflags)
ghost_env.Append (CPPDEFINES = defines)
Import ('window_system')
source_files = ['intern/GHOST_Buttons.cpp',
'intern/GHOST_C-api.cpp',
'intern/GHOST_CallbackEventConsumer.cpp',
'intern/GHOST_DisplayManager.cpp',
'intern/GHOST_EventManager.cpp',
'intern/GHOST_EventPrinter.cpp',
'intern/GHOST_ISystem.cpp',
'intern/GHOST_ModifierKeys.cpp',
'intern/GHOST_Rect.cpp',
'intern/GHOST_System.cpp',
'intern/GHOST_TimerManager.cpp',
'intern/GHOST_Window.cpp',
'intern/GHOST_WindowManager.cpp']
if window_system == 'X11':
source_files += ['intern/GHOST_DisplayManagerX11.cpp',
'intern/GHOST_SystemX11.cpp',
'intern/GHOST_WindowX11.cpp']
elif window_system == 'WIN32':
source_files += ['intern/GHOST_DisplayManagerWin32.cpp',
'intern/GHOST_SystemWin32.cpp',
'intern/GHOST_WindowWin32.cpp']
elif window_system == 'CARBON':
source_files += ['intern/GHOST_DisplayManagerCarbon.cpp',
'intern/GHOST_SystemCarbon.cpp',
'intern/GHOST_WindowCarbon.cpp']
else:
print "Unknown window system specified."
ghost_env.Append (CPPPATH = ['.',
'../string'])
ghost_env.Library (target='#/lib/blender_GHOST', source=source_files)

@ -0,0 +1,15 @@
guardal_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
guardal_env.Append (CCFLAGS = cflags)
guardal_env.Append (CXXFLAGS = cxxflags)
guardal_env.Append (CPPDEFINES = defines)
source_files = ['intern/mallocn.c']
guardal_env.Append (CPPPATH = ['.'])
guardal_env.Library (target='#/lib/blender_guardedalloc', source=source_files)

@ -0,0 +1,21 @@
iksolver_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
iksolver_env.Append (CCFLAGS = cflags)
iksolver_env.Append (CXXFLAGS = cxxflags)
iksolver_env.Append (CPPDEFINES = defines)
source_files = ['intern/IK_QChain.cpp',
'intern/IK_QJacobianSolver.cpp',
'intern/IK_QSegment.cpp',
'intern/IK_Solver.cpp',
'intern/MT_ExpMap.cpp']
iksolver_env.Append (CPPPATH = ['intern',
'../moto/include',
'../memutil'])
iksolver_env.Library (target='#/lib/blender_IK', source=source_files)

15
intern/memutil/SConscript Normal file

@ -0,0 +1,15 @@
memutil_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
memutil_env.Append (CCFLAGS = cflags)
memutil_env.Append (CXXFLAGS = cxxflags)
memutil_env.Append (CPPDEFINES = defines)
source_files = ['intern/MEM_RefCountedC-Api.cpp']
memutil_env.Append (CPPPATH = ['.'])
memutil_env.Library (target='#/lib/blender_MEM', source=source_files)

25
intern/moto/SConscript Normal file

@ -0,0 +1,25 @@
moto_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
moto_env.Append (CCFLAGS = cflags)
moto_env.Append (CXXFLAGS = cxxflags)
moto_env.Append (CPPDEFINES = defines)
source_files = ['intern/MT_CmMatrix4x4.cpp',
'intern/MT_Matrix3x3.cpp',
'intern/MT_Matrix4x4.cpp',
'intern/MT_Plane3.cpp',
'intern/MT_Point3.cpp',
'intern/MT_Quaternion.cpp',
'intern/MT_Transform.cpp',
'intern/MT_Vector2.cpp',
'intern/MT_Vector3.cpp',
'intern/MT_Vector4.cpp',
'intern/MT_random.cpp']
moto_env.Append (CPPPATH = ['include'])
moto_env.Library (target='#/lib/blender_MT', source=source_files)

15
intern/string/SConscript Normal file

@ -0,0 +1,15 @@
string_env = Environment ()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
string_env.Append (CCFLAGS = cflags)
string_env.Append (CXXFLAGS = cxxflags)
string_env.Append (CPPDEFINES = defines)
source_files = ['intern/STR_String.cpp']
string_env.Append (CPPPATH = ['.'])
string_env.Library (target='#/lib/blender_STR', source=source_files)

2
source/SConscript Normal file

@ -0,0 +1,2 @@
SConscript(['blender/SConscript',
'kernel/SConscript'])

28
source/blender/SConscript Normal file

@ -0,0 +1,28 @@
Import ('use_quicktime')
Import ('use_international')
SConscript(['blenloader/SConscript',
'deflate/SConscript',
'inflate/SConscript',
'writestreamglue/SConscript',
'readstreamglue/SConscript',
'writeblenfile/SConscript',
'readblenfile/SConscript',
'avi/SConscript',
'imbuf/SConscript',
'img/SConscript',
'render/SConscript',
'radiosity/SConscript',
'blenlib/SConscript',
'blenkernel/SConscript',
'blenpluginapi/SConscript',
'python/SConscript',
'makesdna/SConscript',
'src/SConscript',
'renderconverter/SConscript'])
if use_international == 'true':
SConscript (['ftfont/SConscript'])
if use_quicktime == 'true':
SConscript (['quicktime/SConscript'])

@ -0,0 +1,24 @@
avi_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('extra_includes')
avi_env.Append (CCFLAGS = cflags)
avi_env.Append (CXXFLAGS = cxxflags)
avi_env.Append (CPPDEFINES = defines)
source_files = ['intern/avi.c',
'intern/avirgb.c',
'intern/codecs.c',
'intern/endian.c',
'intern/mjpeg.c',
'intern/options.c',
'intern/rgb32.c']
avi_env.Append (CPPPATH = ['.',
'#/intern/guardedalloc'])
avi_env.Append (CPPPATH=extra_includes)
avi_env.Library (target='#/lib/blender_avi', source=source_files)

@ -0,0 +1,60 @@
blenkernel_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
blenkernel_env.Append (CCFLAGS = cflags)
blenkernel_env.Append (CXXFLAGS = cxxflags)
blenkernel_env.Append (CPPDEFINES = defines)
source_files = ['intern/constraint.c',
'intern/group.c',
'intern/material.c',
'intern/sca.c',
'intern/world.c',
'intern/curve.c',
'intern/ika.c',
'intern/mball.c',
'intern/scene.c',
'intern/writeavi.c',
'intern/action.c',
'intern/deform.c',
'intern/image.c',
'intern/mesh.c',
'intern/screen.c',
'intern/anim.c',
'intern/displist.c',
'intern/ipo.c',
'intern/nla.c',
'intern/sound.c',
'intern/armature.c',
'intern/effect.c',
'intern/key.c',
'intern/object.c',
'intern/subsurf.c',
'intern/blender.c',
'intern/exotic.c',
'intern/lattice.c',
'intern/packedFile.c',
'intern/text.c',
'intern/script.c',
'intern/bmfont.c',
'intern/font.c',
'intern/library.c',
'intern/property.c',
'intern/texture.c']
blenkernel_env.Append (CPPPATH = ['.',
'#/intern/guardedalloc',
'../include',
'../blenlib',
'../makesdna',
'../python',
'../render/extern/include',
'../imbuf',
'../avi',
'#/intern/iksolver/extern',
'../blenloader'])
blenkernel_env.Library (target='#/lib/blender_blenkernel', source=source_files)

@ -0,0 +1,41 @@
blenlib_env = Environment ()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('extra_includes')
blenlib_env.Append (CCFLAGS = cflags)
blenlib_env.Append (CXXFLAGS = cxxflags)
blenlib_env.Append (CPPDEFINES = defines)
source_files = ['intern/BLI_dynstr.c',
'intern/BLI_ghash.c',
'intern/BLI_linklist.c',
'intern/BLI_memarena.c',
'intern/arithb.c',
'intern/dynlib.c',
'intern/fileops.c',
'intern/gsqueue.c',
'intern/matrixops.c',
'intern/noise.c',
'intern/psfont.c',
'intern/rand.c',
'intern/rct.c',
'intern/scanfill.c',
'intern/storage.c',
'intern/time.c',
'intern/util.c',
'intern/vectorops.c',
'intern/freetypefont.c',
'intern/winstuff.c']
blenlib_env.Append (CPPPATH = ['.',
'../makesdna',
'../blenkernel',
'#/intern/guardedalloc',
'../include'])
blenlib_env.Append (CPPPATH = extra_includes)
blenlib_env.Library (target='#/lib/blender_blenlib', source=source_files)

@ -0,0 +1,29 @@
blenloader_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
blenloader_env.Append (CCFLAGS = cflags)
blenloader_env.Append (CXXFLAGS = cxxflags)
blenloader_env.Append (CPPDEFINES = defines)
source_files = ['intern/genfile.c',
'intern/readblenentry.c',
'intern/readfile.c',
'intern/writefile.c']
blenloader_env.Append (CPPPATH = ['.',
'#/intern/guardedalloc',
'../blenlib',
'../blenkernel',
'../makesdna',
'../readblenfile',
'../include',
'../python',
'../../kernel/gen_messaging',
'../render/extern/include',
'../writestreamglue',
'../readstreamglue'])
blenloader_env.Library (target='#/lib/blender_blenloader', source=source_files)

@ -0,0 +1,20 @@
blenplugin_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
blenplugin_env.Append (CCFLAGS = cflags)
blenplugin_env.Append (CXXFLAGS = cxxflags)
blenplugin_env.Append (CPPDEFINES = defines)
source_files = ['intern/pluginapi.c']
blenplugin_env.Append (CPPPATH = ['.',
'..',
'#/intern/guardedalloc',
'../blenlib',
'../imbuf',
'../makesdna'])
blenplugin_env.Library (target='#/lib/blender_blenpluginapi', source=source_files)

@ -0,0 +1,21 @@
deflate_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('extra_includes')
deflate_env.Append (CCFLAGS = cflags)
deflate_env.Append (CXXFLAGS = cxxflags)
deflate_env.Append (CPPDEFINES = defines)
source_files = ['intern/BLO_deflate.c']
deflate_env.Append (CPPPATH = ['.',
'../../kernel/gen_messaging',
'../writestreamglue',
'../readstreamglue',
'../inflate'])
deflate_env.Append (CPPPATH=extra_includes)
deflate_env.Library (target='#/lib/blender_deflate', source=source_files)

@ -0,0 +1,49 @@
imbuf_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('extra_includes')
imbuf_env.Append (CCFLAGS = cflags)
imbuf_env.Append (CXXFLAGS = cxxflags)
imbuf_env.Append (CPPDEFINES = defines)
source_files = ['intern/allocimbuf.c',
'intern/amiga.c',
'intern/anim.c',
'intern/anim5.c',
'intern/antialias.c',
'intern/bitplanes.c',
'intern/bmp_decode.c',
'intern/cmap.c',
'intern/cspace.c',
'intern/data.c',
'intern/dither.c',
'intern/divers.c',
'intern/filter.c',
'intern/ham.c',
'intern/hamx.c',
'intern/iff.c',
'intern/imageprocess.c',
'intern/iris.c',
'intern/jpeg.c',
'intern/png.c',
'intern/readimage.c',
'intern/rectop.c',
'intern/rotate.c',
'intern/scaling.c',
'intern/targa.c',
'intern/util.c',
'intern/writeimage.c']
imbuf_env.Append (CPPPATH = ['.',
'../makesdna',
'#/intern/guardedalloc',
'../blenlib',
'../avi',
'../quicktime',
'../blenkernel'])
imbuf_env.Append (CPPPATH = extra_includes)
imbuf_env.Library (target='#/lib/blender_imbuf', source=source_files)

@ -0,0 +1,19 @@
img_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
img_env.Append (CCFLAGS = cflags)
img_env.Append (CXXFLAGS = cxxflags)
img_env.Append (CPPDEFINES = defines)
source_files = ['intern/IMG_Api.cpp',
'intern/IMG_BrushRGBA32.cpp',
'intern/IMG_CanvasRGBA32.cpp',
'intern/IMG_Line.cpp',
'intern/IMG_Pixmap.cpp',
'intern/IMG_PixmapRGBA32.cpp',
'intern/IMG_Rect.cpp']
img_env.Library (target='#/lib/blender_img', source=source_files)

@ -0,0 +1,20 @@
inflate_env = Environment ()
# TODO: add the option to build with Quicktime
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('extra_includes')
inflate_env.Append (CCFLAGS = cflags)
inflate_env.Append (CXXFLAGS = cxxflags)
inflate_env.Append (CPPDEFINES = defines)
source_files = ['intern/BLO_inflate.c']
inflate_env.Append (CPPPATH = ['.',
'../../kernel/gen_messaging',
'../readstreamglue'])
inflate_env.Append (CPPPATH = extra_includes)
inflate_env.Library (target='#/lib/blender_inflate', source=source_files)

@ -0,0 +1,18 @@
makesdna_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
makesdna_env.Append (CCFLAGS = cflags)
makesdna_env.Append (CXXFLAGS = cxxflags)
makesdna_env.Append (CPPDEFINES = defines)
objs = []
o = SConscript('intern/SConscript')
objs.append (o)
makesdna_env.Append (CPPPATH = ['#/intern/guardedalloc'])
makesdna_env.Library (target='#/lib/blender_makesdna', source=objs)

@ -0,0 +1,47 @@
import sys
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('platform_libs')
Import ('platform_libpath')
Import ('platform_linkflags')
if sys.platform=='win32':
platform_linkflags = ['/SUBSYSTEM:CONSOLE',
'/MACHINE:I386',
'/ENTRY:mainCRTStartup',
'/NODEFAULTLIB:"msvcprt.lib"',
'/NODEFAULTLIB:"glut32.lib"',
'/NODEFAULTLIB:"libcd.lib"',
#'/NODEFAULTLIB:"libc.lib"',
'/NODEFAULTLIB:"libcpd.lib"',
'/NODEFAULTLIB:"libcp.lib"',
'/NODEFAULTLIB:"libcmtd.lib"'
]
# TODO: make sure the makesdna program does not get installed on the system.
source_files = ['makesdna.c']
include_paths = ['#/intern/guardedalloc',
'..']
makesdna_tool = Environment (CCFLAGS='-DBASE_HEADER="\\"source/blender/makesdna/\\"" ')
makesdna_tool.Append (CCFLAGS=cflags)
makesdna_tool.Append (LIBS=platform_libs)
makesdna_tool.Append (LIBPATH=platform_libpath)
makesdna_tool.Append (LINKFLAGS=platform_linkflags)
makesdna_tool.Append (CPPPATH=include_paths)
makesdna_tool.Append (LIBPATH='#/lib')
makesdna_tool.Append (LIBS='blender_guardedalloc')
makesdna_tool.Program (target='makesdna', source=source_files)
dna = Environment ()
dna_dict = dna.Dictionary()
makesdna_name = 'makesdna' + dna_dict['PROGSUFFIX']
dna.Depends ('dna.c', makesdna_name)
if sys.platform=='win32':
dna.Command ('dna.c', '', "source\\blender\\makesdna\\intern\\makesdna $TARGET")
else:
dna.Command ('dna.c', '', "source/blender/makesdna/intern/makesdna $TARGET")
obj = Object ('dna.c')
Return ('obj')

@ -0,0 +1,62 @@
python_env = Environment ()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('python_include')
Import ('extra_includes')
python_env.Append (CCFLAGS = cflags)
python_env.Append (CXXFLAGS = cxxflags)
python_env.Append (CPPDEFINES = defines)
source_files = ['BPY_interface.c',
'api2_2x/Blender.c',
'api2_2x/Sys.c',
'api2_2x/Registry.c',
'api2_2x/Scene.c',
'api2_2x/Types.c',
'api2_2x/Object.c',
'api2_2x/NMesh.c',
'api2_2x/Material.c',
'api2_2x/Camera.c',
'api2_2x/World.c',
'api2_2x/Lamp.c',
'api2_2x/Lattice.c',
'api2_2x/Curve.c',
'api2_2x/Armature.c',
'api2_2x/Bone.c',
'api2_2x/Ipo.c',
'api2_2x/Ipocurve.c',
'api2_2x/BezTriple.c',
'api2_2x/Metaball.c',
'api2_2x/Effect.c',
'api2_2x/Particle.c',
'api2_2x/Wave.c',
'api2_2x/Build.c',
'api2_2x/Image.c',
'api2_2x/Window.c',
'api2_2x/Draw.c',
'api2_2x/BGL.c',
'api2_2x/Text.c',
'api2_2x/Texture.c',
'api2_2x/MTex.c',
'api2_2x/vector.c',
'api2_2x/constant.c',
'api2_2x/matrix.c',
'api2_2x/rgbTuple.c',
'api2_2x/gen_utils.c',
'api2_2x/EXPP_interface.c']
python_env.Append (CPPPATH = ['api2_2x',
'../blenkernel',
'../blenlib',
'../makesdna',
'#/intern/guardedalloc',
'#/intern/bmfont',
'../imbuf',
'../include',
python_include])
python_env.Append (CPPPATH = extra_includes)
python_env.Library (target='#/lib/blender_python', source=source_files)

@ -0,0 +1,27 @@
rad_env = Environment ()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
rad_env.Append (CCFLAGS = cflags)
rad_env.Append (CXXFLAGS = cxxflags)
rad_env.Append (CPPDEFINES = defines)
source_files = ['intern/source/raddisplay.c',
'intern/source/radfactors.c',
'intern/source/radrender.c',
'intern/source/radio.c',
'intern/source/radnode.c',
'intern/source/radpostprocess.c',
'intern/source/radpreprocess.c']
rad_env.Append (CPPPATH = ['extern/include',
'../blenlib',
'../blenkernel',
'../makesdna',
'../include',
'#/intern/guardedalloc',
'../render/extern/include'])
rad_env.Library (target='#/lib/blender_radiosity', source=source_files)

@ -0,0 +1,19 @@
readblenfile_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
readblenfile_env.Append (CCFLAGS = cflags)
readblenfile_env.Append (CXXFLAGS = cxxflags)
readblenfile_env.Append (CPPDEFINES = defines)
source_files = ['intern/BLO_readblenfile.c']
readblenfile_env.Append (CPPPATH = ['.',
'../readstreamglue',
'../blenloader',
'../blenkernel',
'../../kernel/gen_messaging'])
readblenfile_env.Library (target='#/lib/blender_readblenfile', source=source_files)

@ -0,0 +1,21 @@
readstrgl_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('extra_includes')
readstrgl_env.Append (CCFLAGS = cflags)
readstrgl_env.Append (CXXFLAGS = cxxflags)
readstrgl_env.Append (CPPDEFINES = defines)
source_files = ['intern/BLO_readStreamGlue.c',
'intern/BLO_readStreamGlueLoopBack.c']
readstrgl_env.Append (CPPPATH = ['.',
'../../kernel/gen_messaging',
'../blenloader',
'../inflate'])
readstrgl_env.Append (CPPPATH = extra_includes)
readstrgl_env.Library (target='#/lib/blender_readstreamglue', source=source_files)

@ -0,0 +1,45 @@
render_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
render_env.Append (CCFLAGS = cflags)
render_env.Append (CXXFLAGS = cxxflags)
render_env.Append (CPPDEFINES = defines)
source_files = ['intern/source/RE_callbacks.c',
'intern/source/edgeRender.c',
'intern/source/envmap.c',
'intern/source/errorHandler.c',
'intern/source/gammaCorrectionTables.c',
'intern/source/initrender.c',
'intern/source/jitter.c',
'intern/source/outerRenderLoop.c',
'intern/source/pixelblending.c',
'intern/source/pixelshading.c',
'intern/source/ray.c',
'intern/source/renderHelp.c',
'intern/source/renderPreAndPost.c',
'intern/source/rendercore.c',
'intern/source/renderdatabase.c',
'intern/source/shadbuf.c',
'intern/source/texture.c',
'intern/source/vanillaRenderPipe.c',
'intern/source/zbuf.c',
'intern/source/zbufferdatastruct.c']
render_env.Append (CPPPATH = ['intern/include',
'#/intern/guardedalloc',
'../blenlib',
'../makesdna',
'extern/include',
'../blenkernel',
'../radiosity/extern/include',
'../imbuf',
'../quicktime',
'../include',
'../../kernel/gen_messaging'])
render_env.Library (target='#/lib/blender_render', source=source_files)

@ -0,0 +1,22 @@
renderconv_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
renderconv_env.Append (CCFLAGS = cflags)
renderconv_env.Append (CXXFLAGS = cxxflags)
renderconv_env.Append (CPPDEFINES = defines)
source_files = ['intern/convertBlenderScene.c']
renderconv_env.Append (CPPPATH = ['.',
'../blenlib',
'#/intern/guardedalloc',
'../makesdna',
'../blenkernel',
'../include',
'../render/extern/include',
'../python'])
renderconv_env.Library (target='#/lib/blender_renderconverter', source=source_files)

@ -0,0 +1,148 @@
src_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('python_include')
Import ('sdl_cflags')
Import ('sdl_include')
Import ('extra_includes')
Import ('use_international')
src_env.Append (CCFLAGS = cflags)
src_env.Append (CCFLAGS = sdl_cflags)
src_env.Append (CXXFLAGS = cxxflags)
src_env.Append (CPPDEFINES = defines)
source_files = ['B.blend.c',
'Bfont.c',
'blenderbuttons.c',
'booleanops.c',
'booleanops_mesh.c',
'buttons_editing.c',
'buttons_logic.c',
'buttons_object.c',
'buttons_scene.c',
'buttons_script.c',
'buttons_shading.c',
'butspace.c',
'cmap.tga.c',
'cmovie.tga.c',
'cursors.c',
'drawaction.c',
'drawimage.c',
'drawimasel.c',
'drawipo.c',
'drawmesh.c',
'drawnla.c',
'drawobject.c',
'drawoops.c',
'drawscene.c',
'drawscript.c',
'drawseq.c',
'drawsound.c',
'drawtext.c',
'drawview.c',
'edit.c',
'editaction.c',
'editarmature.c',
'editconstraint.c',
'editcurve.c',
'editdeform.c',
'editface.c',
'editfont.c',
'editgroup.c',
'editika.c',
'editimasel.c',
'editipo.c',
'editkey.c',
'editlattice.c',
'editmball.c',
'editmesh.c',
'editnla.c',
'editobject.c',
'editoops.c',
'editscreen.c',
'editseq.c',
'editsima.c',
'editsound.c',
'editview.c',
'eventdebug.c',
'filesel.c',
'ghostwinlay.c',
'glutil.c',
'headerbuttons.c',
'header_action.c',
'header_buttonswin.c',
'header_filesel.c',
'header_image.c',
'header_imasel.c',
'header_info.c',
'header_ipo.c',
'header_nla.c',
'header_oops.c',
'header_script.c',
'header_seq.c',
'header_sound.c',
'header_text.c',
'header_view3d.c',
'imasel.c',
'interface.c',
'interface_panel.c',
'interface_draw.c',
'keyval.c',
'mainqueue.c',
'mywindow.c',
'oops.c',
'splash.jpg.c',
'playanim.c',
'poseobject.c',
'previewrender.c',
'renderwin.c',
'resources.c',
'scrarea.c',
'screendump.c',
'sequence.c',
'seqaudio.c',
'space.c',
'spacetypes.c',
'swapbuffers.c',
'toets.c',
'toolbox.c',
'usiblender.c',
'view.c',
'vpaint.c',
'writeavicodec.c',
'writeimage.c',
'writemovie.c',
'language.c']
src_env.Append (CPPPATH = ['#/intern/guardedalloc',
'../blenlib',
'../makesdna',
'../blenkernel',
'../include',
'#/intern/bmfont',
'../imbuf',
'../render/extern/include',
'#/intern/bsp/extern',
'../renderconverter',
'../radiosity/extern/include',
'#/intern/decimation/extern',
'../blenloader',
'../python',
'../../kernel/gen_system',
'#/intern/SoundSystem',
'../readstreamglue',
'../img',
'../quicktime',
'#/intern/ghost',
python_include,
sdl_include])
if use_international=='true':
src_env.Append (CPPPATH=['../ftfont'])
src_env.Append (CPPPATH=extra_includes)
src_env.Library (target='#/lib/blender_blendersrc', source=source_files)

@ -0,0 +1,22 @@
wrblenfile_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('extra_includes')
wrblenfile_env.Append (CCFLAGS = cflags)
wrblenfile_env.Append (CXXFLAGS = cxxflags)
wrblenfile_env.Append (CPPDEFINES = defines)
source_files = ['intern/BLO_writeblenfile.c']
wrblenfile_env.Append (CPPPATH = ['.',
'../../kernel/gen_messaging',
'../blenloader',
'../writestreamglue',
'../readstreamglue',
'../readblenfile'])
wrblenfile_env.Append (CPPPATH = extra_includes)
wrblenfile_env.Library (target='#/lib/blender_writeblenfile', source=source_files)

@ -0,0 +1,24 @@
wrstrgl_env = Environment()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
Import ('extra_includes')
wrstrgl_env.Append (CCFLAGS = cflags)
wrstrgl_env.Append (CXXFLAGS = cxxflags)
wrstrgl_env.Append (CPPDEFINES = defines)
source_files = ['intern/BLO_dumpFromMemory.c',
'intern/BLO_getPubKey.c',
'intern/BLO_streamGlueControl.c',
'intern/BLO_writeStreamGlue.c']
wrstrgl_env.Append (CPPPATH = ['.',
'../readstreamglue',
'../deflate',
'../writeblenfile',
'../../kernel/gen_messaging'])
wrstrgl_env.Append (CPPPATH = extra_includes)
wrstrgl_env.Library (target='#/lib/blender_writestreamglue', source=source_files)

22
source/kernel/SConscript Normal file

@ -0,0 +1,22 @@
kernel_env = Environment ()
# Import the C flags set in the SConstruct file
Import ('cflags')
Import ('cxxflags')
Import ('defines')
kernel_env.Append (CCFLAGS = cflags)
kernel_env.Append (CXXFLAGS = cxxflags)
kernel_env.Append (CPPDEFINES = defines)
source_files = ['gen_messaging/intern/messaging.c',
'gen_system/GEN_HashedPtr.cpp',
'gen_system/GEN_Matrix4x4.cpp',
'gen_system/SYS_SingletonSystem.cpp',
'gen_system/SYS_System.cpp']
kernel_env.Append (CPPPATH = ['gen_messaging',
'gen_system',
'#/intern/string',
'#/intern/moto/include'])
kernel_env.Library (target='#/lib/blender_kernel', source=source_files)