root/branches/Carsten_PtrWork2/Tutorials/SConstruct

#!python
# 
# Base scons build file
#

# Import everything under the sun
import sys
import os
pj = os.path.join


import SCons.Environment     # Get the environment crap
#import SCons

# Extend paths for scons-addons and scons-build if needed
# - this allows a development version of scons-addons to be
#   in the standard python path and used instead.
try:
   import SConsAddons.Util
   print "Using SConsAddons from: ", os.path.dirname(SConsAddons.Util.__file__)
except:
   sys.path.insert(0,pj('../Tools','scons-addons','src'))
   print "Using SConsAddons from: ../Tools/scons-addons/src"

import SConsAddons.Options as sca_opts   # Get the modular options stuff
import SConsAddons.Options.OpenSG2
import SConsAddons.Options.Boost
from SConsAddons.EnvironmentBuilder import EnvironmentBuilder
import SConsAddons.Util as sca_util      # Get the utils

# Setup base scons options and settings
EnsureSConsVersion(0,96)
SetOption('max_drift',30)           # 30 second drift on MD5 Files
SetOption('implicit_cache',1)
SConsignFile('.sconsign.'+sca_util.GetPlatform())    # Store all .sconsign stuff in single file

GetPlatform = sca_util.GetPlatform

################################
# Create builder
################################

if GetPlatform() == "win32":
   opt_env = Environment()
   # If you want to explicitly set the version MSVS version to use.
   #opt_env = Environment(MSVS_VERSION='7.1')
else:
   opt_env = Environment(ENV = os.environ)

# Default variants
default_types    = ['optimized', 'debug']
if GetPlatform() == 'win32':
   default_types.append("hybrid")

# ---------- Options ------------ #
# This section sets up all option objects that need to be tested
# and then used later.
options_cache_filename = 'options.cache'
opts = sca_opts.Options(files = [options_cache_filename, 'options.custom'], args=ARGUMENTS)

opts.AddOption(sca_opts.SeparatorOption("\nBuild Variants"))
opts.Add(sca_opts.EnumOption('type','Types of run-times to build.(comma separated list)',
                             default_types[0], default_types))

# OpenSG options.
opensg2_options = SConsAddons.Options.OpenSG2.OpenSG2("opensg", "2.0", required=True)
opensg2_options.verbose = True
boost_options = sca_opts.Boost.Boost("boost", "1.31.0", libs = [],
                                     required = True , useVersion = True, useDebug=True, autoLink=True)


opts.AddOption(sca_opts.SeparatorOption("\nPackage Options"))
opts.AddOption(opensg2_options)
opts.AddOption(boost_options)

help_text = """---- Tutorials Build ---- 

%s

This file will be loaded each time.  Note: Options are cached in the file: %s
""" %(opts.GenerateHelpText(opt_env),options_cache_filename)
Help(help_text)

# ----- Project Setup ------------ #
# setup all modules and apps that need to be
# built as part of this project
if not sca_util.hasHelpFlag():
   opts.Process(opt_env)
   opts.Save(options_cache_filename, opt_env)

   # Debug option settings
   if 1:
      print "---- OpenSG settings ----"
      opensg2_options.dumpSettings()
      print "---- Boost settings ----"
      boost_options.dumpSettings()

   # Create a variant.
   combo = {'type':opt_env['type'], 'archs':'32'}

   # -- Setup Environment builder --- #
   env_bldr = EnvironmentBuilder()
   env_bldr.enableWarnings(EnvironmentBuilder.MINIMAL)

   # Process modifications for variant combo
   if combo["type"] == "debug":
      env_bldr.enableDebug()
      env_bldr.setMsvcRuntime(EnvironmentBuilder.MSVC_MT_DBG_DLL_RT)
   elif combo["type"] == "optimized":
      env_bldr.enableOpt(EnvironmentBuilder.STANDARD)
      env_bldr.setMsvcRuntime(EnvironmentBuilder.MSVC_MT_DLL_RT)
   elif combo["type"] == "hybrid":
      env_bldr.enableDebug()
      env_bldr.setMsvcRuntime(EnvironmentBuilder.MSVC_MT_DLL_RT)
   
   base_env = env_bldr.applyToEnvironment(opt_env.Copy(), variant=combo)

   if GetPlatform() == "win32":
      base_env.Append(CPPDEFINES = ['BOOST_ALL_DYN_LINK',])
      base_env.Append(CPPFLAGS = ["/wd4996",])

      if combo["type"] == "hybrid":
         base_env.Append(CPPDEFINES = ['_USE_RELEASE_RUNTIME',])
         base_env.Append(LINKFLAGS = ['/NODEFAULTLIB:msvcprtd',])
         base_env.Append(LINKFLAGS = ['/NODEFAULTLIB:msvcrtd',])
         base_env.Append(LIBS = ['msvcprt',])
         #base_env.Append(LIBS = ['msvcrt',])

   # Suffix to add to the end of apps to install
   runtime_suffix = ""
   if combo["type"] == "debug":
      runtime_suffix = "_d"
   elif combo["type"] == "hybrid":
      runtime_suffix = "_h"

   # Add OpenSG libs.
   libs=['State', 'System', 'Window', 'FileIO', 'Text', 'WIN32', 'GLUT',
         'Group', 'Util', 'ImageFileIO', 'Base', 'RenderTraversal',
         'Drawable', 'Cluster' ]
   opensg2_options.apply(base_env, libs=libs)
   boost_options.apply(base_env, useDebug=('debug' == combo['type']))

   build_app = True

   if not opensg2_options.isAvailable():
      print "OpenSG not available: Skipping viewer."
      build_app = False
   if not boost_options.isAvailable():
      print "Boost not available: Skipping viewer."
      build_app = False

   if build_app:
      # Get all the source files from the local directory tree
      files = os.listdir('.')
      tutorials = [f for f in files if f.endswith('.cpp')]

      for file in tutorials:
         name = file.split('.')[0]
         local_env = base_env.Copy()
         mylibs = local_env['LIBS']
         for l in open(file).readlines():
            if l.startswith("// Libs:"):
                mylibs += ["OSG"+m for m in l[8:].split()]

         # Build the test program and install into tree
         loader = local_env.Program(name+runtime_suffix, file, LIBS = mylibs)

Default(".")