Sneed-Group/Poodletooth-iLand
1
0
Fork 0
mirror of https://github.com/Sneed-Group/Poodletooth-iLand synced 2024-12-24 20:22:33 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions
Poodletooth-iLand/build/nirai/panda3d/makepanda/makepanda.py
ToontownStride 23139d101d Official files
2015-11-14 14:28:53 -05:00

7009 lines
313 KiB
Python
Raw Blame History

#!/usr/bin/env python
########################################################################
#
# Caution: there are two separate, independent build systems:
# 'makepanda', and 'ppremake'. Use one or the other, do not attempt
# to use both. This file is part of the 'makepanda' system.
#
# To build panda using this script, type 'makepanda.py' on unix
# or 'makepanda.bat' on windows, and examine the help-text.
# Then run the script again with the appropriate options to compile
# panda3d.
#
########################################################################
try:
import sys, os, platform, time, stat, re, getopt, threading, signal, shutil
if sys.platform == "darwin" or sys.version_info >= (2, 6):
import plistlib
if sys.version_info >= (3, 0):
import queue
else:
import Queue as queue
except:
print("You are either using an incomplete or an old version of Python!")
print("Please install the development package of Python 2.x and try again.")
exit(1)
from makepandacore import *
from installpanda import *
import time
import os
import sys
########################################################################
##
## PARSING THE COMMAND LINE OPTIONS
##
## You might be tempted to change the defaults by editing them
## here. Don't do it. Instead, create a script that compiles
## panda with your preferred options. Or, create
## a 'makepandaPreferences' file and put it into your python path.
##
########################################################################
COMPILER=0
INSTALLER=0
GENMAN=0
COMPRESSOR="zlib"
THREADCOUNT=0
CFLAGS=""
CXXFLAGS=""
LDFLAGS=""
RTDIST=0
RTDIST_VERSION="dev"
RUNTIME=0
DISTRIBUTOR=""
VERSION=None
DEBVERSION=None
RPMRELEASE="1"
GIT_COMMIT=None
P3DSUFFIX=None
MAJOR_VERSION=None
COREAPI_VERSION=None
PLUGIN_VERSION=None
OSXTARGET=None
OSX_ARCHS=[]
HOST_URL=None
global STRDXSDKVERSION, STRMSPLATFORMVERSION, BOOUSEINTELCOMPILER
STRDXSDKVERSION = 'default'
STRMSPLATFORMVERSION = 'default'
BOOUSEINTELCOMPILER = False
OPENCV_VER_23 = False
if "MACOSX_DEPLOYMENT_TARGET" in os.environ:
OSXTARGET=os.environ["MACOSX_DEPLOYMENT_TARGET"]
PkgListSet(["PYTHON", "DIRECT", # Python support
"GL", "GLES", "GLES2"] + DXVERSIONS + ["TINYDISPLAY", "NVIDIACG", # 3D graphics
"EGL", # OpenGL (ES) integration
"EIGEN", # Linear algebra acceleration
"OPENAL", "FMODEX", # Audio playback
"VORBIS", "FFMPEG", "SWSCALE", "SWRESAMPLE", # Audio decoding
"ODE", "PHYSX", "BULLET", "PANDAPHYSICS", # Physics
"SPEEDTREE", # SpeedTree
"ZLIB", "PNG", "JPEG", "TIFF", "SQUISH", "FREETYPE", # 2D Formats support
] + MAYAVERSIONS + MAXVERSIONS + [ "FCOLLADA", "ASSIMP", # 3D Formats support
"VRPN", "OPENSSL", # Transport
"FFTW", # Algorithm helpers
"ARTOOLKIT", "OPENCV", "DIRECTCAM", "VISION", # Augmented Reality
"GTK2", # GTK2 is used for PStats on Unix
"MFC", "WX", "FLTK", # Used for web plug-in only
"ROCKET", "AWESOMIUM", # GUI libraries
"CARBON", "COCOA", # Mac OS X toolkits
"X11", "XF86DGA", "XRANDR", "XCURSOR", # Unix platform support
"PANDATOOL", "PVIEW", "DEPLOYTOOLS", # Toolchain
"SKEL", # Example SKEL project
"PANDAFX", # Some distortion special lenses
"PANDAPARTICLESYSTEM", # Built in particle system
"CONTRIB", # Experimental
"SSE2", "NEON", # Compiler features
"TOUCHINPUT", # Touchinput interface (requires Windows 7)
])
CheckPandaSourceTree()
def keyboardInterruptHandler(x,y):
exit("keyboard interrupt")
signal.signal(signal.SIGINT, keyboardInterruptHandler)
########################################################################
##
## Command-line parser.
##
## You can type "makepanda --help" to see all the options.
##
########################################################################
def usage(problem):
if (problem):
print("")
print("Error parsing command-line input: %s" % (problem))
print("")
print("Makepanda generates a 'built' subdirectory containing a")
print("compiled copy of Panda3D. Command-line arguments are:")
print("")
print(" --help (print the help message you're reading now)")
print(" --verbose (print out more information)")
print(" --runtime (build a runtime build instead of an SDK build)")
print(" --installer (build an installer)")
print(" --optimize X (optimization level can be 1,2,3,4)")
print(" --version X (set the panda version number)")
print(" --lzma (use lzma compression when building Windows installer)")
print(" --distributor X (short string identifying the distributor of the build)")
print(" --outputdir X (use the specified directory instead of 'built')")
print(" --host URL (set the host url (runtime build only))")
print(" --threads N (use the multithreaded build system. see manual)")
print(" --osxtarget N (the OS X version number to build for (OS X only))")
print(" --universal (build universal binaries (OS X only))")
print(" --override \"O=V\" (override dtool_config/prc option value)")
print(" --static (builds libraries for static linking)")
print(" --target X (experimental cross-compilation (android only))")
print(" --arch X (target architecture for cross-compilation)")
print("")
for pkg in PkgListGet():
p = pkg.lower()
print(" --use-%-9s --no-%-9s (enable/disable use of %s)"%(p, p, pkg))
if sys.platform != 'win32':
print(" --<PKG>-incdir (custom location for header files of thirdparty package)")
print(" --<PKG>-libdir (custom location for library files of thirdparty package)")
print("")
print(" --nothing (disable every third-party lib)")
print(" --everything (enable every third-party lib)")
print(" --directx-sdk=X (specify version of DirectX SDK to use: jun2010, aug2009, mar2009, aug2006)")
print(" --platform-sdk=X (specify MSPlatSdk to use: win71, win61, win60A, winserver2003r2)")
print(" --use-icl (experimental setting to use an intel compiler instead of MSVC on Windows)")
print("")
print("The simplest way to compile panda is to just type:")
print("")
print(" makepanda --everything")
print("")
os._exit(1)
def parseopts(args):
global INSTALLER,RTDIST,RUNTIME,GENMAN,DISTRIBUTOR,VERSION
global COMPRESSOR,THREADCOUNT,OSXTARGET,OSX_ARCHS,HOST_URL
global DEBVERSION,RPMRELEASE,GIT_COMMIT,P3DSUFFIX
global STRDXSDKVERSION, STRMSPLATFORMVERSION, BOOUSEINTELCOMPILER
longopts = [
"help","distributor=","verbose","runtime","osxtarget=",
"optimize=","everything","nothing","installer","rtdist","nocolor",
"version=","lzma","no-python","threads=","outputdir=","override=",
"static","host=","debversion=","rpmrelease=","p3dsuffix=",
"directx-sdk=", "platform-sdk=", "use-icl",
"universal", "target=", "arch=", "git-commit="]
anything = 0
optimize = ""
target = None
target_arch = None
universal = False
for pkg in PkgListGet():
longopts.append("use-" + pkg.lower())
longopts.append("no-" + pkg.lower())
longopts.append(pkg.lower() + "-incdir=")
longopts.append(pkg.lower() + "-libdir=")
try:
opts, extras = getopt.getopt(args, "", longopts)
for option, value in opts:
if (option=="--help"): raise Exception
elif (option=="--optimize"): optimize=value
elif (option=="--installer"): INSTALLER=1
elif (option=="--verbose"): SetVerbose(True)
elif (option=="--distributor"): DISTRIBUTOR=value
elif (option=="--rtdist"): RTDIST=1
elif (option=="--runtime"): RUNTIME=1
elif (option=="--genman"): GENMAN=1
elif (option=="--everything"): PkgEnableAll()
elif (option=="--nothing"): PkgDisableAll()
elif (option=="--threads"): THREADCOUNT=int(value)
elif (option=="--outputdir"): SetOutputDir(value.strip())
elif (option=="--osxtarget"): OSXTARGET=value.strip()
elif (option=="--universal"): universal = True
elif (option=="--target"): target = value.strip()
elif (option=="--arch"): target_arch = value.strip()
elif (option=="--nocolor"): DisableColors()
elif (option=="--version"):
VERSION=value
if (len(VERSION.split(".")) != 3): raise Exception
elif (option=="--lzma"): COMPRESSOR="lzma"
elif (option=="--override"): AddOverride(value.strip())
elif (option=="--static"): SetLinkAllStatic(True)
elif (option=="--host"): HOST_URL=value
elif (option=="--debversion"): DEBVERSION=value
elif (option=="--rpmrelease"): RPMRELEASE=value
elif (option=="--git-commit"): GIT_COMMIT=value
elif (option=="--p3dsuffix"): P3DSUFFIX=value
# Backward compatibility, OPENGL was renamed to GL
elif (option=="--use-opengl"): PkgEnable("GL")
elif (option=="--no-opengl"): PkgDisable("GL")
elif (option=="--directx-sdk"):
STRDXSDKVERSION = value.strip().lower()
if STRDXSDKVERSION == '':
print("No DirectX SDK version specified. Using 'default' DirectX SDK search")
STRDXSDKVERSION = 'default'
elif (option=="--platform-sdk"):
STRMSPLATFORMVERSION = value.strip().lower()
if STRMSPLATFORMVERSION == '':
print("No MS Platform SDK version specified. Using 'default' MS Platform SDK search")
STRMSPLATFORMVERSION = 'default'
elif (option=="--use-icl"): BOOUSEINTELCOMPILER = True
else:
for pkg in PkgListGet():
if option == "--use-" + pkg.lower():
PkgEnable(pkg)
break
elif option == "--no-" + pkg.lower():
PkgDisable(pkg)
break
elif option == "--" + pkg.lower() + "-incdir":
PkgSetCustomLocation(pkg)
IncDirectory(pkg, value)
break
elif option == "--" + pkg.lower() + "-libdir":
PkgSetCustomLocation(pkg)
LibDirectory(pkg, value)
break
if (option == "--everything" or option.startswith("--use-")
or option == "--nothing" or option.startswith("--no-")):
anything = 1
except:
usage(sys.exc_info()[1])
if not anything:
if RUNTIME:
PkgEnableAll()
else:
usage("You should specify a list of packages to use or --everything to enable all packages.")
if (RTDIST and RUNTIME):
usage("Options --runtime and --rtdist cannot be specified at the same time!")
if (optimize=="" and (RTDIST or RUNTIME)): optimize = "4"
elif (optimize==""): optimize = "3"
if OSXTARGET:
try:
maj, min = OSXTARGET.strip().split('.')
OSXTARGET = int(maj), int(min)
assert OSXTARGET[0] == 10
except:
usage("Invalid setting for OSXTARGET")
else:
OSXTARGET = None
if target is not None or target_arch is not None:
SetTarget(target, target_arch)
if universal:
if target_arch:
exit("--universal is incompatible with --arch")
OSX_ARCHS.append("i386")
if OSXTARGET:
osxver = OSXTARGET
else:
maj, min = platform.mac_ver()[0].split('.')[:2]
osxver = int(maj), int(min)
if osxver[1] < 6:
OSX_ARCHS.append("ppc")
else:
OSX_ARCHS.append("x86_64")
elif HasTargetArch():
OSX_ARCHS.append(GetTargetArch())
try:
SetOptimize(int(optimize))
assert GetOptimize() in [1, 2, 3, 4]
except:
usage("Invalid setting for OPTIMIZE")
if GIT_COMMIT is not None and not re.match("^[a-f0-9]{40}$", GIT_COMMIT):
usage("Invalid SHA-1 hash given for --git-commit option!")
is_win7 = False
if GetHost() == "windows":
if (STRMSPLATFORMVERSION not in ['winserver2003r2', 'win60A']):
platsdk = GetRegistryKey("SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v7.1", "InstallationFolder")
if sys.platform == "win32":
# Note: not available in cygwin.
winver = sys.getwindowsversion()
if platsdk and os.path.isdir(platsdk) and winver[0] >= 6 and winver[1] >= 1:
is_win7 = True
if RUNTIME or not is_win7:
PkgDisable("TOUCHINPUT")
parseopts(sys.argv[1:])
########################################################################
##
## Handle environment variables.
##
########################################################################
if ("CFLAGS" in os.environ):
CFLAGS = os.environ["CFLAGS"].strip()
if ("CXXFLAGS" in os.environ):
CXXFLAGS = os.environ["CXXFLAGS"].strip()
if ("RPM_OPT_FLAGS" in os.environ):
CFLAGS += " " + os.environ["RPM_OPT_FLAGS"].strip()
CXXFLAGS += " " + os.environ["RPM_OPT_FLAGS"].strip()
if ("LDFLAGS" in os.environ):
LDFLAGS = os.environ["LDFLAGS"].strip()
os.environ["MAKEPANDA"] = os.path.abspath(sys.argv[0])
if GetHost() == "darwin" and OSXTARGET is not None:
os.environ["MACOSX_DEPLOYMENT_TARGET"] = "%d.%d" % OSXTARGET
########################################################################
##
## Configure things based on the command-line parameters.
##
########################################################################
PLUGIN_VERSION = ParsePluginVersion("dtool/PandaVersion.pp")
COREAPI_VERSION = PLUGIN_VERSION + "." + ParseCoreapiVersion("dtool/PandaVersion.pp")
if VERSION is None:
if RUNTIME:
VERSION = PLUGIN_VERSION
else:
VERSION = ParsePandaVersion("dtool/PandaVersion.pp")
print("Version: %s" % VERSION)
if RUNTIME or RTDIST:
print("Core API Version: %s" % COREAPI_VERSION)
if DEBVERSION is None:
DEBVERSION = VERSION
MAJOR_VERSION = '.'.join(VERSION.split('.')[:2])
if P3DSUFFIX is None:
P3DSUFFIX = MAJOR_VERSION
outputdir_suffix = ""
if (RUNTIME or RTDIST):
# Compiling Maya/Max is pointless in rtdist build
for ver in MAYAVERSIONS + MAXVERSIONS:
PkgDisable(ver)
if (DISTRIBUTOR.strip() == ""):
exit("You must provide a valid distributor name when making a runtime or rtdist build!")
outputdir_suffix += "_" + DISTRIBUTOR.strip()
if (RUNTIME):
outputdir_suffix += "_rt"
RTDIST_VERSION = DISTRIBUTOR.strip() + "_" + MAJOR_VERSION
elif (DISTRIBUTOR == ""):
DISTRIBUTOR = "makepanda"
if not IsCustomOutputDir():
if GetTarget() == "windows" and GetTargetArch() == 'x64':
outputdir_suffix += '_x64'
SetOutputDir("built" + outputdir_suffix)
if (RUNTIME):
for pkg in PkgListGet():
if pkg in ["GTK2", "MFC"]:
# Optional package(s) for runtime.
pass
elif pkg in ["OPENSSL", "ZLIB"]:
# Required packages for runtime.
if (PkgSkip(pkg)==1):
exit("Runtime must be compiled with OpenSSL and ZLib support!")
else:
# Unused packages for runtime.
PkgDisable(pkg)
if (GetHost() == 'windows'):
os.environ["BISON_SIMPLE"] = GetThirdpartyBase()+"/win-util/bison.simple"
if (INSTALLER and RTDIST):
exit("Cannot build an installer for the rtdist build!")
if (INSTALLER) and (PkgSkip("PYTHON")) and (not RUNTIME) and GetTarget() == 'windows':
exit("Cannot build installer on Windows without python")
if (RTDIST) and (PkgSkip("WX") and PkgSkip("FLTK")):
exit("Cannot build rtdist without wx or fltk")
if (RUNTIME):
SetLinkAllStatic(True)
if not os.path.isdir("contrib"):
PkgDisable("CONTRIB")
########################################################################
##
## Load the dependency cache.
##
########################################################################
LoadDependencyCache()
########################################################################
##
## Locate various SDKs.
##
########################################################################
MakeBuildTree()
SdkLocateDirectX(STRDXSDKVERSION)
SdkLocateMaya()
SdkLocateMax()
SdkLocateMacOSX(OSXTARGET)
SdkLocatePython(RTDIST)
SdkLocateVisualStudio()
SdkLocateMSPlatform(STRMSPLATFORMVERSION)
SdkLocatePhysX()
SdkLocateSpeedTree()
SdkLocateAndroid()
SdkAutoDisableDirectX()
SdkAutoDisableMaya()
SdkAutoDisableMax()
SdkAutoDisablePhysX()
SdkAutoDisableSpeedTree()
if (RTDIST and DISTRIBUTOR == "cmu"):
HOST_URL = "https://runtime.panda3d.org/"
if (RTDIST_VERSION == "cmu_1.7" and SDK["PYTHONVERSION"] != "python2.6"):
exit("The CMU 1.7 runtime distribution must be built against Python 2.6!")
elif (RTDIST_VERSION == "cmu_1.8" and SDK["PYTHONVERSION"] != "python2.7"):
exit("The CMU 1.8 runtime distribution must be built against Python 2.7!")
elif (RTDIST_VERSION == "cmu_1.9" and SDK["PYTHONVERSION"] != "python2.7"):
exit("The CMU 1.9 runtime distribution must be built against Python 2.7!")
elif RTDIST and not HOST_URL:
exit("You must specify a host URL when building the rtdist!")
if RUNTIME and not HOST_URL:
# Set this to a nice default.
HOST_URL = "https://runtime.panda3d.org/"
########################################################################
##
## Choose a Compiler.
##
## This should also set up any environment variables needed to make
## the compiler work.
##
########################################################################
if GetHost() == 'windows' and GetTarget() == 'windows':
COMPILER = "MSVC"
else:
COMPILER = "GCC"
SetupBuildEnvironment(COMPILER)
########################################################################
##
## External includes, external libraries, and external defsyms.
##
########################################################################
IncDirectory("ALWAYS", GetOutputDir()+"/tmp")
IncDirectory("ALWAYS", GetOutputDir()+"/include")
if (COMPILER == "MSVC"):
PkgDisable("X11")
PkgDisable("XRANDR")
PkgDisable("XF86DGA")
PkgDisable("XCURSOR")
PkgDisable("GLES")
PkgDisable("GLES2")
PkgDisable("EGL")
PkgDisable("CARBON")
PkgDisable("COCOA")
if (PkgSkip("PYTHON")==0):
IncDirectory("ALWAYS", SDK["PYTHON"] + "/include")
LibDirectory("ALWAYS", SDK["PYTHON"] + "/libs")
SmartPkgEnable("EIGEN", "eigen3", (), ("Eigen/Dense",), target_pkg = 'ALWAYS')
for pkg in PkgListGet():
if (PkgSkip(pkg)==0):
if (pkg[:4]=="MAYA"):
IncDirectory(pkg, SDK[pkg] + "/include")
DefSymbol(pkg, "MAYAVERSION", pkg)
DefSymbol(pkg, "MLIBRARY_DONTUSE_MFC_MANIFEST", "")
elif (pkg[:3]=="MAX"):
IncDirectory(pkg, SDK[pkg] + "/include")
IncDirectory(pkg, SDK[pkg] + "/include/CS")
IncDirectory(pkg, SDK[pkg+"CS"] + "/include")
IncDirectory(pkg, SDK[pkg+"CS"] + "/include/CS")
DefSymbol(pkg, "MAX", pkg)
if (int(pkg[3:]) >= 2013):
DefSymbol(pkg, "UNICODE", "")
DefSymbol(pkg, "_UNICODE", "")
elif (pkg[:2]=="DX"):
IncDirectory(pkg, SDK[pkg] + "/include")
elif GetThirdpartyDir() is not None:
IncDirectory(pkg, GetThirdpartyDir() + pkg.lower() + "/include")
for pkg in DXVERSIONS:
if (PkgSkip(pkg)==0):
vnum=pkg[2:]
if GetTargetArch() == 'x64':
LibDirectory(pkg, SDK[pkg] + '/lib/x64')
else:
LibDirectory(pkg, SDK[pkg] + '/lib/x86')
LibDirectory(pkg, SDK[pkg] + '/lib')
LibName(pkg, 'd3dVNUM.lib'.replace("VNUM", vnum))
LibName(pkg, 'd3dxVNUM.lib'.replace("VNUM", vnum))
if int(vnum) >= 9 and "GENERIC_DXERR_LIBRARY" in SDK:
LibName(pkg, 'dxerr.lib')
else:
LibName(pkg, 'dxerrVNUM.lib'.replace("VNUM", vnum))
#LibName(pkg, 'ddraw.lib')
LibName(pkg, 'dxguid.lib')
IncDirectory("ALWAYS", GetThirdpartyDir() + "extras/include")
LibName("WINSOCK", "wsock32.lib")
LibName("WINSOCK2", "wsock32.lib")
LibName("WINSOCK2", "ws2_32.lib")
LibName("WINCOMCTL", "comctl32.lib")
LibName("WINCOMDLG", "comdlg32.lib")
LibName("WINUSER", "user32.lib")
LibName("WINMM", "winmm.lib")
LibName("WINIMM", "imm32.lib")
LibName("WINKERNEL", "kernel32.lib")
LibName("WINOLE", "ole32.lib")
LibName("WINOLEAUT", "oleaut32.lib")
LibName("WINOLDNAMES", "oldnames.lib")
LibName("WINSHELL", "shell32.lib")
LibName("WINGDI", "gdi32.lib")
LibName("ADVAPI", "advapi32.lib")
LibName("IPHLPAPI", "iphlpapi.lib")
LibName("GL", "opengl32.lib")
LibName("GLES", "libgles_cm.lib")
LibName("GLES2", "libGLESv2.lib")
LibName("EGL", "libEGL.lib")
LibName("MSIMG", "msimg32.lib")
if (PkgSkip("DIRECTCAM")==0): LibName("DIRECTCAM", "strmiids.lib")
if (PkgSkip("DIRECTCAM")==0): LibName("DIRECTCAM", "quartz.lib")
if (PkgSkip("DIRECTCAM")==0): LibName("DIRECTCAM", "odbc32.lib")
if (PkgSkip("DIRECTCAM")==0): LibName("DIRECTCAM", "odbccp32.lib")
if (PkgSkip("PNG")==0): LibName("PNG", GetThirdpartyDir() + "png/lib/libpng_static.lib")
if (PkgSkip("JPEG")==0): LibName("JPEG", GetThirdpartyDir() + "jpeg/lib/jpeg-static.lib")
if (PkgSkip("TIFF")==0): LibName("TIFF", GetThirdpartyDir() + "tiff/lib/libtiff.lib")
if (PkgSkip("ZLIB")==0): LibName("ZLIB", GetThirdpartyDir() + "zlib/lib/zlibstatic.lib")
if (PkgSkip("VRPN")==0): LibName("VRPN", GetThirdpartyDir() + "vrpn/lib/vrpn.lib")
if (PkgSkip("VRPN")==0): LibName("VRPN", GetThirdpartyDir() + "vrpn/lib/quat.lib")
if (PkgSkip("NVIDIACG")==0): LibName("CGGL", GetThirdpartyDir() + "nvidiacg/lib/cgGL.lib")
if (PkgSkip("NVIDIACG")==0): LibName("CGDX9", GetThirdpartyDir() + "nvidiacg/lib/cgD3D9.lib")
if (PkgSkip("NVIDIACG")==0): LibName("NVIDIACG", GetThirdpartyDir() + "nvidiacg/lib/cg.lib")
if (PkgSkip("OPENSSL")==0): LibName("OPENSSL", GetThirdpartyDir() + "openssl/lib/libpandassl.lib")
if (PkgSkip("OPENSSL")==0): LibName("OPENSSL", GetThirdpartyDir() + "openssl/lib/libpandaeay.lib")
if (PkgSkip("FREETYPE")==0): LibName("FREETYPE", GetThirdpartyDir() + "freetype/lib/freetype.lib")
if (PkgSkip("FFTW")==0): LibName("FFTW", GetThirdpartyDir() + "fftw/lib/rfftw.lib")
if (PkgSkip("FFTW")==0): LibName("FFTW", GetThirdpartyDir() + "fftw/lib/fftw.lib")
if (PkgSkip("ARTOOLKIT")==0):LibName("ARTOOLKIT",GetThirdpartyDir() + "artoolkit/lib/libAR.lib")
if (PkgSkip("FCOLLADA")==0): LibName("FCOLLADA", GetThirdpartyDir() + "fcollada/lib/FCollada.lib")
if (PkgSkip("ASSIMP")==0): PkgDisable("ASSIMP") # Not yet supported
if (PkgSkip("OPENCV")==0): LibName("OPENCV", GetThirdpartyDir() + "opencv/lib/cv.lib")
if (PkgSkip("OPENCV")==0): LibName("OPENCV", GetThirdpartyDir() + "opencv/lib/highgui.lib")
if (PkgSkip("OPENCV")==0): LibName("OPENCV", GetThirdpartyDir() + "opencv/lib/cvaux.lib")
if (PkgSkip("OPENCV")==0): LibName("OPENCV", GetThirdpartyDir() + "opencv/lib/ml.lib")
if (PkgSkip("OPENCV")==0): LibName("OPENCV", GetThirdpartyDir() + "opencv/lib/cxcore.lib")
if (PkgSkip("AWESOMIUM")==0):LibName("AWESOMIUM",GetThirdpartyDir() + "awesomium/lib/Awesomium.lib")
if (PkgSkip("FFMPEG")==0): LibName("FFMPEG", GetThirdpartyDir() + "ffmpeg/lib/avcodec.lib")
if (PkgSkip("FFMPEG")==0): LibName("FFMPEG", GetThirdpartyDir() + "ffmpeg/lib/avformat.lib")
if (PkgSkip("FFMPEG")==0): LibName("FFMPEG", GetThirdpartyDir() + "ffmpeg/lib/avutil.lib")
if (PkgSkip("SWSCALE")==0): LibName("SWSCALE", GetThirdpartyDir() + "ffmpeg/lib/swscale.lib")
if (PkgSkip("SWRESAMPLE")==0):LibName("SWRESAMPLE",GetThirdpartyDir() + "ffmpeg/lib/swresample.lib")
if (PkgSkip("SQUISH")==0):
if GetOptimize() <= 2:
LibName("SQUISH", GetThirdpartyDir() + "squish/lib/squishd.lib")
else:
LibName("SQUISH", GetThirdpartyDir() + "squish/lib/squish.lib")
if (PkgSkip("ROCKET")==0):
LibName("ROCKET", GetThirdpartyDir() + "rocket/lib/RocketCore.lib")
LibName("ROCKET", GetThirdpartyDir() + "rocket/lib/RocketControls.lib")
if (PkgSkip("PYTHON")==0):
LibName("ROCKET", GetThirdpartyDir() + "rocket/lib/" + SDK["PYTHONVERSION"] + "/boost_python-vc100-mt-1_54.lib")
if (GetOptimize() <= 3):
LibName("ROCKET", GetThirdpartyDir() + "rocket/lib/RocketDebugger.lib")
if (PkgSkip("OPENAL")==0): LibName("OPENAL", GetThirdpartyDir() + "openal/lib/OpenAL32.lib")
if (PkgSkip("ODE")==0):
LibName("ODE", GetThirdpartyDir() + "ode/lib/ode_single.lib")
DefSymbol("ODE", "dSINGLE", "")
if (PkgSkip("FMODEX")==0):
if (GetTargetArch() == 'x64'):
LibName("FMODEX", GetThirdpartyDir() + "fmodex/lib/fmodex64_vc.lib")
else:
LibName("FMODEX", GetThirdpartyDir() + "fmodex/lib/fmodex_vc.lib")
if (PkgSkip("FLTK")==0 and RTDIST):
LibName("FLTK", GetThirdpartyDir() + "fltk/lib/fltk.lib")
if not PkgSkip("FLTK"):
# If we have fltk, we don't need wx
PkgDisable("WX")
if (PkgSkip("WX")==0 and RTDIST):
LibName("WX", GetThirdpartyDir() + "wx/lib/wxbase28u.lib")
LibName("WX", GetThirdpartyDir() + "wx/lib/wxmsw28u_core.lib")
DefSymbol("WX", "__WXMSW__", "")
DefSymbol("WX", "_UNICODE", "")
DefSymbol("WX", "UNICODE", "")
if (PkgSkip("VORBIS")==0):
LibName("VORBIS", GetThirdpartyDir() + "vorbis/lib/libogg_static.lib")
LibName("VORBIS", GetThirdpartyDir() + "vorbis/lib/libvorbis_static.lib")
LibName("VORBIS", GetThirdpartyDir() + "vorbis/lib/libvorbisfile_static.lib")
for pkg in MAYAVERSIONS:
if (PkgSkip(pkg)==0):
LibName(pkg, '"' + SDK[pkg] + '/lib/Foundation.lib"')
LibName(pkg, '"' + SDK[pkg] + '/lib/OpenMaya.lib"')
LibName(pkg, '"' + SDK[pkg] + '/lib/OpenMayaAnim.lib"')
LibName(pkg, '"' + SDK[pkg] + '/lib/OpenMayaUI.lib"')
for pkg in MAXVERSIONS:
if (PkgSkip(pkg)==0):
LibName(pkg, SDK[pkg] + '/lib/core.lib')
LibName(pkg, SDK[pkg] + '/lib/edmodel.lib')
LibName(pkg, SDK[pkg] + '/lib/gfx.lib')
LibName(pkg, SDK[pkg] + '/lib/geom.lib')
LibName(pkg, SDK[pkg] + '/lib/mesh.lib')
LibName(pkg, SDK[pkg] + '/lib/maxutil.lib')
LibName(pkg, SDK[pkg] + '/lib/paramblk2.lib')
if (PkgSkip("PHYSX")==0):
if GetTargetArch() == 'x64':
LibName("PHYSX", SDK["PHYSXLIBS"] + "/PhysXLoader64.lib")
LibName("PHYSX", SDK["PHYSXLIBS"] + "/NxCharacter64.lib")
else:
LibName("PHYSX", SDK["PHYSXLIBS"] + "/PhysXLoader.lib")
LibName("PHYSX", SDK["PHYSXLIBS"] + "/NxCharacter.lib")
IncDirectory("PHYSX", SDK["PHYSX"] + "/Physics/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/PhysXLoader/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/NxCharacter/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/NxExtensions/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/Foundation/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/Cooking/include")
if (PkgSkip("SPEEDTREE")==0):
if GetTargetArch() == 'x64':
libdir = SDK["SPEEDTREE"] + "/Lib/Windows/VC10.x64/"
p64ext = '64'
else:
libdir = SDK["SPEEDTREE"] + "/Lib/Windows/VC10/"
p64ext = ''
debugext = ''
if (GetOptimize() <= 2): debugext = "_d"
libsuffix = "_v%s_VC100MT%s_Static%s.lib" % (
SDK["SPEEDTREEVERSION"], p64ext, debugext)
LibName("SPEEDTREE", "%sSpeedTreeCore%s" % (libdir, libsuffix))
LibName("SPEEDTREE", "%sSpeedTreeForest%s" % (libdir, libsuffix))
LibName("SPEEDTREE", "%sSpeedTree%sRenderer%s" % (libdir, SDK["SPEEDTREEAPI"], libsuffix))
LibName("SPEEDTREE", "%sSpeedTreeRenderInterface%s" % (libdir, libsuffix))
if (SDK["SPEEDTREEAPI"] == "OpenGL"):
LibName("SPEEDTREE", "%sglew32.lib" % (libdir))
LibName("SPEEDTREE", "glu32.lib")
IncDirectory("SPEEDTREE", SDK["SPEEDTREE"] + "/Include")
if (PkgSkip("BULLET")==0):
suffix = '.lib'
if GetTargetArch() == 'x64':
suffix = '_x64.lib'
LibName("BULLET", GetThirdpartyDir() + "bullet/lib/LinearMath" + suffix)
LibName("BULLET", GetThirdpartyDir() + "bullet/lib/BulletCollision" + suffix)
LibName("BULLET", GetThirdpartyDir() + "bullet/lib/BulletDynamics" + suffix)
LibName("BULLET", GetThirdpartyDir() + "bullet/lib/BulletSoftBody" + suffix)
if (COMPILER=="GCC"):
PkgDisable("AWESOMIUM")
if GetTarget() != "darwin":
PkgDisable("CARBON")
PkgDisable("COCOA")
elif RUNTIME:
# We don't support Cocoa in the runtime yet.
PkgDisable("COCOA")
if 'x86_64' in OSX_ARCHS:
# 64-bits OS X doesn't have Carbon.
PkgDisable("CARBON")
if (PkgSkip("PYTHON")==0):
IncDirectory("ALWAYS", SDK["PYTHON"])
if (GetHost() == "darwin"):
if (PkgSkip("FREETYPE")==0 and not os.path.isdir(GetThirdpartyDir() + 'freetype')):
IncDirectory("FREETYPE", "/usr/X11/include")
IncDirectory("FREETYPE", "/usr/X11/include/freetype2")
LibDirectory("FREETYPE", "/usr/X11/lib")
if (GetHost() == "freebsd"):
IncDirectory("ALWAYS", "/usr/local/include")
LibDirectory("ALWAYS", "/usr/local/lib")
if (os.path.isdir("/usr/PCBSD")):
IncDirectory("ALWAYS", "/usr/PCBSD/local/include")
LibDirectory("ALWAYS", "/usr/PCBSD/local/lib")
fcollada_libs = ("FColladaD", "FColladaSD", "FColladaS")
# WARNING! The order of the ffmpeg libraries matters!
ffmpeg_libs = ("libavformat", "libavcodec", "libavutil")
# Name pkg-config libs, include(dir)s
if (not RUNTIME):
SmartPkgEnable("EIGEN", "eigen3", (), ("Eigen/Dense",), target_pkg = 'ALWAYS')
SmartPkgEnable("ARTOOLKIT", "", ("AR"), "AR/ar.h")
SmartPkgEnable("FCOLLADA", "", ChooseLib(fcollada_libs, "FCOLLADA"), ("FCollada", "FCollada/FCollada.h"))
SmartPkgEnable("ASSIMP", "assimp", ("assimp"), "assimp")
SmartPkgEnable("FFMPEG", ffmpeg_libs, ffmpeg_libs, ffmpeg_libs)
SmartPkgEnable("SWSCALE", "libswscale", "libswscale", ("libswscale", "libswscale/swscale.h"), target_pkg = "FFMPEG")
SmartPkgEnable("SWRESAMPLE","libswresample", "libswresample", ("libswresample", "libswresample/swresample.h"), target_pkg = "FFMPEG")
SmartPkgEnable("FFTW", "", ("rfftw", "fftw"), ("fftw.h", "rfftw.h"))
SmartPkgEnable("FMODEX", "", ("fmodex"), ("fmodex", "fmodex/fmod.h"))
SmartPkgEnable("FREETYPE", "freetype2", ("freetype"), ("freetype2", "freetype2/freetype/freetype.h"))
SmartPkgEnable("GL", "gl", ("GL"), ("GL/gl.h"), framework = "OpenGL")
SmartPkgEnable("GLES", "glesv1_cm", ("GLESv1_CM"), ("GLES/gl.h"), framework = "OpenGLES")
SmartPkgEnable("GLES2", "glesv2", ("GLESv2"), ("GLES2/gl2.h")) #framework = "OpenGLES"?
SmartPkgEnable("EGL", "egl", ("EGL"), ("EGL/egl.h"))
SmartPkgEnable("NVIDIACG", "", ("Cg"), "Cg/cg.h", framework = "Cg")
SmartPkgEnable("ODE", "", ("ode"), "ode/ode.h", tool = "ode-config")
SmartPkgEnable("OPENAL", "openal", ("openal"), "AL/al.h", framework = "OpenAL")
SmartPkgEnable("SQUISH", "", ("squish"), "squish.h")
SmartPkgEnable("TIFF", "libtiff-4", ("tiff"), "tiff.h")
SmartPkgEnable("VRPN", "", ("vrpn", "quat"), ("vrpn", "quat.h", "vrpn/vrpn_Types.h"))
SmartPkgEnable("BULLET", "bullet", ("BulletSoftBody", "BulletDynamics", "BulletCollision", "LinearMath"), ("bullet", "bullet/btBulletDynamicsCommon.h"))
SmartPkgEnable("VORBIS", "vorbisfile",("vorbisfile", "vorbis", "ogg"), ("ogg/ogg.h", "vorbis/vorbisfile.h"))
SmartPkgEnable("JPEG", "", ("jpeg"), "jpeglib.h")
SmartPkgEnable("PNG", "libpng", ("png"), "png.h", tool = "libpng-config")
if GetTarget() == "darwin" and not PkgSkip("FFMPEG"):
LibName("FFMPEG", "-Wl,-read_only_relocs,suppress")
LibName("FFMPEG", "-framework VideoDecodeAcceleration")
cv_lib = ChooseLib(("opencv_core", "cv"), "OPENCV")
if cv_lib == "opencv_core":
OPENCV_VER_23 = True
SmartPkgEnable("OPENCV", "opencv", ("opencv_core", "opencv_highgui"), ("opencv2/core/core.hpp"))
else:
SmartPkgEnable("OPENCV", "opencv", ("cv", "highgui", "cvaux", "ml", "cxcore"),
("opencv", "opencv/cv.h", "opencv/cxcore.h", "opencv/highgui.h"))
rocket_libs = ("RocketCore", "RocketControls")
if (GetOptimize() <= 3):
rocket_libs += ("RocketDebugger",)
if (GetHost() != "darwin"):
# We use a statically linked libboost_python on OSX
rocket_libs += ("boost_python",)
SmartPkgEnable("ROCKET", "", rocket_libs, "Rocket/Core.h")
if not PkgSkip("PYTHON"):
if GetTarget() == "darwin" and not RTDIST and not PkgHasCustomLocation("PYTHON"):
LibName("PYTHON", "-framework Python")
else:
SmartPkgEnable("PYTHON", "", SDK["PYTHONVERSION"], (SDK["PYTHONVERSION"], SDK["PYTHONVERSION"] + "/Python.h"), tool = SDK["PYTHONVERSION"] + "-config")
SmartPkgEnable("OPENSSL", "openssl", ("ssl", "crypto"), ("openssl/ssl.h", "openssl/crypto.h"))
SmartPkgEnable("ZLIB", "zlib", ("z"), "zlib.h")
SmartPkgEnable("GTK2", "gtk+-2.0")
if (RTDIST):
SmartPkgEnable("WX", tool = "wx-config")
SmartPkgEnable("FLTK", "", ("fltk"), ("FL/Fl.H"), tool = "fltk-config")
if GetTarget() != 'darwin':
# CgGL is covered by the Cg framework, and we don't need X11 components on OSX
if not PkgSkip("NVIDIACG") and not RUNTIME:
SmartPkgEnable("CGGL", "", ("CgGL"), "Cg/cgGL.h")
if not RUNTIME:
SmartPkgEnable("X11", "x11", "X11", ("X11", "X11/Xlib.h"))
SmartPkgEnable("XRANDR", "xrandr", "Xrandr", "X11/extensions/Xrandr.h")
SmartPkgEnable("XF86DGA", "xxf86dga", "Xxf86dga", "X11/extensions/xf86dga.h")
SmartPkgEnable("XCURSOR", "xcursor", "Xcursor", "X11/Xcursor/Xcursor.h")
if GetHost() != "darwin":
# Workaround for an issue where pkg-config does not include this path
if GetTargetArch() in ("x86_64", "amd64"):
if (os.path.isdir("/usr/lib64/glib-2.0/include")):
IncDirectory("GTK2", "/usr/lib64/glib-2.0/include")
if (os.path.isdir("/usr/lib64/gtk-2.0/include")):
IncDirectory("GTK2", "/usr/lib64/gtk-2.0/include")
if not PkgSkip("X11"):
if (os.path.isdir("/usr/X11R6/lib64")):
LibDirectory("ALWAYS", "/usr/X11R6/lib64")
else:
LibDirectory("ALWAYS", "/usr/X11R6/lib")
elif not PkgSkip("X11"):
LibDirectory("ALWAYS", "/usr/X11R6/lib")
if RUNTIME:
# For the runtime, these packages are required
for pkg in ["OPENSSL", "ZLIB"]:
skips = []
if (pkg in PkgListGet() and PkgSkip(pkg)==1):
skips.append(pkg)
if skips:
exit("Runtime must be compiled with OpenSSL and ZLib support (missing %s)" % (', '.join(skips)))
for pkg in MAYAVERSIONS:
if (PkgSkip(pkg)==0 and (pkg in SDK)):
if (GetHost() == "darwin"):
# Sheesh, Autodesk really can't make up their mind
# regarding the location of the Maya devkit on OS X.
if (os.path.isdir(SDK[pkg] + "/Maya.app/Contents/lib")):
LibDirectory(pkg, SDK[pkg] + "/Maya.app/Contents/lib")
if (os.path.isdir(SDK[pkg] + "/Maya.app/Contents/MacOS")):
LibDirectory(pkg, SDK[pkg] + "/Maya.app/Contents/MacOS")
if (os.path.isdir(SDK[pkg] + "/lib")):
LibDirectory(pkg, SDK[pkg] + "/lib")
if (os.path.isdir(SDK[pkg] + "/Maya.app/Contents/include/maya")):
IncDirectory(pkg, SDK[pkg] + "/Maya.app/Contents/include")
if (os.path.isdir(SDK[pkg] + "/devkit/include/maya")):
IncDirectory(pkg, SDK[pkg] + "/devkit/include")
if (os.path.isdir(SDK[pkg] + "/include/maya")):
IncDirectory(pkg, SDK[pkg] + "/include")
else:
LibDirectory(pkg, SDK[pkg] + "/lib")
IncDirectory(pkg, SDK[pkg] + "/include")
DefSymbol(pkg, "MAYAVERSION", pkg)
if GetTarget() == 'darwin':
LibName("ALWAYS", "-framework AppKit")
if (PkgSkip("OPENCV")==0):
LibName("OPENCV", "-framework QuickTime")
LibName("AGL", "-framework AGL")
LibName("CARBON", "-framework Carbon")
LibName("COCOA", "-framework Cocoa")
# Fix for a bug in OSX Leopard:
LibName("GL", "-dylib_file /System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib")
if GetTarget() == 'android':
LibName("ALWAYS", '-llog')
LibName("ALWAYS", '-landroid')
LibName("JNIGRAPHICS", '-ljnigraphics')
for pkg in MAYAVERSIONS:
if (PkgSkip(pkg)==0 and (pkg in SDK)):
if GetTarget() == 'darwin':
LibName(pkg, "-Wl,-rpath," + SDK[pkg] + "/Maya.app/Contents/MacOS")
else:
LibName(pkg, "-Wl,-rpath," + SDK[pkg] + "/lib")
LibName(pkg, "-lOpenMaya")
LibName(pkg, "-lOpenMayaAnim")
LibName(pkg, "-lAnimSlice")
LibName(pkg, "-lDeformSlice")
LibName(pkg, "-lModifiers")
LibName(pkg, "-lDynSlice")
LibName(pkg, "-lKinSlice")
LibName(pkg, "-lModelSlice")
LibName(pkg, "-lNurbsSlice")
LibName(pkg, "-lPolySlice")
LibName(pkg, "-lProjectSlice")
LibName(pkg, "-lImage")
LibName(pkg, "-lShared")
LibName(pkg, "-lTranslators")
LibName(pkg, "-lDataModel")
LibName(pkg, "-lRenderModel")
LibName(pkg, "-lNurbsEngine")
LibName(pkg, "-lDependEngine")
LibName(pkg, "-lCommandEngine")
LibName(pkg, "-lFoundation")
LibName(pkg, "-lIMFbase")
if GetTarget() != 'darwin':
LibName(pkg, "-lOpenMayalib")
else:
LibName(pkg, "-dylib_file /System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib")
if (PkgSkip("PHYSX")==0):
IncDirectory("PHYSX", SDK["PHYSX"] + "/Physics/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/PhysXLoader/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/NxCharacter/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/NxExtensions/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/Foundation/include")
IncDirectory("PHYSX", SDK["PHYSX"] + "/Cooking/include")
LibDirectory("PHYSX", SDK["PHYSXLIBS"])
if (GetHost() == "darwin"):
LibName("PHYSX", SDK["PHYSXLIBS"] + "/osxstatic/PhysXCooking.a")
LibName("PHYSX", SDK["PHYSXLIBS"] + "/osxstatic/PhysXCore.a")
else:
LibName("PHYSX", "-lPhysXLoader")
LibName("PHYSX", "-lNxCharacter")
DefSymbol("WITHINPANDA", "WITHIN_PANDA", "1")
if GetLinkAllStatic():
DefSymbol("ALWAYS", "LINK_ALL_STATIC")
if GetTarget() == 'android':
DefSymbol("ALWAYS", "ANDROID")
if not PkgSkip("EIGEN"):
DefSymbol("ALWAYS", "EIGEN_MPL2_ONLY")
if GetOptimize() >= 3:
DefSymbol("ALWAYS", "EIGEN_NO_DEBUG")
if COMPILER == "MSVC":
# Squeeze out a bit more performance on MSVC builds...
# Only do this if EIGEN_NO_DEBUG is also set, otherwise it
# will turn them into runtime assertions.
DefSymbol("ALWAYS", "EIGEN_NO_STATIC_ASSERT")
########################################################################
##
## Give a Status Report on Command-Line Options
##
########################################################################
def printStatus(header,warnings):
if GetVerbose():
print("")
print("-------------------------------------------------------------------")
print(header)
tkeep = ""
tomit = ""
for x in PkgListGet():
if PkgSkip(x):
tomit = tomit + x + " "
else:
tkeep = tkeep + x + " "
if RTDIST:
print("Makepanda: Runtime distribution build")
elif RUNTIME:
print("Makepanda: Runtime build")
else:
print("Makepanda: Regular build")
print("Makepanda: Compiler: %s" % (COMPILER))
print("Makepanda: Optimize: %d" % (GetOptimize()))
print("Makepanda: Keep Pkg: %s" % (tkeep))
print("Makepanda: Omit Pkg: %s" % (tomit))
if GENMAN:
print("Makepanda: Generate API reference manual")
else:
print("Makepanda: Don't generate API reference manual")
if GetHost() == "windows" and not RTDIST:
if INSTALLER:
print("Makepanda: Build installer, using %s" % (COMPRESSOR))
else:
print("Makepanda: Don't build installer")
print("Makepanda: Version ID: %s" % (VERSION))
for x in warnings:
print("Makepanda: %s" % (x))
print("-------------------------------------------------------------------")
print("")
sys.stdout.flush()
########################################################################
##
## BracketNameWithQuotes
##
########################################################################
def BracketNameWithQuotes(name):
# Workaround for OSX bug - compiler doesn't like those flags quoted.
if (name.startswith("-framework")): return name
if (name.startswith("-dylib_file")): return name
# Don't add quotes when it's not necessary.
if " " not in name: return name
# Account for quoted name (leave as is) but quote everything else (e.g., to protect spaces within paths from improper parsing)
if (name.startswith('"') and name.endswith('"')): return name
else: return '"' + name + '"'
########################################################################
##
## CompileCxx
##
########################################################################
def CompileCxx(obj,src,opts):
ipath = GetListOption(opts, "DIR:")
optlevel = GetOptimizeOption(opts)
if (COMPILER=="MSVC"):
if not BOOUSEINTELCOMPILER:
cmd = "cl "
if GetTargetArch() == 'x64':
cmd += "/favor:blend "
cmd += "/wd4996 /wd4275 /wd4267 /wd4101 /wd4273 "
# Enable Windows 7 interfaces if we need Touchinput.
if PkgSkip("TOUCHINPUT") == 0:
cmd += "/DWINVER=0x601 "
else:
cmd += "/DWINVER=0x501 "
cmd += "/Fo" + obj + " /nologo /c"
if GetTargetArch() != 'x64' and (not PkgSkip("SSE2") or 'SSE2' in opts):
cmd += " /arch:SSE2"
for x in ipath: cmd += " /I" + x
for (opt,dir) in INCDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts): cmd += " /I" + BracketNameWithQuotes(dir)
for (opt,var,val) in DEFSYMBOLS:
if (opt=="ALWAYS") or (opt in opts): cmd += " /D" + var + "=" + val
if (opts.count('MSFORSCOPE')): cmd += ' /Zc:forScope-'
if (optlevel==1): cmd += " /MDd /Zi /RTCs /GS"
if (optlevel==2): cmd += " /MDd /Zi"
if (optlevel==3): cmd += " /MD /Zi /GS- /O2 /Ob2 /Oi /Ot /fp:fast"
if (optlevel==4):
cmd += " /MD /Zi /GS- /Ox /Ob2 /Oi /Ot /fp:fast /DFORCE_INLINING /DNDEBUG /GL"
cmd += " /Oy /Zp16" # jean-claude add /Zp16 insures correct static alignment for SSEx
cmd += " /Fd" + os.path.splitext(obj)[0] + ".pdb"
building = GetValueOption(opts, "BUILDING:")
if (building):
cmd += " /DBUILDING_" + building
if ("BIGOBJ" in opts) or GetTargetArch() == 'x64':
cmd += " /bigobj"
cmd += " /Zm300 /DWIN32_VC /DWIN32"
if 'EXCEPTIONS' in opts:
cmd += " /EHsc"
else:
cmd += " /D_HAS_EXCEPTIONS=0"
if 'RTTI' not in opts:
cmd += " /GR-"
if GetTargetArch() == 'x64':
cmd += " /DWIN64_VC /DWIN64"
cmd += " /W3 " + BracketNameWithQuotes(src)
oscmd(cmd)
else:
cmd = "icl "
if GetTargetArch() == 'x64':
cmd += "/favor:blend "
cmd += "/wd4996 /wd4275 /wd4267 /wd4101 /wd4273 "
# Enable Windows 7 interfaces if we need Touchinput.
if PkgSkip("TOUCHINPUT") == 0:
cmd += "/DWINVER=0x601 "
else:
cmd += "/DWINVER=0x501 "
cmd += "/Fo" + obj + " /c"
for x in ipath: cmd += " /I" + x
for (opt,dir) in INCDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts): cmd += " /I" + BracketNameWithQuotes(dir)
for (opt,var,val) in DEFSYMBOLS:
if (opt=="ALWAYS") or (opt in opts): cmd += " /D" + var + "=" + val
if (opts.count('MSFORSCOPE')): cmd += ' /Zc:forScope-'
if (optlevel==1): cmd += " /MDd /Zi /RTCs /GS"
if (optlevel==2): cmd += " /MDd /Zi /arch:SSE3"
# core changes from jean-claude (dec 2011)
# ----------------------------------------
# performance will be seeked at level 3 & 4
# -----------------------------------------
if (optlevel==3):
cmd += " /MD /Zi /O2 /Oi /Ot /arch:SSE3"
cmd += " /Ob0"
cmd += " /Qipo-" # beware of IPO !!!
## Lesson learned: Don't use /GL flag -> end result is MESSY
## ----------------------------------------------------------------
if (optlevel==4):
cmd += " /MD /Zi /O3 /Oi /Ot /Ob0 /Yc /DNDEBUG" # /Ob0 a ete rajoute en cours de route a 47%
cmd += " /Qipo" # optimization multi file
# for 3 & 4 optimization levels
# -----------------------------
if (optlevel>=3):
cmd += " /fp:fast=2"
cmd += " /Qftz"
cmd += " /Qfp-speculation:fast"
cmd += " /Qopt-matmul" # needs /O2 or /O3
cmd += " /Qprec-div-"
cmd += " /Qsimd"
cmd += " /QxHost" # compile for target host; Compiling for distribs should probably strictly enforce /arch:..
cmd += " /Quse-intel-optimized-headers" # use intel optimized headers
cmd += " /Qparallel" # enable parallelization
cmd += " /Qvc10" # for Microsoft Visual C++ 2010
## PCH files coexistence: the /Qpchi option causes the Intel C++ Compiler to name its
## PCH files with a .pchi filename suffix and reduce build time.
## The /Qpchi option is on by default but interferes with Microsoft libs; so use /Qpchi- to turn it off.
## I need to have a deeper look at this since the compile time is quite influenced by this setting !!!
cmd += " /Qpchi-" # keep it this way!
## Inlining seems to be an issue here ! (the linker doesn't find necessary info later on)
## ------------------------------------
## so don't use cmd += " /DFORCE_INLINING" (need to check why with Panda developpers!)
## Inline expansion /Ob1 : Allow functions marked inline to be inlined.
## Inline any /Ob2 : Inline functions deemed appropriate by compiler.
## Ctor displacement /vd0 : Disable constructor displacement.
## Choose this option only if no class constructors or destructors call virtual functions.
## Use /vd1 (default) to enable. Alternate: #pragma vtordisp
## Best case ptrs /vmb : Use best case "pointer to class member" representation.
## Use this option if you always define a class before you declare a pointer to a member of the class.
## The compiler will issue an error if it encounters a pointer declaration before the class is defined.
## Alternate: #pragma pointers_to_members
cmd += " /Fd" + os.path.splitext(obj)[0] + ".pdb"
building = GetValueOption(opts, "BUILDING:")
if (building): cmd += " /DBUILDING_" + building
if ("BIGOBJ" in opts) or GetTargetArch() == 'x64':
cmd += " /bigobj"
# level of warnings and optimization reports
if GetVerbose():
cmd += " /W3 " # or /W4 or /Wall
cmd += " /Qopt-report:2 /Qopt-report-phase:hlo /Qopt-report-phase:hpo" # some optimization reports
else:
cmd += " /W1 "
cmd += " /EHa /Zm300 /DWIN32_VC /DWIN32"
if GetTargetArch() == 'x64':
cmd += " /DWIN64_VC /DWIN64"
cmd += " " + BracketNameWithQuotes(src)
oscmd(cmd)
if (COMPILER=="GCC"):
if (src.endswith(".c")): cmd = GetCC() +' -fPIC -c -o ' + obj
else: cmd = GetCXX()+' -ftemplate-depth-70 -fPIC -c -o ' + obj
for (opt, dir) in INCDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts): cmd += ' -I' + BracketNameWithQuotes(dir)
for (opt, dir) in FRAMEWORKDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts): cmd += ' -F' + BracketNameWithQuotes(dir)
for (opt,var,val) in DEFSYMBOLS:
if (opt=="ALWAYS") or (opt in opts): cmd += ' -D' + var + '=' + val
for x in ipath: cmd += ' -I' + x
if not GetLinkAllStatic():
cmd += ' -fvisibility=hidden'
# Mac-specific flags.
if GetTarget() == "darwin":
cmd += " -Wno-deprecated-declarations"
if OSXTARGET is not None:
cmd += " -isysroot " + SDK["MACOSX"]
cmd += " -mmacosx-version-min=%d.%d" % (OSXTARGET)
for arch in OSX_ARCHS:
if 'NOARCH:' + arch.upper() not in opts:
cmd += " -arch %s" % arch
if "SYSROOT" in SDK:
cmd += ' --sysroot=%s -no-canonical-prefixes' % (SDK["SYSROOT"])
# Android-specific flags.
arch = GetTargetArch()
if GetTarget() == "android":
# Most of the specific optimization flags here were
# just copied from the default Android Makefiles.
cmd += ' -I%s/include' % (SDK["ANDROID_STL"])
cmd += ' -I%s/libs/%s/include' % (SDK["ANDROID_STL"], SDK["ANDROID_ABI"])
cmd += ' -ffunction-sections -funwind-tables'
if arch == 'armv7a':
cmd += ' -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__'
cmd += ' -fstack-protector -march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16'
elif arch == 'arm':
cmd += ' -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__'
cmd += ' -fstack-protector -march=armv5te -mtune=xscale -msoft-float'
elif arch == 'mips':
cmd += ' -fno-strict-aliasing -finline-functions -fmessage-length=0'
cmd += ' -fno-inline-functions-called-once -fgcse-after-reload'
cmd += ' -frerun-cse-after-loop -frename-registers'
cmd += " -Wa,--noexecstack"
# Now add specific release/debug flags.
if optlevel >= 3:
cmd += " -fomit-frame-pointer"
if arch.startswith('arm'):
cmd += ' -fno-strict-aliasing -finline-limit=64 -mthumb'
elif arch == 'x86':
cmd += ' -fstrict-aliasing'
elif arch == 'mips':
cmd += ' -funswitch-loops -finline-limit=300'
else:
cmd += ' -fno-omit-frame-pointer'
if arch.startswith('arm'):
cmd += ' -marm'
elif arch == 'x86':
cmd += ' -fno-strict-aliasing'
# Enable SIMD instructions if requested
if arch.startswith('arm') and PkgSkip("NEON") == 0:
cmd += ' -mfpu=neon'
else:
cmd += " -pthread"
if not src.endswith(".c"):
# We don't use exceptions for most modules.
if 'EXCEPTIONS' in opts:
cmd += " -fexceptions"
else:
cmd += " -fno-exceptions"
if 'RTTI' not in opts:
# We always disable RTTI on Android for memory usage reasons.
if optlevel >= 4 or GetTarget() == "android":
cmd += " -fno-rtti"
if ('SSE2' in opts or not PkgSkip("SSE2")) and not arch.startswith("arm"):
cmd += " -msse2"
if optlevel >= 3:
cmd += " -ffast-math"
if optlevel == 3:
# Fast math is nice, but we'd like to see NaN in dev builds.
cmd += " -fno-finite-math-only"
if (optlevel==1): cmd += " -ggdb -D_DEBUG"
if (optlevel==2): cmd += " -O1 -D_DEBUG"
if (optlevel==3): cmd += " -O2"
if (optlevel==4): cmd += " -O3 -DNDEBUG"
if src.endswith(".c"):
cmd += ' ' + CFLAGS
else:
cmd += ' ' + CXXFLAGS
cmd = cmd.rstrip()
building = GetValueOption(opts, "BUILDING:")
if (building): cmd += " -DBUILDING_" + building
cmd += ' ' + BracketNameWithQuotes(src)
oscmd(cmd)
########################################################################
##
## CompileBison
##
########################################################################
def CompileBison(wobj, wsrc, opts):
ifile = os.path.basename(wsrc)
wdsth = GetOutputDir()+"/include/" + ifile[:-4] + ".h"
wdstc = GetOutputDir()+"/tmp/" + ifile + ".cxx"
pre = GetValueOption(opts, "BISONPREFIX_")
bison = GetBison()
if bison is None:
# We don't have bison. See if there is a prebuilt file.
base, ext = os.path.splitext(wsrc)
if os.path.isfile(base + '.h.prebuilt') and \
os.path.isfile(base + '.cxx.prebuilt'):
CopyFile(wdstc, base + '.cxx.prebuilt')
CopyFile(wdsth, base + '.h.prebuilt')
else:
exit('Could not find bison!')
else:
oscmd(bison + ' -y -d -o'+GetOutputDir()+'/tmp/'+ifile+'.c -p '+pre+' '+wsrc)
CopyFile(wdstc, GetOutputDir()+"/tmp/"+ifile+".c")
CopyFile(wdsth, GetOutputDir()+"/tmp/"+ifile+".h")
# Finally, compile the generated source file.
CompileCxx(wobj,wdstc,opts)
########################################################################
##
## CompileFlex
##
########################################################################
def CompileFlex(wobj,wsrc,opts):
ifile = os.path.basename(wsrc)
wdst = GetOutputDir()+"/tmp/"+ifile+".cxx"
pre = GetValueOption(opts, "BISONPREFIX_")
dashi = opts.count("FLEXDASHI")
flex = GetFlex()
if flex is None:
# We don't have flex. See if there is a prebuilt file.
base, ext = os.path.splitext(wsrc)
if os.path.isfile(base + '.cxx.prebuilt'):
CopyFile(wdst, base + '.cxx.prebuilt')
else:
exit('Could not find flex!')
else:
if (dashi):
oscmd(flex + " -i -P" + pre + " -o"+wdst+" "+wsrc)
else:
oscmd(flex + " -P" + pre + " -o"+wdst+" "+wsrc)
# Finally, compile the generated source file.
CompileCxx(wobj,wdst,opts)
########################################################################
##
## CompileIgate
##
########################################################################
def CompileIgate(woutd,wsrc,opts):
outbase = os.path.basename(woutd)[:-3]
woutc = GetOutputDir()+"/tmp/"+outbase+"_igate.cxx"
wobj = FindLocation(outbase + "_igate.obj", [])
srcdir = GetValueOption(opts, "SRCDIR:")
module = GetValueOption(opts, "IMOD:")
library = GetValueOption(opts, "ILIB:")
ipath = GetListOption(opts, "DIR:")
if (PkgSkip("PYTHON")):
WriteFile(woutc, "")
WriteFile(woutd, "")
ConditionalWriteFile(woutd, "")
return (wobj, woutc, opts)
if not CrossCompiling():
# If we're compiling for this platform, we can use the one we've built.
cmd = os.path.join(GetOutputDir(), 'bin', 'interrogate')
else:
# Assume that interrogate is on the PATH somewhere.
cmd = 'interrogate'
cmd += ' -srcdir %s -I%s -Dvolatile -Dmutable' % (srcdir, srcdir)
cmd += ' -DCPPPARSER -D__STDC__=1 -D__cplusplus=201103L'
if (COMPILER=="MSVC"):
cmd += ' -D__inline -D_X86_ -DWIN32_VC -DWIN32 -D_WIN32'
if GetTargetArch() == 'x64':
cmd += ' -DWIN64_VC -DWIN64 -D_WIN64'
# NOTE: this 1600 value is the version number for VC2010.
cmd += ' -D_MSC_VER=1600 -D"__declspec(param)=" -D__cdecl -D_near -D_far -D__near -D__far -D__stdcall'
if (COMPILER=="GCC"):
cmd += ' -D__inline -D__const=const -D__attribute__\(x\)='
if GetTargetArch() in ("x86_64", "amd64"):
cmd += ' -D_LP64'
else:
cmd += ' -D__i386__'
optlevel = GetOptimizeOption(opts)
if (optlevel==1): cmd += ' -D_DEBUG'
if (optlevel==2): cmd += ' -D_DEBUG'
if (optlevel==3): pass
if (optlevel==4): cmd += ' -DNDEBUG'
cmd += ' -oc ' + woutc + ' -od ' + woutd
cmd += ' -fnames -string -refcount -assert -python-native'
cmd += ' -S' + GetOutputDir() + '/include/parser-inc'
# Add -I, -S and -D flags
for x in ipath:
cmd += ' -I' + BracketNameWithQuotes(x)
for (opt,dir) in INCDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts):
cmd += ' -S' + BracketNameWithQuotes(dir)
for (opt,var,val) in DEFSYMBOLS:
if (opt=="ALWAYS") or (opt in opts):
cmd += ' -D' + var + '=' + val
#building = GetValueOption(opts, "BUILDING:")
#if (building): cmd += " -DBUILDING_"+building
cmd += ' -module ' + module + ' -library ' + library
for x in wsrc:
if (x.startswith("/")):
cmd += ' ' + BracketNameWithQuotes(x)
else:
cmd += ' ' + BracketNameWithQuotes(os.path.basename(x))
oscmd(cmd)
return (wobj, woutc, opts)
########################################################################
##
## CompileImod
##
########################################################################
def CompileImod(wobj, wsrc, opts):
module = GetValueOption(opts, "IMOD:")
library = GetValueOption(opts, "ILIB:")
if (COMPILER=="MSVC"):
woutc = wobj[:-4]+".cxx"
if (COMPILER=="GCC"):
woutc = wobj[:-2]+".cxx"
if (PkgSkip("PYTHON")):
WriteFile(woutc, "")
CompileCxx(wobj, woutc, opts)
return
if not CrossCompiling():
# If we're compiling for this platform, we can use the one we've built.
cmd = os.path.join(GetOutputDir(), 'bin', 'interrogate_module')
else:
# Assume that interrogate_module is on the PATH somewhere.
cmd = 'interrogate_module'
cmd += ' -oc ' + woutc + ' -module ' + module + ' -library ' + library + ' -python-native'
importmod = GetValueOption(opts, "IMPORT:")
if importmod:
cmd += ' -import ' + importmod
for x in wsrc: cmd += ' ' + BracketNameWithQuotes(x)
oscmd(cmd)
CompileCxx(wobj,woutc,opts)
return
########################################################################
##
## CompileLib
##
########################################################################
def CompileLib(lib, obj, opts):
if (COMPILER=="MSVC"):
if not BOOUSEINTELCOMPILER:
#Use MSVC Linker
cmd = 'link /lib /nologo'
if GetOptimizeOption(opts) == 4:
cmd += " /LTCG"
if HasTargetArch():
cmd += " /MACHINE:" + GetTargetArch().upper()
if GetLinkAllStatic():
cmd += ' /ignore:4006 /ignore:4221'
cmd += ' /OUT:' + BracketNameWithQuotes(lib)
for x in obj: cmd += ' ' + BracketNameWithQuotes(x)
oscmd(cmd)
else:
# Choose Intel linker; from Jean-Claude
cmd = 'xilink /verbose:lib /lib '
if HasTargetArch():
cmd += " /MACHINE:" + GetTargetArch().upper()
cmd += ' /OUT:' + BracketNameWithQuotes(lib)
for x in obj: cmd += ' ' + BracketNameWithQuotes(x)
cmd += ' /LIBPATH:"C:\Program Files (x86)\Intel\Composer XE 2011 SP1\ipp\lib\ia32"'
cmd += ' /LIBPATH:"C:\Program Files (x86)\Intel\Composer XE 2011 SP1\TBB\Lib\ia32\vc10"'
cmd += ' /LIBPATH:"C:\Program Files (x86)\Intel\Composer XE 2011 SP1\compiler\lib\ia32"'
oscmd(cmd)
if (COMPILER=="GCC"):
if GetTarget() == 'darwin':
cmd = 'libtool -static -o ' + BracketNameWithQuotes(lib)
else:
cmd = GetAR() + ' cru ' + BracketNameWithQuotes(lib)
for x in obj:
cmd += ' ' + BracketNameWithQuotes(x)
oscmd(cmd)
oscmd(GetRanlib() + ' ' + BracketNameWithQuotes(lib))
########################################################################
##
## CompileLink
##
########################################################################
def CompileLink(dll, obj, opts):
if (COMPILER=="MSVC"):
if not BOOUSEINTELCOMPILER:
cmd = "link /nologo "
if HasTargetArch():
cmd += " /MACHINE:" + GetTargetArch().upper()
if ("MFC" not in opts):
cmd += " /NOD:MFC90.LIB /NOD:MFC80.LIB /NOD:LIBCMT"
cmd += " /NOD:LIBCI.LIB /DEBUG"
cmd += " /nod:libc /nod:libcmtd /nod:atlthunk /nod:atls /nod:atlsd"
if (GetOrigExt(dll) != ".exe"): cmd += " /DLL"
optlevel = GetOptimizeOption(opts)
if (optlevel==1): cmd += " /MAP /MAPINFO:EXPORTS /NOD:MSVCRT.LIB /NOD:MSVCPRT.LIB /NOD:MSVCIRT.LIB"
if (optlevel==2): cmd += " /MAP:NUL /NOD:MSVCRT.LIB /NOD:MSVCPRT.LIB /NOD:MSVCIRT.LIB"
if (optlevel==3): cmd += " /MAP:NUL /NOD:MSVCRTD.LIB /NOD:MSVCPRTD.LIB /NOD:MSVCIRTD.LIB"
if (optlevel==4): cmd += " /MAP:NUL /LTCG /NOD:MSVCRTD.LIB /NOD:MSVCPRTD.LIB /NOD:MSVCIRTD.LIB"
if ("MFC" in opts):
if (optlevel<=2): cmd += " /NOD:MSVCRTD.LIB mfcs100d.lib MSVCRTD.lib"
else: cmd += " /NOD:MSVCRT.LIB mfcs100.lib MSVCRT.lib"
cmd += " /FIXED:NO /OPT:REF /STACK:4194304 /INCREMENTAL:NO "
cmd += ' /OUT:' + BracketNameWithQuotes(dll)
subsystem = GetValueOption(opts, "SUBSYSTEM:")
if subsystem:
cmd += " /SUBSYSTEM:" + subsystem
if dll.endswith(".dll"):
cmd += ' /IMPLIB:' + GetOutputDir() + '/lib/' + os.path.splitext(os.path.basename(dll))[0] + ".lib"
for (opt, dir) in LIBDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts):
cmd += ' /LIBPATH:' + BracketNameWithQuotes(dir)
for x in obj:
if x.endswith(".dll"):
cmd += ' ' + GetOutputDir() + '/lib/' + os.path.splitext(os.path.basename(x))[0] + ".lib"
elif x.endswith(".pyd"):
cmd += ' ' + os.path.splitext(x)[0] + ".lib"
elif x.endswith(".lib"):
dname = os.path.splitext(os.path.basename(x))[0] + ".dll"
if (GetOrigExt(x) != ".ilb" and os.path.exists(GetOutputDir()+"/bin/" + dname)):
exit("Error: in makepanda, specify "+dname+", not "+x)
cmd += ' ' + BracketNameWithQuotes(x)
elif x.endswith(".def"):
cmd += ' /DEF:' + BracketNameWithQuotes(x)
elif x.endswith(".dat"):
pass
else:
cmd += ' ' + BracketNameWithQuotes(x)
if (GetOrigExt(dll)==".exe" and "NOICON" not in opts):
cmd += " " + GetOutputDir() + "/tmp/pandaIcon.res"
for (opt, name) in LIBNAMES:
if (opt=="ALWAYS") or (opt in opts):
cmd += " " + BracketNameWithQuotes(name)
oscmd(cmd)
else:
cmd = "xilink"
if GetVerbose(): cmd += " /verbose:lib"
if HasTargetArch():
cmd += " /MACHINE:" + GetTargetArch().upper()
if ("MFC" not in opts):
cmd += " /NOD:MFC90.LIB /NOD:MFC80.LIB /NOD:LIBCMT"
cmd += " /NOD:LIBCI.LIB /DEBUG"
cmd += " /nod:libc /nod:libcmtd /nod:atlthunk /nod:atls"
cmd += ' /LIBPATH:"C:\Program Files (x86)\Intel\Composer XE 2011 SP1\ipp\lib\ia32"'
cmd += ' /LIBPATH:"C:\Program Files (x86)\Intel\Composer XE 2011 SP1\TBB\Lib\ia32\vc10"'
cmd += ' /LIBPATH:"C:\Program Files (x86)\Intel\Composer XE 2011 SP1\compiler\lib\ia32"'
if (GetOrigExt(dll) != ".exe"): cmd += " /DLL"
optlevel = GetOptimizeOption(opts)
if (optlevel==1): cmd += " /MAP /MAPINFO:EXPORTS /NOD:MSVCRT.LIB /NOD:MSVCPRT.LIB /NOD:MSVCIRT.LIB"
if (optlevel==2): cmd += " /MAP:NUL /NOD:MSVCRT.LIB /NOD:MSVCPRT.LIB /NOD:MSVCIRT.LIB"
if (optlevel==3): cmd += " /MAP:NUL /NOD:MSVCRTD.LIB /NOD:MSVCPRTD.LIB /NOD:MSVCIRTD.LIB"
if (optlevel==4): cmd += " /MAP:NUL /LTCG /NOD:MSVCRTD.LIB /NOD:MSVCPRTD.LIB /NOD:MSVCIRTD.LIB"
if ("MFC" in opts):
if (optlevel<=2): cmd += " /NOD:MSVCRTD.LIB mfcs100d.lib MSVCRTD.lib"
else: cmd += " /NOD:MSVCRT.LIB mfcs100.lib MSVCRT.lib"
cmd += " /FIXED:NO /OPT:REF /STACK:4194304 /INCREMENTAL:NO "
cmd += ' /OUT:' + BracketNameWithQuotes(dll)
subsystem = GetValueOption(opts, "SUBSYSTEM:")
if subsystem:
cmd += " /SUBSYSTEM:" + subsystem
if dll.endswith(".dll"):
cmd += ' /IMPLIB:' + GetOutputDir() + '/lib/' + os.path.splitext(os.path.basename(dll))[0] + ".lib"
for (opt, dir) in LIBDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts):
cmd += ' /LIBPATH:' + BracketNameWithQuotes(dir)
for x in obj:
if x.endswith(".dll"):
cmd += ' ' + GetOutputDir() + '/lib/' + os.path.splitext(os.path.basename(x))[0] + ".lib"
elif x.endswith(".pyd"):
cmd += ' ' + os.path.splitext(x)[0] + ".lib"
elif x.endswith(".lib"):
dname = os.path.splitext(dll)[0]+".dll"
if (GetOrigExt(x) != ".ilb" and os.path.exists(GetOutputDir()+"/bin/" + os.path.splitext(os.path.basename(x))[0] + ".dll")):
exit("Error: in makepanda, specify "+dname+", not "+x)
cmd += ' ' + BracketNameWithQuotes(x)
elif x.endswith(".def"):
cmd += ' /DEF:' + BracketNameWithQuotes(x)
elif x.endswith(".dat"):
pass
else:
cmd += ' ' + BracketNameWithQuotes(x)
if (GetOrigExt(dll)==".exe" and "NOICON" not in opts):
cmd += " " + GetOutputDir() + "/tmp/pandaIcon.res"
for (opt, name) in LIBNAMES:
if (opt=="ALWAYS") or (opt in opts):
cmd += " " + BracketNameWithQuotes(name)
oscmd(cmd)
if COMPILER == "GCC":
cxx = GetCXX()
if GetOrigExt(dll) == ".exe" and GetTarget() != 'android':
cmd = cxx + ' -o ' + dll + ' -L' + GetOutputDir() + '/lib -L' + GetOutputDir() + '/tmp'
else:
if (GetTarget() == "darwin"):
cmd = cxx + ' -undefined dynamic_lookup'
if ("BUNDLE" in opts or GetOrigExt(dll) == ".pyd"):
cmd += ' -bundle '
else:
install_name = '@loader_path/../lib/' + os.path.basename(dll)
cmd += ' -dynamiclib -install_name ' + install_name
cmd += ' -compatibility_version ' + MAJOR_VERSION + ' -current_version ' + VERSION
cmd += ' -o ' + dll + ' -L' + GetOutputDir() + '/lib -L' + GetOutputDir() + '/tmp'
else:
cmd = cxx + ' -shared'
if ("MODULE" not in opts): cmd += " -Wl,-soname=" + os.path.basename(dll)
cmd += ' -o ' + dll + ' -L' + GetOutputDir() + '/lib -L' + GetOutputDir() + '/tmp'
for x in obj:
if GetOrigExt(x) != ".dat":
cmd += ' ' + x
if (GetOrigExt(dll) == ".exe" and GetTarget() == 'windows' and "NOICON" not in opts):
cmd += " " + GetOutputDir() + "/tmp/pandaIcon.res"
# Mac OS X specific flags.
if GetTarget() == 'darwin':
cmd += " -headerpad_max_install_names"
if OSXTARGET is not None:
cmd += " -isysroot " + SDK["MACOSX"] + " -Wl,-syslibroot," + SDK["MACOSX"]
cmd += " -mmacosx-version-min=%d.%d" % (OSXTARGET)
for arch in OSX_ARCHS:
if 'NOARCH:' + arch.upper() not in opts:
cmd += " -arch %s" % arch
if "SYSROOT" in SDK:
cmd += " --sysroot=%s -no-canonical-prefixes" % (SDK["SYSROOT"])
# Android-specific flags.
if GetTarget() == 'android':
cmd += " -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now"
if GetTargetArch() == 'armv7a':
cmd += " -march=armv7-a -Wl,--fix-cortex-a8"
cmd += ' -lc -lm'
else:
cmd += " -pthread"
if LDFLAGS != "":
cmd += " " + LDFLAGS
for (opt, dir) in LIBDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts):
cmd += ' -L' + BracketNameWithQuotes(dir)
for (opt, dir) in FRAMEWORKDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts):
cmd += ' -F' + BracketNameWithQuotes(dir)
for (opt, name) in LIBNAMES:
if (opt=="ALWAYS") or (opt in opts):
cmd += ' ' + BracketNameWithQuotes(name)
if GetTarget() != 'freebsd':
cmd += " -ldl"
oscmd(cmd)
if GetTarget() == 'android':
# Copy the library to built/libs/$ANDROID_ABI and strip it.
# This is the format that Android NDK projects should use.
new_path = '%s/libs/%s/%s' % (GetOutputDir(), SDK["ANDROID_ABI"], os.path.basename(dll))
CopyFile(new_path, dll)
oscmd('%s --strip-unneeded %s' % (GetStrip(), BracketNameWithQuotes(new_path)))
elif (GetOptimizeOption(opts)==4 and GetTarget() == 'linux'):
oscmd(GetStrip() + " --strip-unneeded " + BracketNameWithQuotes(dll))
os.system("chmod +x " + BracketNameWithQuotes(dll))
if dll.endswith("." + MAJOR_VERSION + ".dylib"):
newdll = dll[:-6-len(MAJOR_VERSION)] + "dylib"
if os.path.isfile(newdll):
os.remove(newdll)
oscmd("ln -s " + BracketNameWithQuotes(os.path.basename(dll)) + " " + BracketNameWithQuotes(newdll))
elif dll.endswith("." + MAJOR_VERSION):
newdll = dll[:-len(MAJOR_VERSION)-1]
if os.path.isfile(newdll):
os.remove(newdll)
oscmd("ln -s " + BracketNameWithQuotes(os.path.basename(dll)) + " " + BracketNameWithQuotes(newdll))
##########################################################################################
#
# CompileEgg
#
##########################################################################################
def CompileEgg(eggfile, src, opts):
pz = False
if eggfile.endswith(".pz"):
pz = True
eggfile = eggfile[:-3]
# Determine the location of the pzip and flt2egg tools.
if CrossCompiling():
# We may not be able to use our generated versions of these tools,
# so we'll expect them to already be present in the PATH.
pzip = 'pzip'
flt2egg = 'flt2egg'
else:
# If we're compiling for this machine, we can use the binaries we've built.
pzip = os.path.join(GetOutputDir(), 'bin', 'pzip')
flt2egg = os.path.join(GetOutputDir(), 'bin', 'flt2egg')
if not os.path.isfile(pzip):
pzip = 'pzip'
if not os.path.isfile(flt2egg):
flt2egg = 'flt2egg'
if src.endswith(".egg"):
CopyFile(eggfile, src)
elif src.endswith(".flt"):
oscmd(flt2egg + ' -ps keep -o ' + BracketNameWithQuotes(eggfile) + ' ' + BracketNameWithQuotes(src))
if pz:
oscmd(pzip + ' ' + BracketNameWithQuotes(eggfile))
##########################################################################################
#
# CompileRes, CompileRsrc
#
##########################################################################################
def CompileRes(target, src, opts):
"""Compiles a Windows .rc file into a .res file."""
ipath = GetListOption(opts, "DIR:")
if (COMPILER == "MSVC"):
cmd = "rc"
cmd += " /Fo" + BracketNameWithQuotes(target)
for x in ipath: cmd += " /I" + x
for (opt,dir) in INCDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts):
cmd += " /I" + BracketNameWithQuotes(dir)
for (opt,var,val) in DEFSYMBOLS:
if (opt=="ALWAYS") or (opt in opts):
cmd += " /D" + var + "=" + val
cmd += " " + BracketNameWithQuotes(src)
else:
cmd = "windres"
for x in ipath: cmd += " -I" + x
for (opt,dir) in INCDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts):
cmd += " -I" + BracketNameWithQuotes(dir)
for (opt,var,val) in DEFSYMBOLS:
if (opt=="ALWAYS") or (opt in opts):
cmd += " -D" + var + "=" + val
cmd += " -i " + BracketNameWithQuotes(src)
cmd += " -o " + BracketNameWithQuotes(target)
oscmd(cmd)
def CompileRsrc(target, src, opts):
"""Compiles a Mac OS .r file into an .rsrc file."""
ipath = GetListOption(opts, "DIR:")
if os.path.isfile("/usr/bin/Rez"):
cmd = "Rez -useDF"
else:
cmd = "/Developer/Tools/Rez -useDF"
cmd += " -o " + BracketNameWithQuotes(target)
for x in ipath:
cmd += " -i " + x
for (opt,dir) in INCDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts):
cmd += " -i " + BracketNameWithQuotes(dir)
for (opt,var,val) in DEFSYMBOLS:
if (opt=="ALWAYS") or (opt in opts):
if (val == ""):
cmd += " -d " + var
else:
cmd += " -d " + var + " = " + val
cmd += " " + BracketNameWithQuotes(src)
oscmd(cmd)
##########################################################################################
#
# GenPyExtensions
#
##########################################################################################
def GenPyExtensions(target, inputs, opts):
# Hopefully the need for this will soon go away as we migrate everything to
# C extensions.
code = "# This file is automatically generated by makepanda.py. Do not modify.\n"
code += "from __future__ import absolute_import\n"
for i in inputs:
if GetOrigExt(i) == ".pyd" or (GetOrigExt(i) == '.lib' and GetLinkAllStatic()):
code += "from .%s import *\n" % (os.path.splitext(os.path.basename(i))[0])
elif GetOrigExt(i) == ".py":
code += "### BEGIN %s\n" % i
code += ReadFile(i)
code += "### END %s\n" % i
WriteFile(target, code)
##########################################################################################
#
# FreezePy
#
##########################################################################################
def FreezePy(target, inputs, opts):
assert len(inputs) > 0
cmdstr = BracketNameWithQuotes(SDK["PYTHONEXEC"]) + " "
if sys.version_info >= (2, 6):
cmdstr += "-B "
cmdstr += os.path.join("direct", "src", "showutil", "pfreeze.py")
src = inputs.pop(0)
for i in inputs:
cmdstr += " -i " + os.path.splitext(i)[0]
cmdstr += " -o " + target + " " + src
if ("LINK_PYTHON_STATIC" in opts):
os.environ["LINK_PYTHON_STATIC"] = "1"
oscmd(cmdstr)
if ("LINK_PYTHON_STATIC" in os.environ):
del os.environ["LINK_PYTHON_STATIC"]
if (not os.path.exists(target)):
exit("FREEZER_ERROR")
##########################################################################################
#
# Package
#
##########################################################################################
def Package(target, inputs, opts):
assert len(inputs) == 1
# Invoke the ppackage script.
command = BracketNameWithQuotes(SDK["PYTHONEXEC"]) + " "
if GetOptimizeOption(opts) >= 4:
command += "-OO "
if sys.version_info >= (2, 6):
command += "-B "
command += "direct/src/p3d/ppackage.py"
if GetTarget() == "darwin":
if SDK.get("MACOSX"):
command += " -R \"%s\"" % SDK["MACOSX"]
for arch in OSX_ARCHS:
if arch == "x86_64":
arch = "amd64"
command += " -P osx_%s" % arch
command += " -i \"" + GetOutputDir() + "/stage\""
if (P3DSUFFIX):
command += ' -a "' + P3DSUFFIX + '"'
command += " " + inputs[0]
oscmd(command)
##########################################################################################
#
# CompileBundle
#
##########################################################################################
def CompileBundle(target, inputs, opts):
assert GetTarget() == "darwin", 'bundles can only be made for Mac OS X'
plist = None
resources = []
objects = []
for i in inputs:
if (i.endswith(".plist")):
if (plist != None): exit("Only one plist file can be used when creating a bundle!")
plist = i
elif (i.endswith(".rsrc") or i.endswith(".icns")):
resources.append(i)
elif (GetOrigExt(i) == ".obj" or GetOrigExt(i) in SUFFIX_LIB or GetOrigExt(i) in SUFFIX_DLL):
objects.append(i)
else:
exit("Don't know how to bundle file %s" % i)
# Now link the object files to form the bundle.
if (plist == None): exit("One plist file must be used when creating a bundle!")
bundleName = plistlib.readPlist(plist)["CFBundleExecutable"]
oscmd("rm -rf %s" % target)
oscmd("mkdir -p %s/Contents/MacOS/" % target)
oscmd("mkdir -p %s/Contents/Resources/" % target)
if target.endswith(".app"):
SetOrigExt("%s/Contents/MacOS/%s" % (target, bundleName), ".exe")
else:
SetOrigExt("%s/Contents/MacOS/%s" % (target, bundleName), ".dll")
CompileLink("%s/Contents/MacOS/%s" % (target, bundleName), objects, opts + ["BUNDLE"])
oscmd("cp %s %s/Contents/Info.plist" % (plist, target))
for r in resources:
oscmd("cp %s %s/Contents/Resources/" % (r, target))
##########################################################################################
#
# CompileMIDL
#
##########################################################################################
def CompileMIDL(target, src, opts):
ipath = GetListOption(opts, "DIR:")
if (COMPILER=="MSVC"):
cmd = "midl"
cmd += " /out" + BracketNameWithQuotes(os.path.dirname(target))
for x in ipath: cmd += " /I" + x
for (opt,dir) in INCDIRECTORIES:
if (opt=="ALWAYS") or (opt in opts): cmd += " /I" + BracketNameWithQuotes(dir)
for (opt,var,val) in DEFSYMBOLS:
if (opt=="ALWAYS") or (opt in opts): cmd += " /D" + var + "=" + val
cmd += " " + BracketNameWithQuotes(src)
oscmd(cmd)
##########################################################################################
#
# CompileAnything
#
##########################################################################################
def CompileAnything(target, inputs, opts, progress = None):
if (opts.count("DEPENDENCYONLY")):
return
if (len(inputs)==0):
exit("No input files for target "+target)
infile = inputs[0]
origsuffix = GetOrigExt(target)
if (len(inputs) == 1 and origsuffix == GetOrigExt(infile)):
# It must be a simple copy operation.
ProgressOutput(progress, "Copying file", target)
CopyFile(target, infile)
if (origsuffix==".exe" and GetHost() != "windows"):
os.system("chmod +x \"%s\"" % target)
return
elif (target.endswith(".py")):
ProgressOutput(progress, "Generating", target)
return GenPyExtensions(target, inputs, opts)
elif (infile.endswith(".py")):
if (origsuffix==".exe"):
ProgressOutput(progress, "Building frozen executable", target)
else:
ProgressOutput(progress, "Building frozen library", target)
return FreezePy(target, inputs, opts)
elif (infile.endswith(".idl")):
ProgressOutput(progress, "Compiling MIDL file", infile)
return CompileMIDL(target, infile, opts)
elif (infile.endswith(".pdef")):
ProgressOutput(progress, "Building package from pdef file", infile)
return Package(target, inputs, opts)
elif origsuffix in SUFFIX_LIB:
ProgressOutput(progress, "Linking static library", target)
return CompileLib(target, inputs, opts)
elif origsuffix in SUFFIX_DLL or (origsuffix==".plugin" and GetTarget() != "darwin"):
if (origsuffix==".exe"):
if GetLinkAllStatic():
return
ProgressOutput(progress, "Linking executable", target)
else:
ProgressOutput(progress, "Linking dynamic library", target)
# Add version number to the dynamic library, on unix
if origsuffix == ".dll" and "MODULE" not in opts and not RTDIST:
tplatform = GetTarget()
if tplatform == "darwin":
# On Mac, libraries are named like libpanda.1.2.dylib
if target.lower().endswith(".dylib"):
target = target[:-5] + MAJOR_VERSION + ".dylib"
SetOrigExt(target, origsuffix)
elif tplatform != "windows" and tplatform != "android":
# On Linux, libraries are named like libpanda.so.1.2
target += "." + MAJOR_VERSION
SetOrigExt(target, origsuffix)
return CompileLink(target, inputs, opts)
elif (origsuffix==".in"):
ProgressOutput(progress, "Building Interrogate database", target)
args = CompileIgate(target, inputs, opts)
ProgressOutput(progress, "Building C++ object", args[0])
return CompileCxx(*args)
elif (origsuffix==".plugin" and GetTarget() == "darwin"):
ProgressOutput(progress, "Building plugin bundle", target)
return CompileBundle(target, inputs, opts)
elif (origsuffix==".app"):
ProgressOutput(progress, "Building application bundle", target)
return CompileBundle(target, inputs, opts)
elif (origsuffix==".pz"):
ProgressOutput(progress, "Compressing", target)
return CompileEgg(target, infile, opts)
elif (origsuffix==".egg"):
ProgressOutput(progress, "Converting", target)
return CompileEgg(target, infile, opts)
elif (origsuffix==".res"):
ProgressOutput(progress, "Building resource object", target)
return CompileRes(target, infile, opts)
elif (origsuffix==".rsrc"):
ProgressOutput(progress, "Building resource object", target)
return CompileRsrc(target, infile, opts)
elif (origsuffix==".obj"):
if (infile.endswith(".cxx")):
ProgressOutput(progress, "Building C++ object", target)
return CompileCxx(target, infile, opts)
elif (infile.endswith(".c")):
ProgressOutput(progress, "Building C object", target)
return CompileCxx(target, infile, opts)
elif (infile.endswith(".mm")):
ProgressOutput(progress, "Building Objective-C++ object", target)
return CompileCxx(target, infile, opts)
elif (infile.endswith(".yxx")):
ProgressOutput(progress, "Building Bison object", target)
return CompileBison(target, infile, opts)
elif (infile.endswith(".lxx")):
ProgressOutput(progress, "Building Flex object", target)
return CompileFlex(target, infile, opts)
elif (infile.endswith(".in")):
ProgressOutput(progress, "Building Interrogate object", target)
return CompileImod(target, inputs, opts)
elif (infile.endswith(".rc")):
ProgressOutput(progress, "Building resource object", target)
return CompileRes(target, infile, opts)
elif (infile.endswith(".r")):
ProgressOutput(progress, "Building resource object", target)
return CompileRsrc(target, infile, opts)
exit("Don't know how to compile: %s from %s" % (target, inputs))
##########################################################################################
#
# Generate dtool_config.h, prc_parameters.h, and dtool_have_xxx.dat
#
##########################################################################################
DTOOL_CONFIG=[
#_Variable_________________________Windows___________________Unix__________
("HAVE_PYTHON", '1', '1'),
("USE_DEBUG_PYTHON", 'UNDEF', 'UNDEF'),
("PYTHON_FRAMEWORK", 'UNDEF', 'UNDEF'),
("COMPILE_IN_DEFAULT_FONT", '1', '1'),
("STDFLOAT_DOUBLE", 'UNDEF', 'UNDEF'),
("HAVE_MAYA", '1', '1'),
("MAYA_PRE_5_0", 'UNDEF', 'UNDEF'),
("HAVE_SOFTIMAGE", 'UNDEF', 'UNDEF'),
("SSL_097", 'UNDEF', 'UNDEF'),
("REPORT_OPENSSL_ERRORS", '1', '1'),
("USE_PANDAFILESTREAM", '1', '1'),
("USE_DELETED_CHAIN", '1', '1'),
("HAVE_WIN_TOUCHINPUT", 'UNDEF', 'UNDEF'),
("HAVE_GLX", 'UNDEF', '1'),
("HAVE_EGL", 'UNDEF', 'UNDEF'),
("HAVE_WGL", '1', 'UNDEF'),
("HAVE_DX9", 'UNDEF', 'UNDEF'),
("HAVE_CHROMIUM", 'UNDEF', 'UNDEF'),
("HAVE_THREADS", '1', '1'),
("SIMPLE_THREADS", 'UNDEF', 'UNDEF'),
("OS_SIMPLE_THREADS", '1', '1'),
("DEBUG_THREADS", 'UNDEF', 'UNDEF'),
("HAVE_POSIX_THREADS", 'UNDEF', '1'),
("HAVE_AUDIO", '1', '1'),
("NOTIFY_DEBUG", 'UNDEF', 'UNDEF'),
("DO_PSTATS", 'UNDEF', 'UNDEF'),
("DO_DCAST", 'UNDEF', 'UNDEF'),
("DO_COLLISION_RECORDING", 'UNDEF', 'UNDEF'),
("SUPPORT_IMMEDIATE_MODE", 'UNDEF', 'UNDEF'),
("SUPPORT_FIXED_FUNCTION", '1', '1'),
("TRACK_IN_INTERPRETER", 'UNDEF', 'UNDEF'),
("DO_MEMORY_USAGE", 'UNDEF', 'UNDEF'),
("DO_PIPELINING", '1', '1'),
("EXPORT_TEMPLATES", 'yes', 'yes'),
("LINK_IN_GL", 'UNDEF', 'UNDEF'),
("LINK_IN_PHYSICS", 'UNDEF', 'UNDEF'),
("DEFAULT_PATHSEP", '";"', '":"'),
("WORDS_BIGENDIAN", 'UNDEF', 'UNDEF'),
("HAVE_NAMESPACE", '1', '1'),
("HAVE_OPEN_MASK", 'UNDEF', 'UNDEF'),
("HAVE_LOCKF", '1', '1'),
("HAVE_WCHAR_T", '1', '1'),
("HAVE_WSTRING", '1', '1'),
("HAVE_TYPENAME", '1', '1'),
("SIMPLE_STRUCT_POINTERS", '1', 'UNDEF'),
("HAVE_DINKUM", 'UNDEF', 'UNDEF'),
("HAVE_STL_HASH", 'UNDEF', 'UNDEF'),
("GETTIMEOFDAY_ONE_PARAM", 'UNDEF', 'UNDEF'),
("HAVE_GETOPT", 'UNDEF', '1'),
("HAVE_GETOPT_LONG_ONLY", 'UNDEF', '1'),
("PHAVE_GETOPT_H", 'UNDEF', '1'),
("PHAVE_LINUX_INPUT_H", 'UNDEF', '1'),
("IOCTL_TERMINAL_WIDTH", 'UNDEF', '1'),
("HAVE_STREAMSIZE", '1', '1'),
("HAVE_IOS_TYPEDEFS", '1', '1'),
("HAVE_IOS_BINARY", '1', '1'),
("STATIC_INIT_GETENV", '1', 'UNDEF'),
("HAVE_PROC_SELF_EXE", 'UNDEF', '1'),
("HAVE_PROC_SELF_MAPS", 'UNDEF', '1'),
("HAVE_PROC_SELF_ENVIRON", 'UNDEF', '1'),
("HAVE_PROC_SELF_CMDLINE", 'UNDEF', '1'),
("HAVE_PROC_CURPROC_FILE", 'UNDEF', 'UNDEF'),
("HAVE_PROC_CURPROC_MAP", 'UNDEF', 'UNDEF'),
("HAVE_PROC_SELF_CMDLINE", 'UNDEF', 'UNDEF'),
("HAVE_GLOBAL_ARGV", '1', 'UNDEF'),
("PROTOTYPE_GLOBAL_ARGV", 'UNDEF', 'UNDEF'),
("GLOBAL_ARGV", '__argv', 'UNDEF'),
("GLOBAL_ARGC", '__argc', 'UNDEF'),
("PHAVE_IO_H", '1', 'UNDEF'),
("PHAVE_IOSTREAM", '1', '1'),
("PHAVE_STRING_H", 'UNDEF', '1'),
("PHAVE_LIMITS_H", 'UNDEF', '1'),
("PHAVE_STDLIB_H", 'UNDEF', '1'),
("PHAVE_MALLOC_H", '1', '1'),
("PHAVE_SYS_MALLOC_H", 'UNDEF', 'UNDEF'),
("PHAVE_ALLOCA_H", 'UNDEF', '1'),
("PHAVE_LOCALE_H", 'UNDEF', '1'),
("PHAVE_MINMAX_H", '1', 'UNDEF'),
("PHAVE_SSTREAM", '1', '1'),
("PHAVE_NEW", '1', '1'),
("PHAVE_SYS_TYPES_H", '1', '1'),
("PHAVE_SYS_TIME_H", 'UNDEF', '1'),
("PHAVE_UNISTD_H", 'UNDEF', '1'),
("PHAVE_UTIME_H", 'UNDEF', '1'),
("PHAVE_GLOB_H", 'UNDEF', '1'),
("PHAVE_DIRENT_H", 'UNDEF', '1'),
("PHAVE_SYS_SOUNDCARD_H", 'UNDEF', '1'),
("PHAVE_UCONTEXT_H", 'UNDEF', '1'),
("PHAVE_STDINT_H", 'UNDEF', '1'),
("HAVE_RTTI", '1', '1'),
("HAVE_X11", 'UNDEF', '1'),
("HAVE_XRANDR", 'UNDEF', '1'),
("HAVE_XF86DGA", 'UNDEF', '1'),
("HAVE_XCURSOR", 'UNDEF', '1'),
("IS_LINUX", 'UNDEF', '1'),
("IS_OSX", 'UNDEF', 'UNDEF'),
("IS_FREEBSD", 'UNDEF', 'UNDEF'),
("GLOBAL_OPERATOR_NEW_EXCEPTIONS", 'UNDEF', '1'),
("HAVE_EIGEN", 'UNDEF', 'UNDEF'),
("LINMATH_ALIGN", '1', '1'),
("HAVE_ZLIB", 'UNDEF', 'UNDEF'),
("HAVE_PNG", 'UNDEF', 'UNDEF'),
("HAVE_JPEG", 'UNDEF', 'UNDEF'),
("PHAVE_JPEGINT_H", '1', '1'),
("HAVE_VIDEO4LINUX", 'UNDEF', '1'),
("HAVE_TIFF", 'UNDEF', 'UNDEF'),
("HAVE_SGI_RGB", '1', '1'),
("HAVE_TGA", '1', '1'),
("HAVE_IMG", '1', '1'),
("HAVE_SOFTIMAGE_PIC", '1', '1'),
("HAVE_BMP", '1', '1'),
("HAVE_PNM", '1', '1'),
("HAVE_VORBIS", 'UNDEF', 'UNDEF'),
("HAVE_NVIDIACG", 'UNDEF', 'UNDEF'),
("HAVE_FREETYPE", 'UNDEF', 'UNDEF'),
("HAVE_FFTW", 'UNDEF', 'UNDEF'),
("HAVE_OPENSSL", 'UNDEF', 'UNDEF'),
("HAVE_NET", 'UNDEF', 'UNDEF'),
("HAVE_EGG", '1', '1'),
("HAVE_CG", 'UNDEF', 'UNDEF'),
("HAVE_CGGL", 'UNDEF', 'UNDEF'),
("HAVE_CGDX9", 'UNDEF', 'UNDEF'),
("HAVE_FFMPEG", 'UNDEF', 'UNDEF'),
("HAVE_SWSCALE", 'UNDEF', 'UNDEF'),
("HAVE_SWRESAMPLE", 'UNDEF', 'UNDEF'),
("HAVE_ARTOOLKIT", 'UNDEF', 'UNDEF'),
("HAVE_OPENCV", 'UNDEF', 'UNDEF'),
("HAVE_DIRECTCAM", 'UNDEF', 'UNDEF'),
("HAVE_SQUISH", 'UNDEF', 'UNDEF'),
("HAVE_FCOLLADA", 'UNDEF', 'UNDEF'),
("HAVE_CARBON", 'UNDEF', 'UNDEF'),
("HAVE_COCOA", 'UNDEF', 'UNDEF'),
("HAVE_OPENAL_FRAMEWORK", 'UNDEF', 'UNDEF'),
("HAVE_ROCKET_PYTHON", '1', '1'),
("HAVE_ROCKET_DEBUGGER", 'UNDEF', 'UNDEF'),
("PRC_SAVE_DESCRIPTIONS", '1', '1'),
# ("_SECURE_SCL", '0', 'UNDEF'),
# ("_SECURE_SCL_THROWS", '0', 'UNDEF'),
("HAVE_P3D_PLUGIN", 'UNDEF', 'UNDEF'),
]
PRC_PARAMETERS=[
("DEFAULT_PRC_DIR", '"<auto>etc"', '"<auto>etc"'),
("PRC_DIR_ENVVARS", '"PANDA_PRC_DIR"', '"PANDA_PRC_DIR"'),
("PRC_PATH_ENVVARS", '"PANDA_PRC_PATH"', '"PANDA_PRC_PATH"'),
("PRC_PATH2_ENVVARS", '""', '""'),
("PRC_PATTERNS", '"*.prc"', '"*.prc"'),
("PRC_ENCRYPTED_PATTERNS", '"*.prc.pe"', '"*.prc.pe"'),
("PRC_ENCRYPTION_KEY", '""', '""'),
("PRC_EXECUTABLE_PATTERNS", '""', '""'),
("PRC_EXECUTABLE_ARGS_ENVVAR", '"PANDA_PRC_XARGS"', '"PANDA_PRC_XARGS"'),
("PRC_PUBLIC_KEYS_FILENAME", '""', '""'),
("PRC_RESPECT_TRUST_LEVEL", 'UNDEF', 'UNDEF'),
("PRC_DCONFIG_TRUST_LEVEL", '0', '0'),
("PRC_INC_TRUST_LEVEL", '0', '0'),
]
def WriteConfigSettings():
dtool_config={}
prc_parameters={}
speedtree_parameters={}
plugin_config={}
if (GetTarget() == 'windows'):
for key,win,unix in DTOOL_CONFIG:
dtool_config[key] = win
for key,win,unix in PRC_PARAMETERS:
prc_parameters[key] = win
else:
for key,win,unix in DTOOL_CONFIG:
dtool_config[key] = unix
for key,win,unix in PRC_PARAMETERS:
prc_parameters[key] = unix
for x in PkgListGet():
if ("HAVE_"+x in dtool_config):
if (PkgSkip(x)==0):
dtool_config["HAVE_"+x] = '1'
else:
dtool_config["HAVE_"+x] = 'UNDEF'
if not PkgSkip("OPENCV"):
dtool_config["OPENCV_VER_23"] = '1' if OPENCV_VER_23 else 'UNDEF'
dtool_config["HAVE_NET"] = '1'
if (PkgSkip("NVIDIACG")==0):
dtool_config["HAVE_CG"] = '1'
dtool_config["HAVE_CGGL"] = '1'
dtool_config["HAVE_CGDX9"] = '1'
if (GetTarget() != "linux"):
dtool_config["HAVE_PROC_SELF_EXE"] = 'UNDEF'
dtool_config["HAVE_PROC_SELF_MAPS"] = 'UNDEF'
dtool_config["HAVE_PROC_SELF_CMDLINE"] = 'UNDEF'
dtool_config["HAVE_PROC_SELF_ENVIRON"] = 'UNDEF'
if (GetTarget() == "darwin"):
dtool_config["PYTHON_FRAMEWORK"] = 'Python'
dtool_config["PHAVE_MALLOC_H"] = 'UNDEF'
dtool_config["PHAVE_SYS_MALLOC_H"] = '1'
dtool_config["HAVE_OPENAL_FRAMEWORK"] = '1'
dtool_config["HAVE_X11"] = 'UNDEF' # We might have X11, but we don't need it.
dtool_config["HAVE_XRANDR"] = 'UNDEF'
dtool_config["HAVE_XF86DGA"] = 'UNDEF'
dtool_config["HAVE_XCURSOR"] = 'UNDEF'
dtool_config["HAVE_GLX"] = 'UNDEF'
dtool_config["IS_LINUX"] = 'UNDEF'
dtool_config["HAVE_VIDEO4LINUX"] = 'UNDEF'
dtool_config["IS_OSX"] = '1'
# 10.4 had a broken ucontext implementation
if int(platform.mac_ver()[0][3]) <= 4:
dtool_config["PHAVE_UCONTEXT_H"] = 'UNDEF'
if (GetTarget() == "freebsd"):
dtool_config["IS_LINUX"] = 'UNDEF'
dtool_config["HAVE_VIDEO4LINUX"] = 'UNDEF'
dtool_config["IS_FREEBSD"] = '1'
dtool_config["PHAVE_ALLOCA_H"] = 'UNDEF'
dtool_config["PHAVE_MALLOC_H"] = 'UNDEF'
dtool_config["PHAVE_LINUX_INPUT_H"] = 'UNDEF'
dtool_config["HAVE_PROC_CURPROC_FILE"] = '1'
dtool_config["HAVE_PROC_CURPROC_MAP"] = '1'
dtool_config["HAVE_PROC_CURPROC_CMDLINE"] = '1'
if (GetTarget() == "android"):
# Android does have RTTI, but we disable it anyway.
dtool_config["HAVE_RTTI"] = 'UNDEF'
dtool_config["PHAVE_GLOB_H"] = 'UNDEF'
dtool_config["HAVE_LOCKF"] = 'UNDEF'
dtool_config["HAVE_VIDEO4LINUX"] = 'UNDEF'
if (GetOptimize() <= 2 and GetTarget() == "windows"):
dtool_config["USE_DEBUG_PYTHON"] = '1'
# This should probably be more sophisticated, such as based
# on whether the libRocket Python modules are available.
if (PkgSkip("PYTHON") != 0):
dtool_config["HAVE_ROCKET_PYTHON"] = 'UNDEF'
if (PkgSkip("TOUCHINPUT") == 0 and GetTarget() == "windows"):
dtool_config["HAVE_WIN_TOUCHINPUT"] = '1'
if (GetOptimize() <= 3):
dtool_config["HAVE_ROCKET_DEBUGGER"] = '1'
if (GetOptimize() <= 3):
if (dtool_config["HAVE_NET"] != 'UNDEF'):
dtool_config["DO_PSTATS"] = '1'
if (GetOptimize() <= 3):
dtool_config["DO_DCAST"] = '1'
if (GetOptimize() <= 3):
dtool_config["DO_COLLISION_RECORDING"] = '1'
#if (GetOptimize() <= 2):
# dtool_config["TRACK_IN_INTERPRETER"] = '1'
if (GetOptimize() <= 3):
dtool_config["DO_MEMORY_USAGE"] = '1'
if (GetOptimize() <= 3):
dtool_config["NOTIFY_DEBUG"] = '1'
if (GetOptimize() >= 4):
dtool_config["PRC_SAVE_DESCRIPTIONS"] = 'UNDEF'
if (GetOptimize() >= 4):
# Disable RTTI on release builds.
dtool_config["HAVE_RTTI"] = 'UNDEF'
# Now that we have OS_SIMPLE_THREADS, we can support
# SIMPLE_THREADS on exotic architectures like win64, so we no
# longer need to disable it for this platform.
## if GetTarget() == 'windows' and GetTargetArch() == 'x64':
## dtool_config["SIMPLE_THREADS"] = 'UNDEF'
if (RTDIST or RUNTIME):
prc_parameters["DEFAULT_PRC_DIR"] = '""'
if HOST_URL:
plugin_config["PANDA_PACKAGE_HOST_URL"] = HOST_URL
#plugin_config["P3D_PLUGIN_LOG_DIRECTORY"] = ""
plugin_config["P3D_PLUGIN_LOG_BASENAME1"] = ""
plugin_config["P3D_PLUGIN_LOG_BASENAME2"] = ""
plugin_config["P3D_PLUGIN_LOG_BASENAME3"] = ""
plugin_config["P3D_PLUGIN_P3D_PLUGIN"] = ""
plugin_config["P3D_PLUGIN_P3DPYTHON"] = ""
plugin_config["P3D_COREAPI_VERSION_STR"] = COREAPI_VERSION
plugin_config["P3D_PLUGIN_VERSION_STR"] = PLUGIN_VERSION
if PkgSkip("GTK2") == 0:
plugin_config["HAVE_GTK"] = '1'
if (RUNTIME):
dtool_config["HAVE_P3D_PLUGIN"] = '1'
# Whether it's present on the system doesn't matter here,
# as the runtime itself doesn't include or link with X11.
if (RUNTIME and GetTarget() == 'linux'):
dtool_config["HAVE_X11"] = '1'
if ("GENERIC_DXERR_LIBRARY" in SDK):
dtool_config["USE_GENERIC_DXERR_LIBRARY"] = "1"
else:
dtool_config["USE_GENERIC_DXERR_LIBRARY"] = "UNDEF"
if (PkgSkip("SPEEDTREE")==0):
speedtree_parameters["SPEEDTREE_OPENGL"] = "UNDEF"
speedtree_parameters["SPEEDTREE_DIRECTX9"] = "UNDEF"
if SDK["SPEEDTREEAPI"] == "OpenGL":
speedtree_parameters["SPEEDTREE_OPENGL"] = "1"
elif SDK["SPEEDTREEAPI"] == "DirectX9":
speedtree_parameters["SPEEDTREE_DIRECTX9"] = "1"
speedtree_parameters["SPEEDTREE_BIN_DIR"] = (SDK["SPEEDTREE"] + "/Bin")
conf = "/* prc_parameters.h. Generated automatically by makepanda.py */\n"
for key in sorted(prc_parameters.keys()):
if ((key == "DEFAULT_PRC_DIR") or (key[:4]=="PRC_")):
val = OverrideValue(key, prc_parameters[key])
if (val == 'UNDEF'): conf = conf + "#undef " + key + "\n"
else: conf = conf + "#define " + key + " " + val + "\n"
ConditionalWriteFile(GetOutputDir() + '/include/prc_parameters.h', conf)
conf = "/* dtool_config.h. Generated automatically by makepanda.py */\n"
for key in sorted(dtool_config.keys()):
val = OverrideValue(key, dtool_config[key])
if (val == 'UNDEF'): conf = conf + "#undef " + key + "\n"
else: conf = conf + "#define " + key + " " + val + "\n"
ConditionalWriteFile(GetOutputDir() + '/include/dtool_config.h', conf)
if (RTDIST or RUNTIME):
conf = "/* p3d_plugin_config.h. Generated automatically by makepanda.py */\n"
for key in sorted(plugin_config.keys()):
val = plugin_config[key]
if (val == 'UNDEF'): conf = conf + "#undef " + key + "\n"
else: conf = conf + "#define " + key + " \"" + val.replace("\\", "\\\\") + "\"\n"
ConditionalWriteFile(GetOutputDir() + '/include/p3d_plugin_config.h', conf)
if (PkgSkip("SPEEDTREE")==0):
conf = "/* speedtree_parameters.h. Generated automatically by makepanda.py */\n"
for key in sorted(speedtree_parameters.keys()):
val = OverrideValue(key, speedtree_parameters[key])
if (val == 'UNDEF'): conf = conf + "#undef " + key + "\n"
else: conf = conf + "#define " + key + " \"" + val.replace("\\", "\\\\") + "\"\n"
ConditionalWriteFile(GetOutputDir() + '/include/speedtree_parameters.h', conf)
for x in PkgListGet():
if (PkgSkip(x)): ConditionalWriteFile(GetOutputDir() + '/tmp/dtool_have_'+x.lower()+'.dat', "0\n")
else: ConditionalWriteFile(GetOutputDir() + '/tmp/dtool_have_'+x.lower()+'.dat', "1\n")
WriteConfigSettings()
WarnConflictingFiles()
if SystemLibraryExists("dtoolbase"):
print("%sWARNING:%s Found conflicting Panda3D libraries from other ppremake build!" % (GetColor("red"), GetColor()))
if SystemLibraryExists("p3dtoolconfig"):
print("%sWARNING:%s Found conflicting Panda3D libraries from other makepanda build!" % (GetColor("red"), GetColor()))
##########################################################################################
#
# Generate pandaVersion.h, pythonversion, null.cxx, etc.
#
##########################################################################################
PANDAVERSION_H="""
#define PANDA_MAJOR_VERSION $VERSION1
#define PANDA_MINOR_VERSION $VERSION2
#define PANDA_SEQUENCE_VERSION $VERSION3
#define PANDA_VERSION $NVERSION
#define PANDA_NUMERIC_VERSION $NVERSION
#define PANDA_VERSION_STR "$VERSION1.$VERSION2.$VERSION3"
#define PANDA_ABI_VERSION_STR "$VERSION1.$VERSION2"
#define PANDA_DISTRIBUTOR "$DISTRIBUTOR"
#define PANDA_PACKAGE_VERSION_STR "$RTDIST_VERSION"
#define PANDA_PACKAGE_HOST_URL "$HOST_URL"
"""
PANDAVERSION_H_RUNTIME="""
#define PANDA_MAJOR_VERSION 0
#define PANDA_MINOR_VERSION 0
#define PANDA_SEQUENCE_VERSION 0
#define PANDA_VERSION_STR "0.0.0"
#define PANDA_ABI_VERSION_STR "0.0"
#define P3D_PLUGIN_MAJOR_VERSION $VERSION1
#define P3D_PLUGIN_MINOR_VERSION $VERSION2
#define P3D_PLUGIN_SEQUENCE_VERSION $VERSION3
#define P3D_PLUGIN_VERSION_STR "$VERSION1.$VERSION2.$VERSION3"
#define P3D_COREAPI_VERSION_STR "$COREAPI_VERSION"
#define PANDA_DISTRIBUTOR "$DISTRIBUTOR"
#define PANDA_PACKAGE_VERSION_STR ""
#define PANDA_PACKAGE_HOST_URL "$HOST_URL"
"""
CHECKPANDAVERSION_CXX="""
# include "dtoolbase.h"
EXPCL_DTOOL int panda_version_$VERSION1_$VERSION2 = 0;
"""
CHECKPANDAVERSION_H="""
# include "dtoolbase.h"
extern EXPCL_DTOOL int panda_version_$VERSION1_$VERSION2;
# ifndef WIN32
/* For Windows, exporting the symbol from the DLL is sufficient; the
DLL will not load unless all expected public symbols are defined.
Other systems may not mind if the symbol is absent unless we
explictly write code that references it. */
static int check_panda_version = panda_version_$VERSION1_$VERSION2;
# endif
"""
P3DACTIVEX_RC="""#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
#include "afxres.h"
#undef APSTUDIO_READONLY_SYMBOLS
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
#ifdef _WIN32
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
#pragma code_page(1252)
#endif
#ifdef APSTUDIO_INVOKED
1 TEXTINCLUDE
BEGIN
"resource.h\\0"
END
2 TEXTINCLUDE
BEGIN
"#include ""afxres.h""\\r\\n"
"\\0"
END
3 TEXTINCLUDE
BEGIN
"1 TYPELIB ""P3DActiveX.tlb""\\r\\n"
"\\0"
END
#endif
%s
IDB_P3DACTIVEX BITMAP "P3DActiveXCtrl.bmp"
IDD_PROPPAGE_P3DACTIVEX DIALOG 0, 0, 250, 62
STYLE DS_SETFONT | WS_CHILD
FONT 8, "MS Sans Serif"
BEGIN
LTEXT "TODO: Place controls to manipulate properties of P3DActiveX Control on this dialog.",
IDC_STATIC,7,25,229,16
END
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO
BEGIN
IDD_PROPPAGE_P3DACTIVEX, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 243
TOPMARGIN, 7
BOTTOMMARGIN, 55
END
END
#endif
STRINGTABLE
BEGIN
IDS_P3DACTIVEX "P3DActiveX Control"
IDS_P3DACTIVEX_PPG "P3DActiveX Property Page"
END
STRINGTABLE
BEGIN
IDS_P3DACTIVEX_PPG_CAPTION "General"
END
#endif
#ifndef APSTUDIO_INVOKED
1 TYPELIB "P3DActiveX.tlb"
#endif"""
def CreatePandaVersionFiles():
version1=int(VERSION.split(".")[0])
version2=int(VERSION.split(".")[1])
version3=int(VERSION.split(".")[2])
nversion=version1*1000000+version2*1000+version3
if (DISTRIBUTOR != "cmu"):
# Subtract 1 if we are not an official version.
nversion -= 1
if (RUNTIME):
pandaversion_h = PANDAVERSION_H_RUNTIME
else:
pandaversion_h = PANDAVERSION_H
pandaversion_h = pandaversion_h.replace("$VERSION1",str(version1))
pandaversion_h = pandaversion_h.replace("$VERSION2",str(version2))
pandaversion_h = pandaversion_h.replace("$VERSION3",str(version3))
pandaversion_h = pandaversion_h.replace("$NVERSION",str(nversion))
pandaversion_h = pandaversion_h.replace("$DISTRIBUTOR",DISTRIBUTOR)
pandaversion_h = pandaversion_h.replace("$RTDIST_VERSION",RTDIST_VERSION)
pandaversion_h = pandaversion_h.replace("$COREAPI_VERSION",COREAPI_VERSION)
pandaversion_h = pandaversion_h.replace("$HOST_URL",(HOST_URL or ""))
if (DISTRIBUTOR == "cmu"):
pandaversion_h += "\n#define PANDA_OFFICIAL_VERSION\n"
else:
pandaversion_h += "\n#undef PANDA_OFFICIAL_VERSION\n"
if GIT_COMMIT:
pandaversion_h += "\n#define PANDA_GIT_COMMIT_STR \"%s\"\n" % (GIT_COMMIT)
if not RUNTIME:
checkpandaversion_cxx = CHECKPANDAVERSION_CXX.replace("$VERSION1",str(version1))
checkpandaversion_cxx = checkpandaversion_cxx.replace("$VERSION2",str(version2))
checkpandaversion_cxx = checkpandaversion_cxx.replace("$VERSION3",str(version3))
checkpandaversion_cxx = checkpandaversion_cxx.replace("$NVERSION",str(nversion))
checkpandaversion_h = CHECKPANDAVERSION_H.replace("$VERSION1",str(version1))
checkpandaversion_h = checkpandaversion_h.replace("$VERSION2",str(version2))
checkpandaversion_h = checkpandaversion_h.replace("$VERSION3",str(version3))
checkpandaversion_h = checkpandaversion_h.replace("$NVERSION",str(nversion))
ConditionalWriteFile(GetOutputDir()+'/include/pandaVersion.h', pandaversion_h)
if RUNTIME:
ConditionalWriteFile(GetOutputDir()+'/include/checkPandaVersion.cxx', '')
ConditionalWriteFile(GetOutputDir()+'/include/checkPandaVersion.h', '')
else:
ConditionalWriteFile(GetOutputDir()+'/include/checkPandaVersion.cxx', checkpandaversion_cxx)
ConditionalWriteFile(GetOutputDir()+'/include/checkPandaVersion.h', checkpandaversion_h)
ConditionalWriteFile(GetOutputDir()+"/tmp/null.cxx","")
if RUNTIME:
p3dactivex_rc = {"name" : "Panda3D Game Engine Plug-in",
"version" : VERSION,
"description" : "Runs 3-D games and interactive applets",
"filename" : "p3dactivex.ocx",
"mimetype" : "application/x-panda3d",
"extension" : "p3d",
"filedesc" : "Panda3D applet"}
ConditionalWriteFile(GetOutputDir()+"/include/P3DActiveX.rc", P3DACTIVEX_RC % GenerateResourceFile(**p3dactivex_rc))
CreatePandaVersionFiles()
##########################################################################################
#
# Copy the "direct" tree
#
##########################################################################################
if (PkgSkip("DIRECT")==0):
CopyPythonTree(GetOutputDir() + '/direct', 'direct/src', lib2to3_fixers=['all'])
ConditionalWriteFile(GetOutputDir() + '/direct/__init__.py', "")
# This file used to be copied, but would nowadays cause conflicts.
# Let's get it out of the way in case someone hasn't cleaned their build since.
if os.path.isfile(GetOutputDir() + '/bin/panda3d.py'):
os.remove(GetOutputDir() + '/bin/panda3d.py')
if os.path.isfile(GetOutputDir() + '/lib/panda3d.py'):
os.remove(GetOutputDir() + '/lib/panda3d.py')
# Don't copy this file, which would cause conflict with our 'panda3d' module.
if os.path.isfile(GetOutputDir() + '/direct/ffi/panda3d.py'):
os.remove(GetOutputDir() + '/direct/ffi/panda3d.py')
if os.path.isfile(GetOutputDir() + '/direct/ffi/panda3d.pyc'):
os.remove(GetOutputDir() + '/direct/ffi/panda3d.pyc')
# This used to exist; no longer.
if sys.platform == 'win32':
core_so = GetOutputDir() + '/panda3d/core.pyd'
direct_so = GetOutputDir() + '/panda3d/direct.pyd'
dtoolconfig_so = GetOutputDir() + '/panda3d/dtoolconfig.pyd'
else:
core_so = GetOutputDir() + '/panda3d/core.so'
direct_so = GetOutputDir() + '/panda3d/direct.so'
dtoolconfig_so = GetOutputDir() + '/panda3d/dtoolconfig.so'
if os.path.isfile(core_so):
os.remove(core_so)
if os.path.isfile(direct_so):
os.remove(direct_so)
if os.path.isfile(dtoolconfig_so):
os.remove(dtoolconfig_so)
# Write an appropriate panda3d/__init__.py
p3d_init = """"Python bindings for the Panda3D libraries"
"""
if GetTarget() == 'windows':
p3d_init += """
import os
bindir = os.path.join(os.path.dirname(__file__), '..', 'bin')
if os.path.isfile(os.path.join(bindir, 'libpanda.dll')):
if not os.environ.get('PATH'):
os.environ['PATH'] = bindir
else:
os.environ['PATH'] = bindir + os.pathsep + os.environ['PATH']
del os, bindir
"""
ConditionalWriteFile(GetOutputDir() + '/panda3d/__init__.py', p3d_init)
# PandaModules is now deprecated; generate a shim for backward compatibility.
for fn in glob.glob(GetOutputDir() + '/pandac/*.py') + glob.glob(GetOutputDir() + '/pandac/*.py[co]'):
if os.path.basename(fn) not in ('PandaModules.py', '__init__.py'):
os.remove(fn)
panda_modules = ['core']
if not PkgSkip("PANDAPHYSICS"):
panda_modules.append('physics')
if not PkgSkip('PANDAFX'):
panda_modules.append('fx')
if not PkgSkip("DIRECT"):
panda_modules.append('direct')
if not PkgSkip("VISION"):
panda_modules.append('vision')
if not PkgSkip("SKEL"):
panda_modules.append('skel')
panda_modules.append('egg')
if not PkgSkip("AWESOMIUM"):
panda_modules.append('awesomium')
if not PkgSkip("ODE"):
panda_modules.append('ode')
if not PkgSkip("VRPN"):
panda_modules.append('vrpn')
panda_modules_code = """
"This module is deprecated. Import from panda3d.core and other panda3d.* modules instead."
print("Warning: pandac.PandaModules is deprecated, import from panda3d.core instead")
"""
for module in panda_modules:
panda_modules_code += """
try:
from panda3d.%s import *
except ImportError as err:
if "No module named %s" not in str(err):
raise""" % (module, module)
ConditionalWriteFile(GetOutputDir() + '/pandac/PandaModules.py', panda_modules_code)
ConditionalWriteFile(GetOutputDir() + '/pandac/__init__.py', '')
##########################################################################################
#
# Generate the PRC files into the ETC directory.
#
##########################################################################################
confautoprc = ReadFile("makepanda/confauto.in")
if (PkgSkip("SPEEDTREE")==0):
# If SpeedTree is available, enable it in the config file
confautoprc = confautoprc.replace('#st#', '')
else:
# otherwise, disable it.
confautoprc = confautoprc.replace('#st#', '#')
if (os.path.isfile("makepanda/myconfig.in")):
configprc = ReadFile("makepanda/myconfig.in")
else:
configprc = ReadFile("makepanda/config.in")
if (GetTarget() == 'windows'):
configprc = configprc.replace("$HOME/.panda3d", "$USER_APPDATA/Panda3D-%s" % MAJOR_VERSION)
else:
configprc = configprc.replace("aux-display pandadx9", "")
if (GetTarget() == 'darwin'):
configprc = configprc.replace(".panda3d/cache", "Library/Caches/Panda3D-%s" % MAJOR_VERSION)
# OpenAL is not yet working well on OSX for us, so let's do this for now.
configprc = configprc.replace("p3openal_audio", "p3fmod_audio")
ConditionalWriteFile(GetOutputDir()+"/etc/Config.prc", configprc)
ConditionalWriteFile(GetOutputDir()+"/etc/Confauto.prc", confautoprc)
##########################################################################################
#
# Copy the precompiled binaries and DLLs into the build.
#
##########################################################################################
tp_dir = GetThirdpartyDir()
if tp_dir is not None:
dylibs = set()
if GetTarget() == 'darwin':
for lib in glob.glob(tp_dir + "/*/lib/*.dylib"):
dylibs.add(os.path.basename(lib))
for pkg in PkgListGet():
if PkgSkip(pkg):
continue
tp_pkg = tp_dir + pkg.lower()
if GetTarget() == 'windows':
if os.path.exists(tp_pkg + "/bin"):
CopyAllFiles(GetOutputDir() + "/bin/", tp_pkg + "/bin/")
if (PkgSkip("PYTHON")==0 and os.path.exists(tp_pkg + "/bin/" + SDK["PYTHONVERSION"])):
CopyAllFiles(GetOutputDir() + "/bin/", tp_pkg + "/bin/" + SDK["PYTHONVERSION"] + "/")
else:
for tp_lib in glob.glob(tp_pkg + "/lib/*.so*"):
CopyFile(GetOutputDir() + "/lib/" + os.path.basename(tp_lib), tp_lib)
if not PkgSkip("PYTHON"):
for tp_lib in glob.glob(os.path.join(tp_pkg, "lib", SDK["PYTHONVERSION"], "*.so*")):
CopyFile(GetOutputDir() + "/lib/" + os.path.basename(tp_lib), tp_lib)
if GetTarget() == 'darwin':
tp_libs = glob.glob(tp_pkg + "/lib/*.dylib")
if not PkgSkip("PYTHON"):
tp_libs += glob.glob(os.path.join(tp_pkg, "lib", SDK["PYTHONVERSION"], "*.dylib"))
for tp_lib in tp_libs:
basename = os.path.basename(tp_lib)
target = GetOutputDir() + "/lib/" + basename
if not NeedsBuild([target], [tp_lib]):
continue
CopyFile(target, tp_lib)
if os.path.islink(target):
continue
# Correct the inter-library dependencies so that the build is relocatable.
oscmd('install_name_tool -id @loader_path/../lib/%s %s' % (basename, target))
oscmd("otool -L %s | grep .dylib > %s/tmp/otool-libs.txt" % (target, GetOutputDir()), True)
for line in open(GetOutputDir() + "/tmp/otool-libs.txt", "r"):
line = line.strip()
if not line or line.startswith('@loader_path/../lib/') or line.endswith(":"):
continue
libdep = line.split(" ", 1)[0]
dep_basename = os.path.basename(libdep)
if dep_basename in dylibs:
oscmd("install_name_tool -change %s @loader_path/../lib/%s %s" % (libdep, dep_basename, target), True)
JustBuilt([target], [tp_lib])
for fwx in glob.glob(tp_pkg + "/*.framework"):
CopyTree(GetOutputDir() + "/Frameworks/" + os.path.basename(fwx), fwx)
if GetTarget() == 'windows':
CopyAllFiles(GetOutputDir() + "/bin/", tp_dir + "extras/bin/")
if not PkgSkip("PYTHON"):
pydll = "/" + SDK["PYTHONVERSION"].replace(".", "")
if (GetOptimize() <= 2): pydll += "_d.dll"
else: pydll += ".dll"
CopyFile(GetOutputDir() + "/bin" + pydll, SDK["PYTHON"] + pydll)
if not RTDIST:
CopyTree(GetOutputDir() + "/python", SDK["PYTHON"])
if not os.path.isfile(SDK["PYTHON"] + "/ppython.exe") and os.path.isfile(SDK["PYTHON"] + "/python.exe"):
CopyFile(GetOutputDir() + "/python/ppython.exe", SDK["PYTHON"] + "/python.exe")
if not os.path.isfile(SDK["PYTHON"] + "/ppythonw.exe") and os.path.isfile(SDK["PYTHON"] + "/pythonw.exe"):
CopyFile(GetOutputDir() + "/python/ppythonw.exe", SDK["PYTHON"] + "/pythonw.exe")
ConditionalWriteFile(GetOutputDir() + "/python/panda.pth", "..\n../bin\n")
########################################################################
##
## Copy various stuff into the build.
##
########################################################################
CopyFile(GetOutputDir()+"/", "doc/LICENSE")
CopyFile(GetOutputDir()+"/", "doc/ReleaseNotes")
if (PkgSkip("PANDATOOL")==0):
CopyAllFiles(GetOutputDir()+"/plugins/", "pandatool/src/scripts/", ".mel")
CopyAllFiles(GetOutputDir()+"/plugins/", "pandatool/src/scripts/", ".ms")
if (PkgSkip("PYTHON")==0 and os.path.isdir(GetThirdpartyBase()+"/Pmw")):
CopyTree(GetOutputDir()+'/Pmw', GetThirdpartyBase()+'/Pmw')
ConditionalWriteFile(GetOutputDir()+'/include/ctl3d.h', '/* dummy file to make MAX happy */')
########################################################################
#
# Copy header files to the built/include/parser-inc directory.
#
########################################################################
CopyTree(GetOutputDir()+'/include/parser-inc','dtool/src/parser-inc')
MakeDirectory(GetOutputDir()+'/include/parser-inc/openssl')
MakeDirectory(GetOutputDir()+'/include/parser-inc/netinet')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Cg')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Core')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Forest')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Renderers')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Renderers/OpenGL')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Renderers/DirectX9')
MakeDirectory(GetOutputDir()+'/include/parser-inc/glew')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Eigen')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Rocket')
MakeDirectory(GetOutputDir()+'/include/parser-inc/Rocket/Core')
MakeDirectory(GetOutputDir()+'/include/parser-inc/opencv2')
MakeDirectory(GetOutputDir()+'/include/parser-inc/opencv2/core')
MakeDirectory(GetOutputDir()+'/include/parser-inc/opencv2/highgui')
CopyAllFiles(GetOutputDir()+'/include/parser-inc/openssl/','dtool/src/parser-inc/')
CopyAllFiles(GetOutputDir()+'/include/parser-inc/netinet/','dtool/src/parser-inc/')
CopyFile(GetOutputDir()+'/include/parser-inc/Cg/','dtool/src/parser-inc/cg.h')
CopyFile(GetOutputDir()+'/include/parser-inc/Cg/','dtool/src/parser-inc/cgGL.h')
CopyFile(GetOutputDir()+'/include/parser-inc/Core/','dtool/src/parser-inc/Core.h')
CopyFile(GetOutputDir()+'/include/parser-inc/Forest/','dtool/src/parser-inc/Forest.h')
CopyFile(GetOutputDir()+'/include/parser-inc/Renderers/OpenGL/','dtool/src/parser-inc/OpenGLRenderer.h')
CopyFile(GetOutputDir()+'/include/parser-inc/Renderers/DirectX9/','dtool/src/parser-inc/DirectX9Renderer.h')
CopyFile(GetOutputDir()+'/include/parser-inc/glew/','dtool/src/parser-inc/glew.h')
CopyFile(GetOutputDir()+'/include/parser-inc/Eigen/','dtool/src/parser-inc/Dense')
CopyFile(GetOutputDir()+'/include/parser-inc/Eigen/','dtool/src/parser-inc/StdVector')
CopyFile(GetOutputDir()+'/include/parser-inc/Rocket/Core/','dtool/src/parser-inc/RenderInterface.h')
CopyFile(GetOutputDir()+'/include/parser-inc/opencv2/core/','dtool/src/parser-inc/core.hpp')
CopyFile(GetOutputDir()+'/include/parser-inc/opencv2/highgui/','dtool/src/parser-inc/highgui.hpp')
DeleteVCS(GetOutputDir()+'/include/parser-inc')
########################################################################
#
# Transfer all header files to the built/include directory.
#
########################################################################
CopyAllHeaders('dtool/src/dtoolbase')
CopyAllHeaders('dtool/src/dtoolutil', skip=["pandaVersion.h", "checkPandaVersion.h"])
CopyFile(GetOutputDir()+'/include/','dtool/src/dtoolutil/vector_src.cxx')
CopyAllHeaders('dtool/metalibs/dtool')
CopyAllHeaders('dtool/src/cppparser')
CopyAllHeaders('dtool/src/prc', skip=["prc_parameters.h"])
CopyAllHeaders('dtool/src/dconfig')
CopyAllHeaders('dtool/src/interrogatedb')
CopyAllHeaders('dtool/metalibs/dtoolconfig')
CopyAllHeaders('dtool/src/pystub')
CopyAllHeaders('dtool/src/interrogate')
CopyAllHeaders('dtool/src/test_interrogate')
CopyAllHeaders('panda/src/putil')
CopyAllHeaders('panda/src/pandabase')
CopyAllHeaders('panda/src/express')
CopyAllHeaders('panda/src/downloader')
CopyAllHeaders('panda/metalibs/pandaexpress')
CopyAllHeaders('panda/src/pipeline')
CopyAllHeaders('panda/src/linmath')
CopyAllHeaders('panda/src/putil')
CopyAllHeaders('dtool/src/prckeys')
CopyAllHeaders('panda/src/audio')
CopyAllHeaders('panda/src/event')
CopyAllHeaders('panda/src/mathutil')
CopyAllHeaders('panda/src/gsgbase')
CopyAllHeaders('panda/src/pnmimage')
CopyAllHeaders('panda/src/nativenet')
CopyAllHeaders('panda/src/net')
CopyAllHeaders('panda/src/pstatclient')
CopyAllHeaders('panda/src/gobj')
CopyAllHeaders('panda/src/movies')
CopyAllHeaders('panda/src/pgraphnodes')
CopyAllHeaders('panda/src/pgraph')
CopyAllHeaders('panda/src/cull')
CopyAllHeaders('panda/src/chan')
CopyAllHeaders('panda/src/char')
CopyAllHeaders('panda/src/dgraph')
CopyAllHeaders('panda/src/display')
CopyAllHeaders('panda/src/device')
CopyAllHeaders('panda/src/pnmtext')
CopyAllHeaders('panda/src/text')
CopyAllHeaders('panda/src/grutil')
if (PkgSkip("VISION")==0):
CopyAllHeaders('panda/src/vision')
CopyAllHeaders('panda/src/awesomium')
if (PkgSkip("FFMPEG")==0):
CopyAllHeaders('panda/src/ffmpeg')
CopyAllHeaders('panda/src/tform')
CopyAllHeaders('panda/src/collide')
CopyAllHeaders('panda/src/parametrics')
CopyAllHeaders('panda/src/pgui')
CopyAllHeaders('panda/src/pnmimagetypes')
CopyAllHeaders('panda/src/recorder')
if (PkgSkip("ROCKET")==0):
CopyAllHeaders('panda/src/rocket')
if (PkgSkip("VRPN")==0):
CopyAllHeaders('panda/src/vrpn')
CopyAllHeaders('panda/src/wgldisplay')
CopyAllHeaders('panda/src/ode')
CopyAllHeaders('panda/metalibs/pandaode')
if (PkgSkip("PANDAPHYSICS")==0):
CopyAllHeaders('panda/src/physics')
if (PkgSkip("PANDAPARTICLESYSTEM")==0):
CopyAllHeaders('panda/src/particlesystem')
CopyAllHeaders('panda/src/dxml')
CopyAllHeaders('panda/metalibs/panda')
CopyAllHeaders('panda/src/audiotraits')
CopyAllHeaders('panda/src/audiotraits')
CopyAllHeaders('panda/src/distort')
CopyAllHeaders('panda/src/downloadertools')
CopyAllHeaders('panda/src/windisplay')
CopyAllHeaders('panda/src/dxgsg9')
CopyAllHeaders('panda/metalibs/pandadx9')
CopyAllHeaders('panda/src/egg')
CopyAllHeaders('panda/src/egg2pg')
CopyAllHeaders('panda/src/framework')
CopyAllHeaders('panda/metalibs/pandafx')
CopyAllHeaders('panda/src/glstuff')
CopyAllHeaders('panda/src/glgsg')
CopyAllHeaders('panda/src/glesgsg')
CopyAllHeaders('panda/src/gles2gsg')
CopyAllHeaders('panda/metalibs/pandaegg')
if GetTarget() == 'windows':
CopyAllHeaders('panda/src/wgldisplay')
elif GetTarget() == 'darwin':
CopyAllHeaders('panda/src/osxdisplay')
CopyAllHeaders('panda/src/cocoadisplay')
elif GetTarget() == 'android':
CopyAllHeaders('panda/src/android')
CopyAllHeaders('panda/src/androiddisplay')
else:
CopyAllHeaders('panda/src/x11display')
CopyAllHeaders('panda/src/glxdisplay')
CopyAllHeaders('panda/src/egldisplay')
CopyAllHeaders('panda/metalibs/pandagl')
CopyAllHeaders('panda/metalibs/pandagles')
CopyAllHeaders('panda/metalibs/pandagles2')
CopyAllHeaders('panda/metalibs/pandaphysics')
CopyAllHeaders('panda/src/testbed')
if (PkgSkip("PHYSX")==0):
CopyAllHeaders('panda/src/physx')
CopyAllHeaders('panda/metalibs/pandaphysx')
if (PkgSkip("BULLET")==0):
CopyAllHeaders('panda/src/bullet')
CopyAllHeaders('panda/metalibs/pandabullet')
if (PkgSkip("SPEEDTREE")==0):
CopyAllHeaders('panda/src/speedtree')
if (PkgSkip("DIRECT")==0):
CopyAllHeaders('direct/src/directbase')
CopyAllHeaders('direct/src/dcparser')
CopyAllHeaders('direct/src/deadrec')
CopyAllHeaders('direct/src/distributed')
CopyAllHeaders('direct/src/interval')
CopyAllHeaders('direct/src/showbase')
CopyAllHeaders('direct/metalibs/direct')
CopyAllHeaders('direct/src/dcparse')
if (RUNTIME or RTDIST):
CopyAllHeaders('direct/src/plugin', skip=["p3d_plugin_config.h"])
if (RUNTIME):
CopyAllHeaders('direct/src/plugin_npapi')
CopyAllHeaders('direct/src/plugin_standalone')
if (PkgSkip("PANDATOOL")==0):
CopyAllHeaders('pandatool/src/pandatoolbase')
CopyAllHeaders('pandatool/src/converter')
CopyAllHeaders('pandatool/src/progbase')
CopyAllHeaders('pandatool/src/eggbase')
CopyAllHeaders('pandatool/src/bam')
CopyAllHeaders('pandatool/src/cvscopy')
CopyAllHeaders('pandatool/src/daeegg')
CopyAllHeaders('pandatool/src/daeprogs')
CopyAllHeaders('pandatool/src/dxf')
CopyAllHeaders('pandatool/src/dxfegg')
CopyAllHeaders('pandatool/src/dxfprogs')
CopyAllHeaders('pandatool/src/palettizer')
CopyAllHeaders('pandatool/src/egg-mkfont')
CopyAllHeaders('pandatool/src/eggcharbase')
CopyAllHeaders('pandatool/src/egg-optchar')
CopyAllHeaders('pandatool/src/egg-palettize')
CopyAllHeaders('pandatool/src/egg-qtess')
CopyAllHeaders('pandatool/src/eggprogs')
CopyAllHeaders('pandatool/src/flt')
CopyAllHeaders('pandatool/src/fltegg')
CopyAllHeaders('pandatool/src/fltprogs')
CopyAllHeaders('pandatool/src/imagebase')
CopyAllHeaders('pandatool/src/imageprogs')
CopyAllHeaders('pandatool/src/pfmprogs')
CopyAllHeaders('pandatool/src/lwo')
CopyAllHeaders('pandatool/src/lwoegg')
CopyAllHeaders('pandatool/src/lwoprogs')
CopyAllHeaders('pandatool/src/maya')
CopyAllHeaders('pandatool/src/mayaegg')
CopyAllHeaders('pandatool/src/maxegg')
CopyAllHeaders('pandatool/src/maxprogs')
CopyAllHeaders('pandatool/src/objegg')
CopyAllHeaders('pandatool/src/objprogs')
CopyAllHeaders('pandatool/src/vrml')
CopyAllHeaders('pandatool/src/vrmlegg')
CopyAllHeaders('pandatool/src/xfile')
CopyAllHeaders('pandatool/src/xfileegg')
CopyAllHeaders('pandatool/src/ptloader')
CopyAllHeaders('pandatool/src/miscprogs')
CopyAllHeaders('pandatool/src/pstatserver')
CopyAllHeaders('pandatool/src/softprogs')
CopyAllHeaders('pandatool/src/text-stats')
CopyAllHeaders('pandatool/src/vrmlprogs')
CopyAllHeaders('pandatool/src/win-stats')
CopyAllHeaders('pandatool/src/xfileprogs')
if (PkgSkip("CONTRIB")==0):
CopyAllHeaders('contrib/src/contribbase')
CopyAllHeaders('contrib/src/ai')
########################################################################
#
# Copy Java files, if applicable
#
########################################################################
if GetTarget() == 'android':
CopyAllJavaSources('panda/src/android')
########################################################################
#
# These definitions are syntactic shorthand. They make it easy
# to link with the usual libraries without listing them all.
#
########################################################################
COMMON_DTOOL_LIBS=[
'libp3dtool.dll',
'libp3dtoolconfig.dll',
]
COMMON_PANDA_LIBS=[
'libpanda.dll',
'libpandaexpress.dll'
] + COMMON_DTOOL_LIBS
COMMON_EGG2X_LIBS=[
'libp3eggbase.lib',
'libp3progbase.lib',
'libp3converter.lib',
'libp3pandatoolbase.lib',
'libpandaegg.dll',
] + COMMON_PANDA_LIBS
COMMON_DTOOL_LIBS_PYSTUB = COMMON_DTOOL_LIBS + ['libp3pystub.lib']
COMMON_PANDA_LIBS_PYSTUB = COMMON_PANDA_LIBS + ['libp3pystub.lib']
COMMON_EGG2X_LIBS_PYSTUB = COMMON_EGG2X_LIBS + ['libp3pystub.lib']
########################################################################
#
# This section contains a list of all the files that need to be compiled.
#
########################################################################
print("Generating dependencies...")
sys.stdout.flush()
#
# Compile Panda icon resource file.
# We do it first because we need it at
# the time we compile an executable.
#
if GetTarget() == 'windows':
OPTS=['DIR:panda/src/configfiles']
TargetAdd('pandaIcon.res', opts=OPTS, input='pandaIcon.rc')
#
# DIRECTORY: dtool/src/dtoolbase/
#
OPTS=['DIR:dtool/src/dtoolbase', 'BUILDING:DTOOL']
TargetAdd('p3dtoolbase_composite1.obj', opts=OPTS, input='p3dtoolbase_composite1.cxx')
TargetAdd('p3dtoolbase_composite2.obj', opts=OPTS, input='p3dtoolbase_composite2.cxx')
TargetAdd('p3dtoolbase_lookup3.obj', opts=OPTS, input='lookup3.c')
TargetAdd('p3dtoolbase_indent.obj', opts=OPTS, input='indent.cxx')
#
# DIRECTORY: dtool/src/dtoolutil/
#
OPTS=['DIR:dtool/src/dtoolutil', 'BUILDING:DTOOL']
TargetAdd('p3dtoolutil_composite1.obj', opts=OPTS, input='p3dtoolutil_composite1.cxx')
TargetAdd('p3dtoolutil_composite2.obj', opts=OPTS, input='p3dtoolutil_composite2.cxx')
if GetTarget() == 'darwin':
TargetAdd('p3dtoolutil_filename_assist.obj', opts=OPTS, input='filename_assist.mm')
#
# DIRECTORY: dtool/metalibs/dtool/
#
OPTS=['DIR:dtool/metalibs/dtool', 'BUILDING:DTOOL']
TargetAdd('p3dtool_dtool.obj', opts=OPTS, input='dtool.cxx')
TargetAdd('libp3dtool.dll', input='p3dtool_dtool.obj')
TargetAdd('libp3dtool.dll', input='p3dtoolutil_composite1.obj')
TargetAdd('libp3dtool.dll', input='p3dtoolutil_composite2.obj')
if GetTarget() == 'darwin':
TargetAdd('libp3dtool.dll', input='p3dtoolutil_filename_assist.obj')
TargetAdd('libp3dtool.dll', input='p3dtoolbase_composite1.obj')
TargetAdd('libp3dtool.dll', input='p3dtoolbase_composite2.obj')
TargetAdd('libp3dtool.dll', input='p3dtoolbase_indent.obj')
TargetAdd('libp3dtool.dll', input='p3dtoolbase_lookup3.obj')
TargetAdd('libp3dtool.dll', opts=['ADVAPI','WINSHELL','WINKERNEL'])
#
# DIRECTORY: dtool/src/cppparser/
#
if (not RUNTIME):
OPTS=['DIR:dtool/src/cppparser', 'BISONPREFIX_cppyy']
CreateFile(GetOutputDir()+"/include/cppBison.h")
TargetAdd('p3cppParser_cppBison.obj', opts=OPTS, input='cppBison.yxx')
TargetAdd('cppBison.h', input='p3cppParser_cppBison.obj', opts=['DEPENDENCYONLY'])
TargetAdd('p3cppParser_composite1.obj', opts=OPTS, input='p3cppParser_composite1.cxx')
TargetAdd('p3cppParser_composite2.obj', opts=OPTS, input='p3cppParser_composite2.cxx')
TargetAdd('libp3cppParser.ilb', input='p3cppParser_composite1.obj')
TargetAdd('libp3cppParser.ilb', input='p3cppParser_composite2.obj')
TargetAdd('libp3cppParser.ilb', input='p3cppParser_cppBison.obj')
#
# DIRECTORY: dtool/src/prc/
#
OPTS=['DIR:dtool/src/prc', 'BUILDING:DTOOLCONFIG', 'OPENSSL']
TargetAdd('p3prc_composite1.obj', opts=OPTS, input='p3prc_composite1.cxx')
TargetAdd('p3prc_composite2.obj', opts=OPTS, input='p3prc_composite2.cxx')
#
# DIRECTORY: dtool/src/dconfig/
#
OPTS=['DIR:dtool/src/dconfig', 'BUILDING:DTOOLCONFIG']
TargetAdd('p3dconfig_composite1.obj', opts=OPTS, input='p3dconfig_composite1.cxx')
#
# DIRECTORY: dtool/metalibs/dtoolconfig/
#
OPTS=['DIR:dtool/metalibs/dtoolconfig', 'BUILDING:DTOOLCONFIG']
TargetAdd('p3dtoolconfig_dtoolconfig.obj', opts=OPTS, input='dtoolconfig.cxx')
TargetAdd('libp3dtoolconfig.dll', input='p3dtoolconfig_dtoolconfig.obj')
TargetAdd('libp3dtoolconfig.dll', input='p3dconfig_composite1.obj')
TargetAdd('libp3dtoolconfig.dll', input='p3prc_composite1.obj')
TargetAdd('libp3dtoolconfig.dll', input='p3prc_composite2.obj')
TargetAdd('libp3dtoolconfig.dll', input='libp3dtool.dll')
TargetAdd('libp3dtoolconfig.dll', opts=['ADVAPI', 'OPENSSL', 'WINGDI', 'WINUSER'])
#
# DIRECTORY: dtool/src/interrogatedb/
#
OPTS=['DIR:dtool/src/interrogatedb', 'BUILDING:INTERROGATEDB']
TargetAdd('p3interrogatedb_composite1.obj', opts=OPTS, input='p3interrogatedb_composite1.cxx')
TargetAdd('p3interrogatedb_composite2.obj', opts=OPTS, input='p3interrogatedb_composite2.cxx')
TargetAdd('libp3interrogatedb.dll', input='p3interrogatedb_composite1.obj')
TargetAdd('libp3interrogatedb.dll', input='p3interrogatedb_composite2.obj')
TargetAdd('libp3interrogatedb.dll', input='libp3dtool.dll')
TargetAdd('libp3interrogatedb.dll', input='libp3dtoolconfig.dll')
TargetAdd('libp3interrogatedb.dll', opts=['PYTHON'])
if not PkgSkip("PYTHON"):
# This used to be called dtoolconfig.pyd, but it just contains the interrogatedb
# stuff, so it has been renamed appropriately.
OPTS=['DIR:dtool/metalibs/dtoolconfig']
TargetAdd('interrogatedb_pydtool.obj', opts=OPTS, input="pydtool.cxx")
TargetAdd('interrogatedb.pyd', input='interrogatedb_pydtool.obj')
TargetAdd('interrogatedb.pyd', input='libp3dtool.dll')
TargetAdd('interrogatedb.pyd', input='libp3dtoolconfig.dll')
TargetAdd('interrogatedb.pyd', input='libp3interrogatedb.dll')
TargetAdd('interrogatedb.pyd', opts=['PYTHON'])
# Make a stub file importing the new one for backward compatibility.
TargetAdd('panda3d/dtoolconfig.py', input='interrogatedb.pyd')
#
# DIRECTORY: dtool/src/pystub/
#
OPTS=['DIR:dtool/src/pystub']
TargetAdd('p3pystub_pystub.obj', opts=OPTS, input='pystub.cxx')
TargetAdd('libp3pystub.lib', input='p3pystub_pystub.obj')
#TargetAdd('libp3pystub.lib', input='libp3dtool.dll')
TargetAdd('libp3pystub.lib', opts=['ADVAPI'])
#
# DIRECTORY: dtool/src/interrogate/
#
if (not RUNTIME):
OPTS=['DIR:dtool/src/interrogate', 'DIR:dtool/src/cppparser', 'DIR:dtool/src/interrogatedb']
TargetAdd('interrogate_composite1.obj', opts=OPTS, input='interrogate_composite1.cxx')
TargetAdd('interrogate_composite2.obj', opts=OPTS, input='interrogate_composite2.cxx')
TargetAdd('interrogate.exe', input='interrogate_composite1.obj')
TargetAdd('interrogate.exe', input='interrogate_composite2.obj')
TargetAdd('interrogate.exe', input='libp3cppParser.ilb')
TargetAdd('interrogate.exe', input=COMMON_DTOOL_LIBS_PYSTUB)
TargetAdd('interrogate.exe', input='libp3interrogatedb.dll')
TargetAdd('interrogate.exe', opts=['ADVAPI', 'OPENSSL', 'WINSHELL', 'WINGDI', 'WINUSER'])
TargetAdd('interrogate_module_interrogate_module.obj', opts=OPTS, input='interrogate_module.cxx')
TargetAdd('interrogate_module.exe', input='interrogate_module_interrogate_module.obj')
TargetAdd('interrogate_module.exe', input='libp3cppParser.ilb')
TargetAdd('interrogate_module.exe', input=COMMON_DTOOL_LIBS_PYSTUB)
TargetAdd('interrogate_module.exe', input='libp3interrogatedb.dll')
TargetAdd('interrogate_module.exe', opts=['ADVAPI', 'OPENSSL', 'WINSHELL', 'WINGDI', 'WINUSER'])
if (not RTDIST):
TargetAdd('parse_file_parse_file.obj', opts=OPTS, input='parse_file.cxx')
TargetAdd('parse_file.exe', input='parse_file_parse_file.obj')
TargetAdd('parse_file.exe', input='libp3cppParser.ilb')
TargetAdd('parse_file.exe', input=COMMON_DTOOL_LIBS_PYSTUB)
TargetAdd('parse_file.exe', input='libp3interrogatedb.dll')
TargetAdd('parse_file.exe', opts=['ADVAPI', 'OPENSSL', 'WINSHELL', 'WINGDI', 'WINUSER'])
#
# DIRECTORY: dtool/src/prckeys/
#
if (PkgSkip("OPENSSL")==0 and not RUNTIME and not RTDIST):
OPTS=['DIR:dtool/src/prckeys', 'OPENSSL']
TargetAdd('make-prc-key_makePrcKey.obj', opts=OPTS, input='makePrcKey.cxx')
TargetAdd('make-prc-key.exe', input='make-prc-key_makePrcKey.obj')
TargetAdd('make-prc-key.exe', input=COMMON_DTOOL_LIBS_PYSTUB)
TargetAdd('make-prc-key.exe', opts=['ADVAPI', 'OPENSSL', 'WINSHELL', 'WINGDI', 'WINUSER'])
#
# DIRECTORY: dtool/src/test_interrogate/
#
if (not RTDIST and not RUNTIME):
OPTS=['DIR:dtool/src/test_interrogate']
TargetAdd('test_interrogate_test_interrogate.obj', opts=OPTS, input='test_interrogate.cxx')
TargetAdd('test_interrogate.exe', input='test_interrogate_test_interrogate.obj')
TargetAdd('test_interrogate.exe', input='libp3interrogatedb.dll')
TargetAdd('test_interrogate.exe', input=COMMON_DTOOL_LIBS_PYSTUB)
TargetAdd('test_interrogate.exe', opts=['ADVAPI', 'OPENSSL', 'WINSHELL', 'WINGDI', 'WINUSER'])
#
# DIRECTORY: panda/src/pandabase/
#
OPTS=['DIR:panda/src/pandabase', 'BUILDING:PANDAEXPRESS']
TargetAdd('p3pandabase_pandabase.obj', opts=OPTS, input='pandabase.cxx')
#
# DIRECTORY: panda/src/express/
#
OPTS=['DIR:panda/src/express', 'BUILDING:PANDAEXPRESS', 'OPENSSL', 'ZLIB']
TargetAdd('p3express_composite1.obj', opts=OPTS, input='p3express_composite1.cxx')
TargetAdd('p3express_composite2.obj', opts=OPTS, input='p3express_composite2.cxx')
OPTS=['DIR:panda/src/express', 'OPENSSL', 'ZLIB']
IGATEFILES=GetDirectoryContents('panda/src/express', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3express.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3express.in', opts=['IMOD:panda3d.core', 'ILIB:libp3express', 'SRCDIR:panda/src/express'])
TargetAdd('libp3express_igate.obj', input='libp3express.in', opts=["DEPENDENCYONLY"])
TargetAdd('p3express_ext_composite.obj', opts=OPTS, input='p3express_ext_composite.cxx')
#
# DIRECTORY: panda/src/downloader/
#
OPTS=['DIR:panda/src/downloader', 'BUILDING:PANDAEXPRESS', 'OPENSSL', 'ZLIB']
TargetAdd('p3downloader_composite1.obj', opts=OPTS, input='p3downloader_composite1.cxx')
TargetAdd('p3downloader_composite2.obj', opts=OPTS, input='p3downloader_composite2.cxx')
OPTS=['DIR:panda/src/downloader', 'OPENSSL', 'ZLIB']
IGATEFILES=GetDirectoryContents('panda/src/downloader', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3downloader.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3downloader.in', opts=['IMOD:panda3d.core', 'ILIB:libp3downloader', 'SRCDIR:panda/src/downloader'])
TargetAdd('libp3downloader_igate.obj', input='libp3downloader.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/metalibs/pandaexpress/
#
OPTS=['DIR:panda/metalibs/pandaexpress', 'BUILDING:PANDAEXPRESS', 'ZLIB']
TargetAdd('pandaexpress_pandaexpress.obj', opts=OPTS, input='pandaexpress.cxx')
TargetAdd('libpandaexpress.dll', input='pandaexpress_pandaexpress.obj')
TargetAdd('libpandaexpress.dll', input='p3downloader_composite1.obj')
TargetAdd('libpandaexpress.dll', input='p3downloader_composite2.obj')
TargetAdd('libpandaexpress.dll', input='p3express_composite1.obj')
TargetAdd('libpandaexpress.dll', input='p3express_composite2.obj')
TargetAdd('libpandaexpress.dll', input='p3pandabase_pandabase.obj')
TargetAdd('libpandaexpress.dll', input=COMMON_DTOOL_LIBS)
TargetAdd('libpandaexpress.dll', opts=['ADVAPI', 'WINSOCK2', 'OPENSSL', 'ZLIB', 'WINGDI', 'WINUSER'])
#
# DIRECTORY: panda/src/pipeline/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/pipeline', 'BUILDING:PANDA']
TargetAdd('p3pipeline_composite1.obj', opts=OPTS, input='p3pipeline_composite1.cxx')
TargetAdd('p3pipeline_composite2.obj', opts=OPTS, input='p3pipeline_composite2.cxx')
TargetAdd('p3pipeline_contextSwitch.obj', opts=OPTS, input='contextSwitch.c')
OPTS=['DIR:panda/src/pipeline']
IGATEFILES=GetDirectoryContents('panda/src/pipeline', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3pipeline.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3pipeline.in', opts=['IMOD:panda3d.core', 'ILIB:libp3pipeline', 'SRCDIR:panda/src/pipeline'])
TargetAdd('libp3pipeline_igate.obj', input='libp3pipeline.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/linmath/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/linmath', 'BUILDING:PANDA']
TargetAdd('p3linmath_composite1.obj', opts=OPTS, input='p3linmath_composite1.cxx')
TargetAdd('p3linmath_composite2.obj', opts=OPTS, input='p3linmath_composite2.cxx')
OPTS=['DIR:panda/src/linmath']
IGATEFILES=GetDirectoryContents('panda/src/linmath', ["*.h", "*_composite*.cxx"])
for ifile in IGATEFILES[:]:
if "_src." in ifile:
IGATEFILES.remove(ifile)
IGATEFILES.remove('cast_to_double.h')
IGATEFILES.remove('lmat_ops.h')
IGATEFILES.remove('cast_to_float.h')
TargetAdd('libp3linmath.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3linmath.in', opts=['IMOD:panda3d.core', 'ILIB:libp3linmath', 'SRCDIR:panda/src/linmath'])
TargetAdd('libp3linmath_igate.obj', input='libp3linmath.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/putil/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/putil', 'BUILDING:PANDA', 'ZLIB']
TargetAdd('p3putil_composite1.obj', opts=OPTS, input='p3putil_composite1.cxx')
TargetAdd('p3putil_composite2.obj', opts=OPTS, input='p3putil_composite2.cxx')
OPTS=['DIR:panda/src/putil', 'ZLIB']
IGATEFILES=GetDirectoryContents('panda/src/putil', ["*.h", "*_composite*.cxx"])
IGATEFILES.remove("test_bam.h")
TargetAdd('libp3putil.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3putil.in', opts=['IMOD:panda3d.core', 'ILIB:libp3putil', 'SRCDIR:panda/src/putil'])
TargetAdd('libp3putil_igate.obj', input='libp3putil.in', opts=["DEPENDENCYONLY"])
TargetAdd('p3putil_typedWritable_ext.obj', opts=OPTS, input='typedWritable_ext.cxx')
TargetAdd('p3putil_pythonCallbackObject.obj', opts=OPTS, input='pythonCallbackObject.cxx')
#
# DIRECTORY: panda/src/audio/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/audio', 'BUILDING:PANDA']
TargetAdd('p3audio_composite1.obj', opts=OPTS, input='p3audio_composite1.cxx')
OPTS=['DIR:panda/src/audio']
IGATEFILES=["audio.h"]
TargetAdd('libp3audio.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3audio.in', opts=['IMOD:panda3d.core', 'ILIB:libp3audio', 'SRCDIR:panda/src/audio'])
TargetAdd('libp3audio_igate.obj', input='libp3audio.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/event/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/event', 'BUILDING:PANDA']
TargetAdd('p3event_composite1.obj', opts=OPTS, input='p3event_composite1.cxx')
TargetAdd('p3event_composite2.obj', opts=OPTS, input='p3event_composite2.cxx')
OPTS=['DIR:panda/src/event']
TargetAdd('p3event_pythonTask.obj', opts=OPTS, input='pythonTask.cxx')
IGATEFILES=GetDirectoryContents('panda/src/event', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3event.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3event.in', opts=['IMOD:panda3d.core', 'ILIB:libp3event', 'SRCDIR:panda/src/event'])
TargetAdd('libp3event_igate.obj', input='libp3event.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/mathutil/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/mathutil', 'BUILDING:PANDA', 'FFTW']
TargetAdd('p3mathutil_composite1.obj', opts=OPTS, input='p3mathutil_composite1.cxx')
TargetAdd('p3mathutil_composite2.obj', opts=OPTS, input='p3mathutil_composite2.cxx')
OPTS=['DIR:panda/src/mathutil', 'FFTW']
IGATEFILES=GetDirectoryContents('panda/src/mathutil', ["*.h", "*_composite*.cxx"])
for ifile in IGATEFILES[:]:
if "_src." in ifile:
IGATEFILES.remove(ifile)
TargetAdd('libp3mathutil.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3mathutil.in', opts=['IMOD:panda3d.core', 'ILIB:libp3mathutil', 'SRCDIR:panda/src/mathutil'])
TargetAdd('libp3mathutil_igate.obj', input='libp3mathutil.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/gsgbase/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/gsgbase', 'BUILDING:PANDA']
TargetAdd('p3gsgbase_composite1.obj', opts=OPTS, input='p3gsgbase_composite1.cxx')
OPTS=['DIR:panda/src/gsgbase']
IGATEFILES=GetDirectoryContents('panda/src/gsgbase', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3gsgbase.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3gsgbase.in', opts=['IMOD:panda3d.core', 'ILIB:libp3gsgbase', 'SRCDIR:panda/src/gsgbase'])
TargetAdd('libp3gsgbase_igate.obj', input='libp3gsgbase.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/pnmimage/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/pnmimage', 'BUILDING:PANDA', 'ZLIB']
TargetAdd('p3pnmimage_composite1.obj', opts=OPTS, input='p3pnmimage_composite1.cxx')
TargetAdd('p3pnmimage_composite2.obj', opts=OPTS, input='p3pnmimage_composite2.cxx')
TargetAdd('p3pnmimage_convert_srgb_sse2.obj', opts=OPTS+['SSE2'], input='convert_srgb_sse2.cxx')
OPTS=['DIR:panda/src/pnmimage', 'ZLIB']
IGATEFILES=GetDirectoryContents('panda/src/pnmimage', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3pnmimage.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3pnmimage.in', opts=['IMOD:panda3d.core', 'ILIB:libp3pnmimage', 'SRCDIR:panda/src/pnmimage'])
TargetAdd('libp3pnmimage_igate.obj', input='libp3pnmimage.in', opts=["DEPENDENCYONLY"])
TargetAdd('p3pnmimage_pfmFile_ext.obj', opts=OPTS, input='pfmFile_ext.cxx')
#
# DIRECTORY: panda/src/nativenet/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/nativenet', 'OPENSSL', 'BUILDING:PANDA']
TargetAdd('p3nativenet_composite1.obj', opts=OPTS, input='p3nativenet_composite1.cxx')
OPTS=['DIR:panda/src/nativenet', 'OPENSSL']
IGATEFILES=GetDirectoryContents('panda/src/nativenet', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3nativenet.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3nativenet.in', opts=['IMOD:panda3d.core', 'ILIB:libp3nativenet', 'SRCDIR:panda/src/nativenet'])
TargetAdd('libp3nativenet_igate.obj', input='libp3nativenet.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/net/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/net', 'BUILDING:PANDA']
TargetAdd('p3net_composite1.obj', opts=OPTS, input='p3net_composite1.cxx')
TargetAdd('p3net_composite2.obj', opts=OPTS, input='p3net_composite2.cxx')
OPTS=['DIR:panda/src/net']
IGATEFILES=GetDirectoryContents('panda/src/net', ["*.h", "*_composite*.cxx"])
IGATEFILES.remove("datagram_ui.h")
TargetAdd('libp3net.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3net.in', opts=['IMOD:panda3d.core', 'ILIB:libp3net', 'SRCDIR:panda/src/net'])
TargetAdd('libp3net_igate.obj', input='libp3net.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/pstatclient/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/pstatclient', 'BUILDING:PANDA']
TargetAdd('p3pstatclient_composite1.obj', opts=OPTS, input='p3pstatclient_composite1.cxx')
TargetAdd('p3pstatclient_composite2.obj', opts=OPTS, input='p3pstatclient_composite2.cxx')
OPTS=['DIR:panda/src/pstatclient']
IGATEFILES=GetDirectoryContents('panda/src/pstatclient', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3pstatclient.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3pstatclient.in', opts=['IMOD:panda3d.core', 'ILIB:libp3pstatclient', 'SRCDIR:panda/src/pstatclient'])
TargetAdd('libp3pstatclient_igate.obj', input='libp3pstatclient.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/gobj/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/gobj', 'BUILDING:PANDA', 'NVIDIACG', 'ZLIB', 'SQUISH']
TargetAdd('p3gobj_composite1.obj', opts=OPTS, input='p3gobj_composite1.cxx')
TargetAdd('p3gobj_composite2.obj', opts=OPTS, input='p3gobj_composite2.cxx')
OPTS=['DIR:panda/src/gobj', 'NVIDIACG', 'ZLIB', 'SQUISH']
IGATEFILES=GetDirectoryContents('panda/src/gobj', ["*.h", "*_composite*.cxx"])
if ("cgfx_states.h" in IGATEFILES): IGATEFILES.remove("cgfx_states.h")
TargetAdd('libp3gobj.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3gobj.in', opts=['IMOD:panda3d.core', 'ILIB:libp3gobj', 'SRCDIR:panda/src/gobj'])
TargetAdd('libp3gobj_igate.obj', input='libp3gobj.in', opts=["DEPENDENCYONLY"])
TargetAdd('p3gobj_ext_composite.obj', opts=OPTS, input='p3gobj_ext_composite.cxx')
#
# DIRECTORY: panda/src/pgraphnodes/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/pgraphnodes', 'BUILDING:PANDA']
TargetAdd('p3pgraphnodes_composite1.obj', opts=OPTS, input='p3pgraphnodes_composite1.cxx')
TargetAdd('p3pgraphnodes_composite2.obj', opts=OPTS, input='p3pgraphnodes_composite2.cxx')
OPTS=['DIR:panda/src/pgraphnodes']
IGATEFILES=GetDirectoryContents('panda/src/pgraphnodes', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3pgraphnodes.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3pgraphnodes.in', opts=['IMOD:panda3d.core', 'ILIB:libp3pgraphnodes', 'SRCDIR:panda/src/pgraphnodes'])
TargetAdd('libp3pgraphnodes_igate.obj', input='libp3pgraphnodes.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/pgraph/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/pgraph', 'BUILDING:PANDA']
TargetAdd('p3pgraph_nodePath.obj', opts=OPTS, input='nodePath.cxx')
TargetAdd('p3pgraph_composite1.obj', opts=OPTS, input='p3pgraph_composite1.cxx')
TargetAdd('p3pgraph_composite2.obj', opts=OPTS, input='p3pgraph_composite2.cxx')
TargetAdd('p3pgraph_composite3.obj', opts=OPTS, input='p3pgraph_composite3.cxx')
TargetAdd('p3pgraph_composite4.obj', opts=OPTS, input='p3pgraph_composite4.cxx')
OPTS=['DIR:panda/src/pgraph']
IGATEFILES=GetDirectoryContents('panda/src/pgraph', ["*.h", "nodePath.cxx", "*_composite*.cxx"])
TargetAdd('libp3pgraph.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3pgraph.in', opts=['IMOD:panda3d.core', 'ILIB:libp3pgraph', 'SRCDIR:panda/src/pgraph'])
TargetAdd('libp3pgraph_igate.obj', input='libp3pgraph.in', opts=["DEPENDENCYONLY","BIGOBJ"])
TargetAdd('p3pgraph_ext_composite.obj', opts=OPTS, input='p3pgraph_ext_composite.cxx')
#
# DIRECTORY: panda/src/cull/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/cull', 'BUILDING:PANDA']
TargetAdd('p3cull_composite1.obj', opts=OPTS, input='p3cull_composite1.cxx')
TargetAdd('p3cull_composite2.obj', opts=OPTS, input='p3cull_composite2.cxx')
OPTS=['DIR:panda/src/cull']
IGATEFILES=GetDirectoryContents('panda/src/cull', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3cull.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3cull.in', opts=['IMOD:panda3d.core', 'ILIB:libp3cull', 'SRCDIR:panda/src/cull'])
TargetAdd('libp3cull_igate.obj', input='libp3cull.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/chan/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/chan', 'BUILDING:PANDA']
TargetAdd('p3chan_composite1.obj', opts=OPTS, input='p3chan_composite1.cxx')
TargetAdd('p3chan_composite2.obj', opts=OPTS, input='p3chan_composite2.cxx')
OPTS=['DIR:panda/src/chan']
IGATEFILES=GetDirectoryContents('panda/src/chan', ["*.h", "*_composite*.cxx"])
IGATEFILES.remove('movingPart.h')
IGATEFILES.remove('animChannelFixed.h')
TargetAdd('libp3chan.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3chan.in', opts=['IMOD:panda3d.core', 'ILIB:libp3chan', 'SRCDIR:panda/src/chan'])
TargetAdd('libp3chan_igate.obj', input='libp3chan.in', opts=["DEPENDENCYONLY"])
# DIRECTORY: panda/src/char/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/char', 'BUILDING:PANDA']
TargetAdd('p3char_composite1.obj', opts=OPTS, input='p3char_composite1.cxx')
TargetAdd('p3char_composite2.obj', opts=OPTS, input='p3char_composite2.cxx')
OPTS=['DIR:panda/src/char']
IGATEFILES=GetDirectoryContents('panda/src/char', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3char.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3char.in', opts=['IMOD:panda3d.core', 'ILIB:libp3char', 'SRCDIR:panda/src/char'])
TargetAdd('libp3char_igate.obj', input='libp3char.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/dgraph/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/dgraph', 'BUILDING:PANDA']
TargetAdd('p3dgraph_composite1.obj', opts=OPTS, input='p3dgraph_composite1.cxx')
TargetAdd('p3dgraph_composite2.obj', opts=OPTS, input='p3dgraph_composite2.cxx')
OPTS=['DIR:panda/src/dgraph']
IGATEFILES=GetDirectoryContents('panda/src/dgraph', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3dgraph.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3dgraph.in', opts=['IMOD:panda3d.core', 'ILIB:libp3dgraph', 'SRCDIR:panda/src/dgraph'])
TargetAdd('libp3dgraph_igate.obj', input='libp3dgraph.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/display/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/display', 'BUILDING:PANDA']
TargetAdd('p3display_composite1.obj', opts=OPTS, input='p3display_composite1.cxx')
TargetAdd('p3display_composite2.obj', opts=OPTS, input='p3display_composite2.cxx')
OPTS=['DIR:panda/src/display']
IGATEFILES=GetDirectoryContents('panda/src/display', ["*.h", "*_composite*.cxx"])
IGATEFILES.remove("renderBuffer.h")
TargetAdd('libp3display.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3display.in', opts=['IMOD:panda3d.core', 'ILIB:libp3display', 'SRCDIR:panda/src/display'])
TargetAdd('libp3display_igate.obj', input='libp3display.in', opts=["DEPENDENCYONLY"])
TargetAdd('p3display_graphicsStateGuardian_ext.obj', opts=OPTS, input='graphicsStateGuardian_ext.cxx')
TargetAdd('p3display_graphicsWindow_ext.obj', opts=OPTS, input='graphicsWindow_ext.cxx')
TargetAdd('p3display_pythonGraphicsWindowProc.obj', opts=OPTS, input='pythonGraphicsWindowProc.cxx')
if RTDIST and GetTarget() == 'darwin':
OPTS=['DIR:panda/src/display']
TargetAdd('subprocessWindowBuffer.obj', opts=OPTS, input='subprocessWindowBuffer.cxx')
TargetAdd('libp3subprocbuffer.ilb', input='subprocessWindowBuffer.obj')
#
# DIRECTORY: panda/src/device/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/device', 'BUILDING:PANDA']
TargetAdd('p3device_composite1.obj', opts=OPTS, input='p3device_composite1.cxx')
TargetAdd('p3device_composite2.obj', opts=OPTS, input='p3device_composite2.cxx')
OPTS=['DIR:panda/src/device']
IGATEFILES=GetDirectoryContents('panda/src/device', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3device.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3device.in', opts=['IMOD:panda3d.core', 'ILIB:libp3device', 'SRCDIR:panda/src/device'])
TargetAdd('libp3device_igate.obj', input='libp3device.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/pnmtext/
#
if (PkgSkip("FREETYPE")==0 and not RUNTIME):
OPTS=['DIR:panda/src/pnmtext', 'BUILDING:PANDA', 'FREETYPE']
TargetAdd('p3pnmtext_composite1.obj', opts=OPTS, input='p3pnmtext_composite1.cxx')
OPTS=['DIR:panda/src/pnmtext', 'FREETYPE']
IGATEFILES=GetDirectoryContents('panda/src/pnmtext', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3pnmtext.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3pnmtext.in', opts=['IMOD:panda3d.core', 'ILIB:libp3pnmtext', 'SRCDIR:panda/src/pnmtext'])
TargetAdd('libp3pnmtext_igate.obj', input='libp3pnmtext.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/text/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/text', 'BUILDING:PANDA', 'ZLIB', 'FREETYPE']
TargetAdd('p3text_composite1.obj', opts=OPTS, input='p3text_composite1.cxx')
TargetAdd('p3text_composite2.obj', opts=OPTS, input='p3text_composite2.cxx')
OPTS=['DIR:panda/src/text', 'ZLIB', 'FREETYPE']
IGATEFILES=GetDirectoryContents('panda/src/text', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3text.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3text.in', opts=['IMOD:panda3d.core', 'ILIB:libp3text', 'SRCDIR:panda/src/text'])
TargetAdd('libp3text_igate.obj', input='libp3text.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/movies/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/movies', 'BUILDING:PANDA', 'VORBIS']
TargetAdd('p3movies_composite1.obj', opts=OPTS, input='p3movies_composite1.cxx')
OPTS=['DIR:panda/src/movies', 'VORBIS']
IGATEFILES=GetDirectoryContents('panda/src/movies', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3movies.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3movies.in', opts=['IMOD:panda3d.core', 'ILIB:libp3movies', 'SRCDIR:panda/src/movies'])
TargetAdd('libp3movies_igate.obj', input='libp3movies.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/grutil/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/grutil', 'BUILDING:PANDA']
TargetAdd('p3grutil_multitexReducer.obj', opts=OPTS, input='multitexReducer.cxx')
TargetAdd('p3grutil_composite1.obj', opts=OPTS, input='p3grutil_composite1.cxx')
TargetAdd('p3grutil_composite2.obj', opts=OPTS, input='p3grutil_composite2.cxx')
OPTS=['DIR:panda/src/grutil']
IGATEFILES=GetDirectoryContents('panda/src/grutil', ["*.h", "*_composite*.cxx"])
if 'convexHull.h' in IGATEFILES: IGATEFILES.remove('convexHull.h')
TargetAdd('libp3grutil.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3grutil.in', opts=['IMOD:panda3d.core', 'ILIB:libp3grutil', 'SRCDIR:panda/src/grutil'])
TargetAdd('libp3grutil_igate.obj', input='libp3grutil.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/tform/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/tform', 'BUILDING:PANDA']
TargetAdd('p3tform_composite1.obj', opts=OPTS, input='p3tform_composite1.cxx')
TargetAdd('p3tform_composite2.obj', opts=OPTS, input='p3tform_composite2.cxx')
OPTS=['DIR:panda/src/tform']
IGATEFILES=GetDirectoryContents('panda/src/tform', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3tform.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3tform.in', opts=['IMOD:panda3d.core', 'ILIB:libp3tform', 'SRCDIR:panda/src/tform'])
TargetAdd('libp3tform_igate.obj', input='libp3tform.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/collide/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/collide', 'BUILDING:PANDA']
TargetAdd('p3collide_composite1.obj', opts=OPTS, input='p3collide_composite1.cxx')
TargetAdd('p3collide_composite2.obj', opts=OPTS, input='p3collide_composite2.cxx')
OPTS=['DIR:panda/src/collide']
IGATEFILES=GetDirectoryContents('panda/src/collide', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3collide.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3collide.in', opts=['IMOD:panda3d.core', 'ILIB:libp3collide', 'SRCDIR:panda/src/collide'])
TargetAdd('libp3collide_igate.obj', input='libp3collide.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/parametrics/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/parametrics', 'BUILDING:PANDA']
TargetAdd('p3parametrics_composite1.obj', opts=OPTS, input='p3parametrics_composite1.cxx')
TargetAdd('p3parametrics_composite2.obj', opts=OPTS, input='p3parametrics_composite2.cxx')
OPTS=['DIR:panda/src/parametrics']
IGATEFILES=GetDirectoryContents('panda/src/parametrics', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3parametrics.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3parametrics.in', opts=['IMOD:panda3d.core', 'ILIB:libp3parametrics', 'SRCDIR:panda/src/parametrics'])
TargetAdd('libp3parametrics_igate.obj', input='libp3parametrics.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/pgui/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/pgui', 'BUILDING:PANDA']
TargetAdd('p3pgui_composite1.obj', opts=OPTS, input='p3pgui_composite1.cxx')
TargetAdd('p3pgui_composite2.obj', opts=OPTS, input='p3pgui_composite2.cxx')
OPTS=['DIR:panda/src/pgui']
IGATEFILES=GetDirectoryContents('panda/src/pgui', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3pgui.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3pgui.in', opts=['IMOD:panda3d.core', 'ILIB:libp3pgui', 'SRCDIR:panda/src/pgui'])
TargetAdd('libp3pgui_igate.obj', input='libp3pgui.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/pnmimagetypes/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/pnmimagetypes', 'DIR:panda/src/pnmimage', 'BUILDING:PANDA', 'PNG', 'ZLIB', 'JPEG', 'TIFF']
TargetAdd('p3pnmimagetypes_composite1.obj', opts=OPTS, input='p3pnmimagetypes_composite1.cxx')
TargetAdd('p3pnmimagetypes_composite2.obj', opts=OPTS, input='p3pnmimagetypes_composite2.cxx')
#
# DIRECTORY: panda/src/recorder/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/recorder', 'BUILDING:PANDA']
TargetAdd('p3recorder_composite1.obj', opts=OPTS, input='p3recorder_composite1.cxx')
TargetAdd('p3recorder_composite2.obj', opts=OPTS, input='p3recorder_composite2.cxx')
OPTS=['DIR:panda/src/recorder']
IGATEFILES=GetDirectoryContents('panda/src/recorder', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3recorder.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3recorder.in', opts=['IMOD:panda3d.core', 'ILIB:libp3recorder', 'SRCDIR:panda/src/recorder'])
TargetAdd('libp3recorder_igate.obj', input='libp3recorder.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/dxml/
#
DefSymbol("TINYXML", "TIXML_USE_STL", "")
OPTS=['DIR:panda/src/dxml', 'TINYXML']
TargetAdd('tinyxml_composite1.obj', opts=OPTS, input='tinyxml_composite1.cxx')
TargetAdd('libp3tinyxml.ilb', input='tinyxml_composite1.obj')
if (not RUNTIME):
OPTS=['DIR:panda/src/dxml', 'BUILDING:PANDA', 'TINYXML']
TargetAdd('p3dxml_composite1.obj', opts=OPTS, input='p3dxml_composite1.cxx')
OPTS=['DIR:panda/src/dxml', 'TINYXML']
IGATEFILES=GetDirectoryContents('panda/src/dxml', ["*.h", "p3dxml_composite1.cxx"])
TargetAdd('libp3dxml.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3dxml.in', opts=['IMOD:panda3d.core', 'ILIB:libp3dxml', 'SRCDIR:panda/src/dxml'])
TargetAdd('libp3dxml_igate.obj', input='libp3dxml.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/metalibs/panda/
#
if (not RUNTIME):
OPTS=['DIR:panda/metalibs/panda', 'BUILDING:PANDA', 'JPEG', 'PNG',
'TIFF', 'ZLIB', 'OPENSSL', 'FREETYPE', 'FFTW', 'ADVAPI', 'WINSOCK2',
'SQUISH', 'NVIDIACG', 'VORBIS', 'WINUSER', 'WINMM', 'WINGDI', 'IPHLPAPI']
TargetAdd('panda_panda.obj', opts=OPTS, input='panda.cxx')
TargetAdd('libpanda.dll', input='panda_panda.obj')
TargetAdd('libpanda.dll', input='p3recorder_composite1.obj')
TargetAdd('libpanda.dll', input='p3recorder_composite2.obj')
TargetAdd('libpanda.dll', input='p3pgraphnodes_composite1.obj')
TargetAdd('libpanda.dll', input='p3pgraphnodes_composite2.obj')
TargetAdd('libpanda.dll', input='p3pgraph_nodePath.obj')
TargetAdd('libpanda.dll', input='p3pgraph_composite1.obj')
TargetAdd('libpanda.dll', input='p3pgraph_composite2.obj')
TargetAdd('libpanda.dll', input='p3pgraph_composite3.obj')
TargetAdd('libpanda.dll', input='p3pgraph_composite4.obj')
TargetAdd('libpanda.dll', input='p3cull_composite1.obj')
TargetAdd('libpanda.dll', input='p3cull_composite2.obj')
TargetAdd('libpanda.dll', input='p3movies_composite1.obj')
TargetAdd('libpanda.dll', input='p3grutil_multitexReducer.obj')
TargetAdd('libpanda.dll', input='p3grutil_composite1.obj')
TargetAdd('libpanda.dll', input='p3grutil_composite2.obj')
TargetAdd('libpanda.dll', input='p3chan_composite1.obj')
TargetAdd('libpanda.dll', input='p3chan_composite2.obj')
TargetAdd('libpanda.dll', input='p3pstatclient_composite1.obj')
TargetAdd('libpanda.dll', input='p3pstatclient_composite2.obj')
TargetAdd('libpanda.dll', input='p3char_composite1.obj')
TargetAdd('libpanda.dll', input='p3char_composite2.obj')
TargetAdd('libpanda.dll', input='p3collide_composite1.obj')
TargetAdd('libpanda.dll', input='p3collide_composite2.obj')
TargetAdd('libpanda.dll', input='p3device_composite1.obj')
TargetAdd('libpanda.dll', input='p3device_composite2.obj')
TargetAdd('libpanda.dll', input='p3dgraph_composite1.obj')
TargetAdd('libpanda.dll', input='p3dgraph_composite2.obj')
TargetAdd('libpanda.dll', input='p3display_composite1.obj')
TargetAdd('libpanda.dll', input='p3display_composite2.obj')
TargetAdd('libpanda.dll', input='p3pipeline_composite1.obj')
TargetAdd('libpanda.dll', input='p3pipeline_composite2.obj')
TargetAdd('libpanda.dll', input='p3pipeline_contextSwitch.obj')
TargetAdd('libpanda.dll', input='p3event_composite1.obj')
TargetAdd('libpanda.dll', input='p3event_composite2.obj')
TargetAdd('libpanda.dll', input='p3gobj_composite1.obj')
TargetAdd('libpanda.dll', input='p3gobj_composite2.obj')
TargetAdd('libpanda.dll', input='p3gsgbase_composite1.obj')
TargetAdd('libpanda.dll', input='p3linmath_composite1.obj')
TargetAdd('libpanda.dll', input='p3linmath_composite2.obj')
TargetAdd('libpanda.dll', input='p3mathutil_composite1.obj')
TargetAdd('libpanda.dll', input='p3mathutil_composite2.obj')
TargetAdd('libpanda.dll', input='p3parametrics_composite1.obj')
TargetAdd('libpanda.dll', input='p3parametrics_composite2.obj')
TargetAdd('libpanda.dll', input='p3pnmimagetypes_composite1.obj')
TargetAdd('libpanda.dll', input='p3pnmimagetypes_composite2.obj')
TargetAdd('libpanda.dll', input='p3pnmimage_composite1.obj')
TargetAdd('libpanda.dll', input='p3pnmimage_composite2.obj')
TargetAdd('libpanda.dll', input='p3pnmimage_convert_srgb_sse2.obj')
TargetAdd('libpanda.dll', input='p3text_composite1.obj')
TargetAdd('libpanda.dll', input='p3text_composite2.obj')
TargetAdd('libpanda.dll', input='p3tform_composite1.obj')
TargetAdd('libpanda.dll', input='p3tform_composite2.obj')
TargetAdd('libpanda.dll', input='p3putil_composite1.obj')
TargetAdd('libpanda.dll', input='p3putil_composite2.obj')
TargetAdd('libpanda.dll', input='p3audio_composite1.obj')
TargetAdd('libpanda.dll', input='p3pgui_composite1.obj')
TargetAdd('libpanda.dll', input='p3pgui_composite2.obj')
TargetAdd('libpanda.dll', input='p3net_composite1.obj')
TargetAdd('libpanda.dll', input='p3net_composite2.obj')
TargetAdd('libpanda.dll', input='p3nativenet_composite1.obj')
TargetAdd('libpanda.dll', input='p3pandabase_pandabase.obj')
TargetAdd('libpanda.dll', input='libpandaexpress.dll')
TargetAdd('libpanda.dll', input='p3dxml_composite1.obj')
TargetAdd('libpanda.dll', input='libp3dtoolconfig.dll')
TargetAdd('libpanda.dll', input='libp3dtool.dll')
if PkgSkip("FREETYPE")==0:
TargetAdd('libpanda.dll', input="p3pnmtext_composite1.obj")
TargetAdd('libpanda.dll', dep='dtool_have_freetype.dat')
TargetAdd('libpanda.dll', opts=OPTS)
TargetAdd('core_module.obj', input='libp3downloader.in')
TargetAdd('core_module.obj', input='libp3express.in')
TargetAdd('core_module.obj', input='libp3recorder.in')
TargetAdd('core_module.obj', input='libp3pgraphnodes.in')
TargetAdd('core_module.obj', input='libp3pgraph.in')
TargetAdd('core_module.obj', input='libp3cull.in')
TargetAdd('core_module.obj', input='libp3grutil.in')
TargetAdd('core_module.obj', input='libp3chan.in')
TargetAdd('core_module.obj', input='libp3pstatclient.in')
TargetAdd('core_module.obj', input='libp3char.in')
TargetAdd('core_module.obj', input='libp3collide.in')
TargetAdd('core_module.obj', input='libp3device.in')
TargetAdd('core_module.obj', input='libp3dgraph.in')
TargetAdd('core_module.obj', input='libp3display.in')
TargetAdd('core_module.obj', input='libp3pipeline.in')
TargetAdd('core_module.obj', input='libp3event.in')
TargetAdd('core_module.obj', input='libp3gobj.in')
TargetAdd('core_module.obj', input='libp3gsgbase.in')
TargetAdd('core_module.obj', input='libp3linmath.in')
TargetAdd('core_module.obj', input='libp3mathutil.in')
TargetAdd('core_module.obj', input='libp3parametrics.in')
TargetAdd('core_module.obj', input='libp3pnmimage.in')
TargetAdd('core_module.obj', input='libp3text.in')
TargetAdd('core_module.obj', input='libp3tform.in')
TargetAdd('core_module.obj', input='libp3putil.in')
TargetAdd('core_module.obj', input='libp3audio.in')
TargetAdd('core_module.obj', input='libp3nativenet.in')
TargetAdd('core_module.obj', input='libp3net.in')
TargetAdd('core_module.obj', input='libp3pgui.in')
TargetAdd('core_module.obj', input='libp3movies.in')
TargetAdd('core_module.obj', input='libp3dxml.in')
if PkgSkip("FREETYPE")==0:
TargetAdd('core_module.obj', input='libp3pnmtext.in')
TargetAdd('core_module.obj', opts=['IMOD:panda3d._core', 'ILIB:_core'])
TargetAdd('_core.pyd', input='libp3downloader_igate.obj')
TargetAdd('_core.pyd', input='p3express_ext_composite.obj')
TargetAdd('_core.pyd', input='libp3express_igate.obj')
TargetAdd('_core.pyd', input='libp3recorder_igate.obj')
TargetAdd('_core.pyd', input='libp3pgraphnodes_igate.obj')
TargetAdd('_core.pyd', input='libp3pgraph_igate.obj')
TargetAdd('_core.pyd', input='libp3movies_igate.obj')
TargetAdd('_core.pyd', input='libp3grutil_igate.obj')
TargetAdd('_core.pyd', input='libp3chan_igate.obj')
TargetAdd('_core.pyd', input='libp3pstatclient_igate.obj')
TargetAdd('_core.pyd', input='libp3char_igate.obj')
TargetAdd('_core.pyd', input='libp3collide_igate.obj')
TargetAdd('_core.pyd', input='libp3device_igate.obj')
TargetAdd('_core.pyd', input='libp3dgraph_igate.obj')
TargetAdd('_core.pyd', input='libp3display_igate.obj')
TargetAdd('_core.pyd', input='libp3pipeline_igate.obj')
TargetAdd('_core.pyd', input='libp3event_igate.obj')
TargetAdd('_core.pyd', input='libp3gobj_igate.obj')
TargetAdd('_core.pyd', input='libp3gsgbase_igate.obj')
TargetAdd('_core.pyd', input='libp3linmath_igate.obj')
TargetAdd('_core.pyd', input='libp3mathutil_igate.obj')
TargetAdd('_core.pyd', input='libp3parametrics_igate.obj')
TargetAdd('_core.pyd', input='libp3pnmimage_igate.obj')
TargetAdd('_core.pyd', input='libp3text_igate.obj')
TargetAdd('_core.pyd', input='libp3tform_igate.obj')
TargetAdd('_core.pyd', input='libp3putil_igate.obj')
TargetAdd('_core.pyd', input='libp3audio_igate.obj')
TargetAdd('_core.pyd', input='libp3pgui_igate.obj')
TargetAdd('_core.pyd', input='libp3net_igate.obj')
TargetAdd('_core.pyd', input='libp3nativenet_igate.obj')
TargetAdd('_core.pyd', input='libp3dxml_igate.obj')
if PkgSkip("FREETYPE")==0:
TargetAdd('_core.pyd', input="libp3pnmtext_igate.obj")
TargetAdd('_core.pyd', input='p3putil_typedWritable_ext.obj')
TargetAdd('_core.pyd', input='p3putil_pythonCallbackObject.obj')
TargetAdd('_core.pyd', input='p3pnmimage_pfmFile_ext.obj')
TargetAdd('_core.pyd', input='p3event_pythonTask.obj')
TargetAdd('_core.pyd', input='p3gobj_ext_composite.obj')
TargetAdd('_core.pyd', input='p3pgraph_ext_composite.obj')
TargetAdd('_core.pyd', input='p3display_graphicsStateGuardian_ext.obj')
TargetAdd('_core.pyd', input='p3display_graphicsWindow_ext.obj')
TargetAdd('_core.pyd', input='p3display_pythonGraphicsWindowProc.obj')
TargetAdd('_core.pyd', input='core_module.obj')
if not GetLinkAllStatic():
TargetAdd('core.pyd', input='libp3tinyxml.ilb')
TargetAdd('_core.pyd', input='libp3interrogatedb.dll')
TargetAdd('_core.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('_core.pyd', opts=['PYTHON', 'WINSOCK2'])
OPTS=['DIR:direct/src/extensions_native']
TargetAdd('panda3d/core.py', input='_core.pyd')
TargetAdd('panda3d/core.py', opts=OPTS, input='core_extensions.py')
TargetAdd('panda3d/core.py', opts=OPTS, input='NodePath_extensions.py')
TargetAdd('panda3d/core.py', opts=OPTS, input='Mat3_extensions.py')
TargetAdd('panda3d/core.py', opts=OPTS, input='VBase3_extensions.py')
TargetAdd('panda3d/core.py', opts=OPTS, input='VBase4_extensions.py')
TargetAdd('panda3d/core.py', opts=OPTS, input='HTTPChannel_extensions.py')
#
# DIRECTORY: panda/src/vision/
#
if (PkgSkip("VISION") == 0) and (not RUNTIME):
OPTS=['DIR:panda/src/vision', 'BUILDING:VISION', 'ARTOOLKIT', 'OPENCV', 'DX9', 'DIRECTCAM', 'JPEG', 'EXCEPTIONS']
TargetAdd('p3vision_composite1.obj', opts=OPTS, input='p3vision_composite1.cxx')
TargetAdd('libp3vision.dll', input='p3vision_composite1.obj')
TargetAdd('libp3vision.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3vision.dll', opts=OPTS)
OPTS=['DIR:panda/src/vision', 'ARTOOLKIT', 'OPENCV', 'DX9', 'DIRECTCAM', 'JPEG', 'EXCEPTIONS']
IGATEFILES=GetDirectoryContents('panda/src/vision', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3vision.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3vision.in', opts=['IMOD:panda3d.vision', 'ILIB:libp3vision', 'SRCDIR:panda/src/vision'])
TargetAdd('libp3vision_igate.obj', input='libp3vision.in', opts=["DEPENDENCYONLY"])
TargetAdd('vision_module.obj', input='libp3vision.in')
TargetAdd('vision_module.obj', opts=OPTS)
TargetAdd('vision_module.obj', opts=['IMOD:panda3d.vision', 'ILIB:vision', 'IMPORT:panda3d._core'])
TargetAdd('vision.pyd', input='vision_module.obj')
TargetAdd('vision.pyd', input='libp3vision_igate.obj')
TargetAdd('vision.pyd', input='libp3vision.dll')
TargetAdd('vision.pyd', input='libp3interrogatedb.dll')
TargetAdd('vision.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('vision.pyd', opts=['PYTHON'])
#
# DIRECTORY: panda/src/rocket/
#
if (PkgSkip("ROCKET") == 0) and (not RUNTIME):
OPTS=['DIR:panda/src/rocket', 'BUILDING:ROCKET', 'ROCKET']
TargetAdd('p3rocket_composite1.obj', opts=OPTS, input='p3rocket_composite1.cxx')
TargetAdd('libp3rocket.dll', input='p3rocket_composite1.obj')
TargetAdd('libp3rocket.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3rocket.dll', opts=OPTS)
OPTS=['DIR:panda/src/rocket', 'ROCKET', 'RTTI', 'EXCEPTIONS']
IGATEFILES=GetDirectoryContents('panda/src/rocket', ["rocketInputHandler.h",
"rocketInputHandler.cxx", "rocketRegion.h", "rocketRegion.cxx", "rocketRegion_ext.h"])
TargetAdd('libp3rocket.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3rocket.in', opts=['IMOD:panda3d.rocket', 'ILIB:libp3rocket', 'SRCDIR:panda/src/rocket'])
TargetAdd('libp3rocket_igate.obj', input='libp3rocket.in', opts=["DEPENDENCYONLY"])
TargetAdd('p3rocket_rocketRegion_ext.obj', opts=OPTS, input='rocketRegion_ext.cxx')
TargetAdd('rocket_module.obj', input='libp3rocket.in')
TargetAdd('rocket_module.obj', opts=OPTS)
TargetAdd('rocket_module.obj', opts=['IMOD:panda3d.rocket', 'ILIB:rocket', 'IMPORT:panda3d._core'])
TargetAdd('rocket.pyd', input='rocket_module.obj')
TargetAdd('rocket.pyd', input='libp3rocket_igate.obj')
TargetAdd('rocket.pyd', input='p3rocket_rocketRegion_ext.obj')
TargetAdd('rocket.pyd', input='libp3rocket.dll')
TargetAdd('rocket.pyd', input='libp3interrogatedb.dll')
TargetAdd('rocket.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('rocket.pyd', opts=['PYTHON', 'ROCKET'])
#
# DIRECTORY: panda/src/p3awesomium
#
if PkgSkip("AWESOMIUM") == 0 and not RUNTIME:
OPTS=['DIR:panda/src/awesomium', 'BUILDING:PANDAAWESOMIUM', 'AWESOMIUM']
TargetAdd('pandaawesomium_composite1.obj', opts=OPTS, input='pandaawesomium_composite1.cxx')
TargetAdd('libp3awesomium.dll', input='pandaawesomium_composite1.obj')
TargetAdd('libp3awesomium.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3awesomium.dll', opts=OPTS)
OPTS=['DIR:panda/src/awesomium', 'AWESOMIUM']
IGATEFILES=GetDirectoryContents('panda/src/awesomium', ["*.h", "*_composite1.cxx"])
TargetAdd('libp3awesomium.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3awesomium.in', opts=['IMOD:panda3d.awesomium', 'ILIB:libp3awesomium', 'SRCDIR:panda/src/awesomium'])
TargetAdd('libp3awesomium_igate.obj', input='libp3awesomium.in', opts=["DEPENDENCYONLY"])
TargetAdd('awesomium_module.obj', input='libp3awesomium.in')
TargetAdd('awesomium_module.obj', opts=OPTS)
TargetAdd('awesomium_module.obj', opts=['IMOD:panda3d.awesomium', 'ILIB:awesomium', 'IMPORT:panda3d._core'])
TargetAdd('awesomium.pyd', input='awesomium_module.obj')
TargetAdd('awesomium.pyd', input='libp3awesomium_igate.obj')
TargetAdd('awesomium.pyd', input='libp3awesomium.dll')
TargetAdd('awesomium.pyd', input='libp3interrogatedb.dll')
TargetAdd('awesomium.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('awesomium.pyd', opts=['PYTHON'])
#
# DIRECTORY: panda/src/p3skel
#
if (PkgSkip('SKEL')==0) and (not RUNTIME):
OPTS=['DIR:panda/src/skel', 'BUILDING:PANDASKEL', 'ADVAPI']
TargetAdd('p3skel_composite1.obj', opts=OPTS, input='p3skel_composite1.cxx')
OPTS=['DIR:panda/src/skel', 'ADVAPI']
IGATEFILES=GetDirectoryContents("panda/src/skel", ["*.h", "*_composite*.cxx"])
TargetAdd('libp3skel.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3skel.in', opts=['IMOD:panda3d.skel', 'ILIB:libp3skel', 'SRCDIR:panda/src/skel'])
TargetAdd('libp3skel_igate.obj', input='libp3skel.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/p3skel
#
if (PkgSkip('SKEL')==0) and (not RUNTIME):
OPTS=['BUILDING:PANDASKEL', 'ADVAPI']
TargetAdd('libpandaskel.dll', input='p3skel_composite1.obj')
TargetAdd('libpandaskel.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandaskel.dll', opts=OPTS)
TargetAdd('skel_module.obj', input='libp3skel.in')
TargetAdd('skel_module.obj', opts=['IMOD:panda3d.skel', 'ILIB:skel', 'IMPORT:panda3d._core'])
TargetAdd('skel.pyd', input='skel_module.obj')
TargetAdd('skel.pyd', input='libp3skel_igate.obj')
TargetAdd('skel.pyd', input='libpandaskel.dll')
TargetAdd('skel.pyd', input='libp3interrogatedb.dll')
TargetAdd('skel.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('skel.pyd', opts=['PYTHON'])
#
# DIRECTORY: panda/src/distort/
#
if (PkgSkip('PANDAFX')==0) and (not RUNTIME):
OPTS=['DIR:panda/src/distort', 'BUILDING:PANDAFX']
TargetAdd('p3distort_composite1.obj', opts=OPTS, input='p3distort_composite1.cxx')
OPTS=['DIR:panda/metalibs/pandafx', 'DIR:panda/src/distort', 'NVIDIACG']
IGATEFILES=GetDirectoryContents('panda/src/distort', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3distort.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3distort.in', opts=['IMOD:panda3d.fx', 'ILIB:libp3distort', 'SRCDIR:panda/src/distort'])
TargetAdd('libp3distort_igate.obj', input='libp3distort.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/metalibs/pandafx/
#
if (PkgSkip('PANDAFX')==0) and (not RUNTIME):
OPTS=['DIR:panda/metalibs/pandafx', 'DIR:panda/src/distort', 'BUILDING:PANDAFX', 'NVIDIACG']
TargetAdd('pandafx_pandafx.obj', opts=OPTS, input='pandafx.cxx')
TargetAdd('libpandafx.dll', input='pandafx_pandafx.obj')
TargetAdd('libpandafx.dll', input='p3distort_composite1.obj')
TargetAdd('libpandafx.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandafx.dll', opts=['ADVAPI', 'NVIDIACG'])
OPTS=['DIR:panda/metalibs/pandafx', 'DIR:panda/src/distort', 'NVIDIACG']
TargetAdd('fx_module.obj', input='libp3distort.in')
TargetAdd('fx_module.obj', opts=OPTS)
TargetAdd('fx_module.obj', opts=['IMOD:panda3d.fx', 'ILIB:fx', 'IMPORT:panda3d._core'])
TargetAdd('fx.pyd', input='fx_module.obj')
TargetAdd('fx.pyd', input='libp3distort_igate.obj')
TargetAdd('fx.pyd', input='libpandafx.dll')
TargetAdd('fx.pyd', input='libp3interrogatedb.dll')
TargetAdd('fx.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('fx.pyd', opts=['PYTHON'])
#
# DIRECTORY: panda/src/vrpn/
#
if (PkgSkip("VRPN")==0 and not RUNTIME):
OPTS=['DIR:panda/src/vrpn', 'BUILDING:VRPN', 'VRPN']
TargetAdd('p3vrpn_composite1.obj', opts=OPTS, input='p3vrpn_composite1.cxx')
TargetAdd('libp3vrpn.dll', input='p3vrpn_composite1.obj')
TargetAdd('libp3vrpn.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3vrpn.dll', opts=['VRPN'])
OPTS=['DIR:panda/src/vrpn', 'VRPN']
IGATEFILES=GetDirectoryContents('panda/src/vrpn', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3vrpn.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3vrpn.in', opts=['IMOD:panda3d.vrpn', 'ILIB:libp3vrpn', 'SRCDIR:panda/src/vrpn'])
TargetAdd('libp3vrpn_igate.obj', input='libp3vrpn.in', opts=["DEPENDENCYONLY"])
TargetAdd('vrpn_module.obj', input='libp3vrpn.in')
TargetAdd('vrpn_module.obj', opts=OPTS)
TargetAdd('vrpn_module.obj', opts=['IMOD:panda3d.vrpn', 'ILIB:vrpn', 'IMPORT:panda3d._core'])
TargetAdd('vrpn.pyd', input='vrpn_module.obj')
TargetAdd('vrpn.pyd', input='libp3vrpn_igate.obj')
TargetAdd('vrpn.pyd', input='libp3vrpn.dll')
TargetAdd('vrpn.pyd', input='libp3interrogatedb.dll')
TargetAdd('vrpn.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('vrpn.pyd', opts=['PYTHON'])
#
# DIRECTORY: panda/src/ffmpeg
#
if PkgSkip("FFMPEG") == 0 and not RUNTIME:
OPTS=['DIR:panda/src/ffmpeg', 'BUILDING:FFMPEG', 'FFMPEG', 'SWSCALE', 'SWRESAMPLE']
TargetAdd('p3ffmpeg_composite1.obj', opts=OPTS, input='p3ffmpeg_composite1.cxx')
TargetAdd('libp3ffmpeg.dll', input='p3ffmpeg_composite1.obj')
TargetAdd('libp3ffmpeg.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3ffmpeg.dll', opts=OPTS)
#
# DIRECTORY: panda/src/audiotraits/
#
if PkgSkip("FMODEX") == 0 and not RUNTIME:
OPTS=['DIR:panda/src/audiotraits', 'BUILDING:FMOD_AUDIO', 'FMODEX']
TargetAdd('fmod_audio_fmod_audio_composite1.obj', opts=OPTS, input='fmod_audio_composite1.cxx')
TargetAdd('libp3fmod_audio.dll', input='fmod_audio_fmod_audio_composite1.obj')
TargetAdd('libp3fmod_audio.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3fmod_audio.dll', opts=['MODULE', 'ADVAPI', 'WINUSER', 'WINMM', 'FMODEX'])
if PkgSkip("OPENAL") == 0 and not RUNTIME:
OPTS=['DIR:panda/src/audiotraits', 'BUILDING:OPENAL_AUDIO', 'OPENAL']
TargetAdd('openal_audio_openal_audio_composite1.obj', opts=OPTS, input='openal_audio_composite1.cxx')
TargetAdd('libp3openal_audio.dll', input='openal_audio_openal_audio_composite1.obj')
TargetAdd('libp3openal_audio.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3openal_audio.dll', opts=['MODULE', 'ADVAPI', 'WINUSER', 'WINMM', 'OPENAL'])
#
# DIRECTORY: panda/src/downloadertools/
#
if (PkgSkip("OPENSSL")==0 and not RTDIST and not RUNTIME and PkgSkip("DEPLOYTOOLS")==0):
OPTS=['DIR:panda/src/downloadertools', 'OPENSSL', 'ZLIB', 'ADVAPI', 'WINSOCK2', 'WINSHELL', 'WINGDI', 'WINUSER']
TargetAdd('apply_patch_apply_patch.obj', opts=OPTS, input='apply_patch.cxx')
TargetAdd('apply_patch.exe', input=['apply_patch_apply_patch.obj'])
TargetAdd('apply_patch.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('apply_patch.exe', opts=OPTS)
TargetAdd('build_patch_build_patch.obj', opts=OPTS, input='build_patch.cxx')
TargetAdd('build_patch.exe', input=['build_patch_build_patch.obj'])
TargetAdd('build_patch.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('build_patch.exe', opts=OPTS)
if not PkgSkip("ZLIB"):
TargetAdd('check_adler_check_adler.obj', opts=OPTS, input='check_adler.cxx')
TargetAdd('check_adler.exe', input=['check_adler_check_adler.obj'])
TargetAdd('check_adler.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('check_adler.exe', opts=OPTS)
TargetAdd('check_crc_check_crc.obj', opts=OPTS, input='check_crc.cxx')
TargetAdd('check_crc.exe', input=['check_crc_check_crc.obj'])
TargetAdd('check_crc.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('check_crc.exe', opts=OPTS)
TargetAdd('check_md5_check_md5.obj', opts=OPTS, input='check_md5.cxx')
TargetAdd('check_md5.exe', input=['check_md5_check_md5.obj'])
TargetAdd('check_md5.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('check_md5.exe', opts=OPTS)
TargetAdd('pdecrypt_pdecrypt.obj', opts=OPTS, input='pdecrypt.cxx')
TargetAdd('pdecrypt.exe', input=['pdecrypt_pdecrypt.obj'])
TargetAdd('pdecrypt.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('pdecrypt.exe', opts=OPTS)
TargetAdd('pencrypt_pencrypt.obj', opts=OPTS, input='pencrypt.cxx')
TargetAdd('pencrypt.exe', input=['pencrypt_pencrypt.obj'])
TargetAdd('pencrypt.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('pencrypt.exe', opts=OPTS)
TargetAdd('show_ddb_show_ddb.obj', opts=OPTS, input='show_ddb.cxx')
TargetAdd('show_ddb.exe', input=['show_ddb_show_ddb.obj'])
TargetAdd('show_ddb.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('show_ddb.exe', opts=OPTS)
#
# DIRECTORY: panda/src/downloadertools/
#
if (PkgSkip("ZLIB")==0 and not RTDIST and not RUNTIME and PkgSkip("DEPLOYTOOLS")==0):
OPTS=['DIR:panda/src/downloadertools', 'ZLIB', 'OPENSSL', 'ADVAPI', 'WINSOCK2', 'WINSHELL', 'WINGDI', 'WINUSER']
TargetAdd('multify_multify.obj', opts=OPTS, input='multify.cxx')
TargetAdd('multify.exe', input=['multify_multify.obj'])
TargetAdd('multify.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('multify.exe', opts=OPTS)
TargetAdd('pzip_pzip.obj', opts=OPTS, input='pzip.cxx')
TargetAdd('pzip.exe', input=['pzip_pzip.obj'])
TargetAdd('pzip.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('pzip.exe', opts=OPTS)
TargetAdd('punzip_punzip.obj', opts=OPTS, input='punzip.cxx')
TargetAdd('punzip.exe', input=['punzip_punzip.obj'])
TargetAdd('punzip.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('punzip.exe', opts=OPTS)
#
# DIRECTORY: panda/src/windisplay/
#
if (GetTarget() == 'windows' and not RUNTIME):
OPTS=['DIR:panda/src/windisplay', 'BUILDING:PANDAWIN']
TargetAdd('p3windisplay_composite1.obj', opts=OPTS+["BIGOBJ"], input='p3windisplay_composite1.cxx')
TargetAdd('p3windisplay_windetectdx9.obj', opts=OPTS + ["DX9"], input='winDetectDx9.cxx')
TargetAdd('libp3windisplay.dll', input='p3windisplay_composite1.obj')
TargetAdd('libp3windisplay.dll', input='p3windisplay_windetectdx9.obj')
TargetAdd('libp3windisplay.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3windisplay.dll', opts=['WINIMM', 'WINGDI', 'WINKERNEL', 'WINOLDNAMES', 'WINUSER', 'WINMM',"BIGOBJ"])
#
# DIRECTORY: panda/metalibs/pandadx9/
#
if PkgSkip("DX9")==0 and not RUNTIME:
OPTS=['DIR:panda/src/dxgsg9', 'BUILDING:PANDADX', 'DX9', 'NVIDIACG', 'CGDX9']
TargetAdd('p3dxgsg9_dxGraphicsStateGuardian9.obj', opts=OPTS, input='dxGraphicsStateGuardian9.cxx')
TargetAdd('p3dxgsg9_composite1.obj', opts=OPTS, input='p3dxgsg9_composite1.cxx')
OPTS=['DIR:panda/metalibs/pandadx9', 'BUILDING:PANDADX', 'DX9', 'NVIDIACG', 'CGDX9']
TargetAdd('pandadx9_pandadx9.obj', opts=OPTS, input='pandadx9.cxx')
TargetAdd('libpandadx9.dll', input='pandadx9_pandadx9.obj')
TargetAdd('libpandadx9.dll', input='p3dxgsg9_dxGraphicsStateGuardian9.obj')
TargetAdd('libpandadx9.dll', input='p3dxgsg9_composite1.obj')
TargetAdd('libpandadx9.dll', input='libp3windisplay.dll')
TargetAdd('libpandadx9.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandadx9.dll', opts=['MODULE', 'ADVAPI', 'WINGDI', 'WINKERNEL', 'WINUSER', 'WINMM', 'DX9', 'NVIDIACG', 'CGDX9'])
#
# DIRECTORY: panda/src/egg/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/egg', 'BUILDING:PANDAEGG', 'ZLIB', 'BISONPREFIX_eggyy', 'FLEXDASHI']
CreateFile(GetOutputDir()+"/include/parser.h")
TargetAdd('p3egg_parser.obj', opts=OPTS, input='parser.yxx')
TargetAdd('parser.h', input='p3egg_parser.obj', opts=['DEPENDENCYONLY'])
TargetAdd('p3egg_lexer.obj', opts=OPTS, input='lexer.lxx')
TargetAdd('p3egg_composite1.obj', opts=OPTS, input='p3egg_composite1.cxx')
TargetAdd('p3egg_composite2.obj', opts=OPTS, input='p3egg_composite2.cxx')
OPTS=['DIR:panda/src/egg', 'ZLIB']
IGATEFILES=GetDirectoryContents('panda/src/egg', ["*.h", "*_composite*.cxx"])
if "parser.h" in IGATEFILES: IGATEFILES.remove("parser.h")
TargetAdd('libp3egg.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3egg.in', opts=['IMOD:panda3d.egg', 'ILIB:libp3egg', 'SRCDIR:panda/src/egg'])
TargetAdd('libp3egg_igate.obj', input='libp3egg.in', opts=["DEPENDENCYONLY"])
TargetAdd('p3egg_eggGroupNode_ext.obj', opts=OPTS, input='eggGroupNode_ext.cxx')
#
# DIRECTORY: panda/src/egg2pg/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/egg2pg', 'BUILDING:PANDAEGG']
TargetAdd('p3egg2pg_composite1.obj', opts=OPTS, input='p3egg2pg_composite1.cxx')
TargetAdd('p3egg2pg_composite2.obj', opts=OPTS, input='p3egg2pg_composite2.cxx')
OPTS=['DIR:panda/src/egg2pg']
IGATEFILES=['load_egg_file.h']
TargetAdd('libp3egg2pg.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3egg2pg.in', opts=['IMOD:panda3d.egg', 'ILIB:libp3egg2pg', 'SRCDIR:panda/src/egg2pg'])
TargetAdd('libp3egg2pg_igate.obj', input='libp3egg2pg.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/framework/
#
if (not RUNTIME):
OPTS=['DIR:panda/src/framework', 'BUILDING:FRAMEWORK']
TargetAdd('p3framework_composite1.obj', opts=OPTS, input='p3framework_composite1.cxx')
TargetAdd('libp3framework.dll', input='p3framework_composite1.obj')
TargetAdd('libp3framework.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3framework.dll', opts=['ADVAPI'])
#
# DIRECTORY: panda/src/glgsg/
#
if (not RUNTIME and PkgSkip("GL")==0):
OPTS=['DIR:panda/src/glgsg', 'DIR:panda/src/glstuff', 'BUILDING:PANDAGL', 'GL', 'NVIDIACG']
TargetAdd('p3glgsg_config_glgsg.obj', opts=OPTS, input='config_glgsg.cxx')
TargetAdd('p3glgsg_glgsg.obj', opts=OPTS, input='glgsg.cxx')
#
# DIRECTORY: panda/src/glesgsg/
#
if (not RUNTIME and PkgSkip("GLES")==0):
OPTS=['DIR:panda/src/glesgsg', 'DIR:panda/src/glstuff', 'BUILDING:PANDAGLES', 'GLES']
TargetAdd('p3glesgsg_config_glesgsg.obj', opts=OPTS, input='config_glesgsg.cxx')
TargetAdd('p3glesgsg_glesgsg.obj', opts=OPTS, input='glesgsg.cxx')
#
# DIRECTORY: panda/src/gles2gsg/
#
if (not RUNTIME and PkgSkip("GLES2")==0):
OPTS=['DIR:panda/src/gles2gsg', 'DIR:panda/src/glstuff', 'BUILDING:PANDAGLES2', 'GLES2']
TargetAdd('p3gles2gsg_config_gles2gsg.obj', opts=OPTS, input='config_gles2gsg.cxx')
TargetAdd('p3gles2gsg_gles2gsg.obj', opts=OPTS, input='gles2gsg.cxx')
#
# DIRECTORY: panda/metalibs/pandaegg/
#
if (not RUNTIME):
OPTS=['DIR:panda/metalibs/pandaegg', 'DIR:panda/src/egg', 'BUILDING:PANDAEGG']
TargetAdd('pandaegg_pandaegg.obj', opts=OPTS, input='pandaegg.cxx')
TargetAdd('libpandaegg.dll', input='pandaegg_pandaegg.obj')
TargetAdd('libpandaegg.dll', input='p3egg2pg_composite1.obj')
TargetAdd('libpandaegg.dll', input='p3egg2pg_composite2.obj')
TargetAdd('libpandaegg.dll', input='p3egg_composite1.obj')
TargetAdd('libpandaegg.dll', input='p3egg_composite2.obj')
TargetAdd('libpandaegg.dll', input='p3egg_parser.obj')
TargetAdd('libpandaegg.dll', input='p3egg_lexer.obj')
TargetAdd('libpandaegg.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandaegg.dll', opts=['ADVAPI'])
OPTS=['DIR:panda/metalibs/pandaegg', 'DIR:panda/src/egg']
TargetAdd('egg_module.obj', input='libp3egg2pg.in')
TargetAdd('egg_module.obj', input='libp3egg.in')
TargetAdd('egg_module.obj', opts=OPTS)
TargetAdd('egg_module.obj', opts=['IMOD:panda3d.egg', 'ILIB:egg', 'IMPORT:panda3d._core'])
TargetAdd('egg.pyd', input='egg_module.obj')
TargetAdd('egg.pyd', input='p3egg_eggGroupNode_ext.obj')
TargetAdd('egg.pyd', input='libp3egg_igate.obj')
TargetAdd('egg.pyd', input='libp3egg2pg_igate.obj')
TargetAdd('egg.pyd', input='libpandaegg.dll')
TargetAdd('egg.pyd', input='libp3interrogatedb.dll')
TargetAdd('egg.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('egg.pyd', opts=['PYTHON'])
#
# DIRECTORY: panda/src/x11display/
#
if (GetTarget() not in ['windows', 'darwin'] and PkgSkip("X11")==0 and not RUNTIME):
OPTS=['DIR:panda/src/x11display', 'BUILDING:PANDAX11', 'X11']
TargetAdd('p3x11display_composite1.obj', opts=OPTS, input='p3x11display_composite1.cxx')
#
# DIRECTORY: panda/src/glxdisplay/
#
if (GetTarget() not in ['windows', 'darwin'] and PkgSkip("GL")==0 and PkgSkip("X11")==0 and not RUNTIME):
OPTS=['DIR:panda/src/glxdisplay', 'BUILDING:PANDAGL', 'GL', 'NVIDIACG', 'CGGL']
TargetAdd('p3glxdisplay_composite1.obj', opts=OPTS, input='p3glxdisplay_composite1.cxx')
OPTS=['DIR:panda/metalibs/pandagl', 'BUILDING:PANDAGL', 'GL', 'NVIDIACG', 'CGGL']
TargetAdd('pandagl_pandagl.obj', opts=OPTS, input='pandagl.cxx')
TargetAdd('libpandagl.dll', input='p3x11display_composite1.obj')
TargetAdd('libpandagl.dll', input='pandagl_pandagl.obj')
TargetAdd('libpandagl.dll', input='p3glgsg_config_glgsg.obj')
TargetAdd('libpandagl.dll', input='p3glgsg_glgsg.obj')
TargetAdd('libpandagl.dll', input='p3glxdisplay_composite1.obj')
TargetAdd('libpandagl.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandagl.dll', opts=['MODULE', 'GL', 'NVIDIACG', 'CGGL', 'X11', 'XRANDR', 'XF86DGA', 'XCURSOR'])
#
# DIRECTORY: panda/src/cocoadisplay/
#
if (GetTarget() == 'darwin' and PkgSkip("COCOA")==0 and PkgSkip("GL")==0 and not RUNTIME):
OPTS=['DIR:panda/src/cocoadisplay', 'BUILDING:PANDAGL', 'GL', 'NVIDIACG', 'CGGL']
TargetAdd('p3cocoadisplay_composite1.obj', opts=OPTS, input='p3cocoadisplay_composite1.mm')
OPTS=['DIR:panda/metalibs/pandagl', 'BUILDING:PANDAGL', 'GL', 'NVIDIACG', 'CGGL']
TargetAdd('pandagl_pandagl.obj', opts=OPTS, input='pandagl.cxx')
TargetAdd('libpandagl.dll', input='pandagl_pandagl.obj')
TargetAdd('libpandagl.dll', input='p3glgsg_config_glgsg.obj')
TargetAdd('libpandagl.dll', input='p3glgsg_glgsg.obj')
TargetAdd('libpandagl.dll', input='p3cocoadisplay_composite1.obj')
if (PkgSkip('PANDAFX')==0):
TargetAdd('libpandagl.dll', input='libpandafx.dll')
TargetAdd('libpandagl.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandagl.dll', opts=['MODULE', 'GL', 'NVIDIACG', 'CGGL', 'COCOA'])
#
# DIRECTORY: panda/src/osxdisplay/
#
elif (GetTarget() == 'darwin' and PkgSkip("CARBON")==0 and PkgSkip("GL")==0 and not RUNTIME):
OPTS=['DIR:panda/src/osxdisplay', 'BUILDING:PANDAGL', 'GL', 'NVIDIACG', 'CGGL']
TargetAdd('p3osxdisplay_composite1.obj', opts=OPTS, input='p3osxdisplay_composite1.cxx')
TargetAdd('p3osxdisplay_osxGraphicsWindow.obj', opts=OPTS, input='osxGraphicsWindow.mm')
OPTS=['DIR:panda/metalibs/pandagl', 'BUILDING:PANDAGL', 'GL', 'NVIDIACG', 'CGGL']
TargetAdd('pandagl_pandagl.obj', opts=OPTS, input='pandagl.cxx')
TargetAdd('libpandagl.dll', input='pandagl_pandagl.obj')
TargetAdd('libpandagl.dll', input='p3glgsg_config_glgsg.obj')
TargetAdd('libpandagl.dll', input='p3glgsg_glgsg.obj')
TargetAdd('libpandagl.dll', input='p3osxdisplay_composite1.obj')
TargetAdd('libpandagl.dll', input='p3osxdisplay_osxGraphicsWindow.obj')
if (PkgSkip('PANDAFX')==0):
TargetAdd('libpandagl.dll', input='libpandafx.dll')
TargetAdd('libpandagl.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandagl.dll', opts=['MODULE', 'GL', 'NVIDIACG', 'CGGL', 'CARBON', 'AGL', 'COCOA'])
#
# DIRECTORY: panda/src/wgldisplay/
#
if (GetTarget() == 'windows' and PkgSkip("GL")==0 and not RUNTIME):
OPTS=['DIR:panda/src/wgldisplay', 'DIR:panda/src/glstuff', 'BUILDING:PANDAGL', 'NVIDIACG', 'CGGL']
TargetAdd('p3wgldisplay_composite1.obj', opts=OPTS, input='p3wgldisplay_composite1.cxx')
OPTS=['DIR:panda/metalibs/pandagl', 'BUILDING:PANDAGL', 'NVIDIACG', 'CGGL']
TargetAdd('pandagl_pandagl.obj', opts=OPTS, input='pandagl.cxx')
TargetAdd('libpandagl.dll', input='pandagl_pandagl.obj')
TargetAdd('libpandagl.dll', input='p3glgsg_config_glgsg.obj')
TargetAdd('libpandagl.dll', input='p3glgsg_glgsg.obj')
TargetAdd('libpandagl.dll', input='p3wgldisplay_composite1.obj')
TargetAdd('libpandagl.dll', input='libp3windisplay.dll')
if (PkgSkip('PANDAFX')==0):
TargetAdd('libpandagl.dll', input='libpandafx.dll')
TargetAdd('libpandagl.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandagl.dll', opts=['MODULE', 'WINGDI', 'GL', 'WINKERNEL', 'WINOLDNAMES', 'WINUSER', 'WINMM', 'NVIDIACG', 'CGGL'])
#
# DIRECTORY: panda/src/egldisplay/
#
if (PkgSkip("EGL")==0 and PkgSkip("GLES")==0 and PkgSkip("X11")==0 and not RUNTIME):
DefSymbol('GLES', 'OPENGLES_1', '')
OPTS=['DIR:panda/src/egldisplay', 'DIR:panda/src/glstuff', 'BUILDING:PANDAGLES', 'GLES', 'EGL']
TargetAdd('pandagles_egldisplay_composite1.obj', opts=OPTS, input='p3egldisplay_composite1.cxx')
OPTS=['DIR:panda/metalibs/pandagles', 'BUILDING:PANDAGLES', 'GLES', 'EGL']
TargetAdd('pandagles_pandagles.obj', opts=OPTS, input='pandagles.cxx')
# Uncomment this as soon as x11-specific stuff is removed from p3egldisplay
#TargetAdd('libpandagles.dll', input='p3x11display_composite1.obj')
TargetAdd('libpandagles.dll', input='pandagles_pandagles.obj')
TargetAdd('libpandagles.dll', input='p3glesgsg_config_glesgsg.obj')
TargetAdd('libpandagles.dll', input='p3glesgsg_glesgsg.obj')
TargetAdd('libpandagles.dll', input='pandagles_egldisplay_composite1.obj')
TargetAdd('libpandagles.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandagles.dll', opts=['MODULE', 'GLES', 'EGL', 'X11', 'XRANDR', 'XF86DGA', 'XCURSOR'])
#
# DIRECTORY: panda/src/egldisplay/
#
if (PkgSkip("EGL")==0 and PkgSkip("GLES2")==0 and PkgSkip("X11")==0 and not RUNTIME):
DefSymbol('GLES2', 'OPENGLES_2', '')
OPTS=['DIR:panda/src/egldisplay', 'DIR:panda/src/glstuff', 'BUILDING:PANDAGLES2', 'GLES2', 'EGL']
TargetAdd('pandagles2_egldisplay_composite1.obj', opts=OPTS, input='p3egldisplay_composite1.cxx')
OPTS=['DIR:panda/metalibs/pandagles2', 'BUILDING:PANDAGLES2', 'GLES2', 'EGL']
TargetAdd('pandagles2_pandagles2.obj', opts=OPTS, input='pandagles2.cxx')
# Uncomment this as soon as x11-specific stuff is removed from p3egldisplay
#TargetAdd('libpandagles2.dll', input='p3x11display_composite1.obj')
TargetAdd('libpandagles2.dll', input='pandagles2_pandagles2.obj')
TargetAdd('libpandagles2.dll', input='p3gles2gsg_config_gles2gsg.obj')
TargetAdd('libpandagles2.dll', input='p3gles2gsg_gles2gsg.obj')
TargetAdd('libpandagles2.dll', input='pandagles2_egldisplay_composite1.obj')
TargetAdd('libpandagles2.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandagles2.dll', opts=['MODULE', 'GLES2', 'EGL', 'X11', 'XRANDR', 'XF86DGA', 'XCURSOR'])
#
# DIRECTORY: panda/src/ode/
#
if (PkgSkip("ODE")==0 and not RUNTIME):
OPTS=['DIR:panda/src/ode', 'BUILDING:PANDAODE', 'ODE']
TargetAdd('p3ode_composite1.obj', opts=OPTS, input='p3ode_composite1.cxx')
TargetAdd('p3ode_composite2.obj', opts=OPTS, input='p3ode_composite2.cxx')
TargetAdd('p3ode_composite3.obj', opts=OPTS, input='p3ode_composite3.cxx')
OPTS=['DIR:panda/src/ode', 'ODE']
IGATEFILES=GetDirectoryContents('panda/src/ode', ["*.h", "*_composite*.cxx"])
IGATEFILES.remove("odeConvexGeom.h")
IGATEFILES.remove("odeHeightFieldGeom.h")
IGATEFILES.remove("odeHelperStructs.h")
TargetAdd('libpandaode.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libpandaode.in', opts=['IMOD:panda3d.ode', 'ILIB:libpandaode', 'SRCDIR:panda/src/ode'])
TargetAdd('libpandaode_igate.obj', input='libpandaode.in', opts=["DEPENDENCYONLY"])
TargetAdd('p3ode_ext_composite.obj', opts=OPTS, input='p3ode_ext_composite.cxx')
#
# DIRECTORY: panda/metalibs/pandaode/
#
if (PkgSkip("ODE")==0 and not RUNTIME):
OPTS=['DIR:panda/metalibs/pandaode', 'BUILDING:PANDAODE', 'ODE']
TargetAdd('pandaode_pandaode.obj', opts=OPTS, input='pandaode.cxx')
TargetAdd('libpandaode.dll', input='pandaode_pandaode.obj')
TargetAdd('libpandaode.dll', input='p3ode_composite1.obj')
TargetAdd('libpandaode.dll', input='p3ode_composite2.obj')
TargetAdd('libpandaode.dll', input='p3ode_composite3.obj')
TargetAdd('libpandaode.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandaode.dll', opts=['WINUSER', 'ODE'])
OPTS=['DIR:panda/metalibs/pandaode', 'ODE']
TargetAdd('ode_module.obj', input='libpandaode.in')
TargetAdd('ode_module.obj', opts=OPTS)
TargetAdd('ode_module.obj', opts=['IMOD:panda3d.ode', 'ILIB:ode', 'IMPORT:panda3d._core'])
TargetAdd('ode.pyd', input='ode_module.obj')
TargetAdd('ode.pyd', input='libpandaode_igate.obj')
TargetAdd('ode.pyd', input='p3ode_ext_composite.obj')
TargetAdd('ode.pyd', input='libpandaode.dll')
TargetAdd('ode.pyd', input='libp3interrogatedb.dll')
TargetAdd('ode.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('ode.pyd', opts=['PYTHON', 'WINUSER', 'ODE'])
#
# DIRECTORY: panda/src/bullet/
#
if (PkgSkip("BULLET")==0 and not RUNTIME):
OPTS=['DIR:panda/src/bullet', 'BUILDING:PANDABULLET', 'BULLET']
TargetAdd('p3bullet_composite.obj', opts=OPTS, input='p3bullet_composite.cxx')
OPTS=['DIR:panda/src/bullet', 'BULLET']
IGATEFILES=GetDirectoryContents('panda/src/bullet', ["*.h", "*_composite*.cxx"])
TargetAdd('libpandabullet.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libpandabullet.in', opts=['IMOD:panda3d.bullet', 'ILIB:libpandabullet', 'SRCDIR:panda/src/bullet'])
TargetAdd('libpandabullet_igate.obj', input='libpandabullet.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/metalibs/pandabullet/
#
if (PkgSkip("BULLET")==0 and not RUNTIME):
OPTS=['DIR:panda/metalibs/pandabullet', 'BUILDING:PANDABULLET', 'BULLET']
TargetAdd('pandabullet_pandabullet.obj', opts=OPTS, input='pandabullet.cxx')
TargetAdd('libpandabullet.dll', input='pandabullet_pandabullet.obj')
TargetAdd('libpandabullet.dll', input='p3bullet_composite.obj')
TargetAdd('libpandabullet.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandabullet.dll', opts=['WINUSER', 'BULLET'])
OPTS=['DIR:panda/metalibs/pandabullet', 'BULLET']
TargetAdd('bullet_module.obj', input='libpandabullet.in')
TargetAdd('bullet_module.obj', opts=OPTS)
TargetAdd('bullet_module.obj', opts=['IMOD:panda3d.bullet', 'ILIB:bullet', 'IMPORT:panda3d._core'])
TargetAdd('bullet.pyd', input='bullet_module.obj')
TargetAdd('bullet.pyd', input='libpandabullet_igate.obj')
TargetAdd('bullet.pyd', input='libpandabullet.dll')
TargetAdd('bullet.pyd', input='libp3interrogatedb.dll')
TargetAdd('bullet.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('bullet.pyd', opts=['PYTHON', 'WINUSER', 'BULLET'])
#
# DIRECTORY: panda/src/physx/
#
if (PkgSkip("PHYSX")==0):
OPTS=['DIR:panda/src/physx', 'BUILDING:PANDAPHYSX', 'PHYSX', 'NOARCH:PPC']
TargetAdd('p3physx_composite.obj', opts=OPTS, input='p3physx_composite.cxx')
OPTS=['DIR:panda/src/physx', 'PHYSX', 'NOARCH:PPC']
IGATEFILES=GetDirectoryContents('panda/src/physx', ["*.h", "*_composite*.cxx"])
TargetAdd('libpandaphysx.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libpandaphysx.in', opts=['IMOD:panda3d.physx', 'ILIB:libpandaphysx', 'SRCDIR:panda/src/physx'])
TargetAdd('libpandaphysx_igate.obj', input='libpandaphysx.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/metalibs/pandaphysx/
#
if (PkgSkip("PHYSX")==0):
OPTS=['DIR:panda/metalibs/pandaphysx', 'BUILDING:PANDAPHYSX', 'PHYSX', 'NOARCH:PPC']
TargetAdd('pandaphysx_pandaphysx.obj', opts=OPTS, input='pandaphysx.cxx')
TargetAdd('libpandaphysx.dll', input='pandaphysx_pandaphysx.obj')
TargetAdd('libpandaphysx.dll', input='p3physx_composite.obj')
TargetAdd('libpandaphysx.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandaphysx.dll', opts=['WINUSER', 'PHYSX', 'NOARCH:PPC'])
OPTS=['DIR:panda/metalibs/pandaphysx', 'PHYSX', 'NOARCH:PPC']
TargetAdd('physx_module.obj', input='libpandaphysx.in')
TargetAdd('physx_module.obj', opts=OPTS)
TargetAdd('physx_module.obj', opts=['IMOD:panda3d.physx', 'ILIB:physx', 'IMPORT:panda3d._core'])
TargetAdd('physx.pyd', input='physx_module.obj')
TargetAdd('physx.pyd', input='libpandaphysx_igate.obj')
TargetAdd('physx.pyd', input='libpandaphysx.dll')
TargetAdd('physx.pyd', input='libp3interrogatedb.dll')
TargetAdd('physx.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('physx.pyd', opts=['PYTHON', 'WINUSER', 'PHYSX', 'NOARCH:PPC'])
#
# DIRECTORY: panda/src/physics/
#
if (PkgSkip("PANDAPHYSICS")==0) and (not RUNTIME):
OPTS=['DIR:panda/src/physics', 'BUILDING:PANDAPHYSICS']
TargetAdd('p3physics_composite1.obj', opts=OPTS, input='p3physics_composite1.cxx')
TargetAdd('p3physics_composite2.obj', opts=OPTS, input='p3physics_composite2.cxx')
OPTS=['DIR:panda/src/physics']
IGATEFILES=GetDirectoryContents('panda/src/physics', ["*.h", "*_composite*.cxx"])
IGATEFILES.remove("forces.h")
TargetAdd('libp3physics.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3physics.in', opts=['IMOD:panda3d.physics', 'ILIB:libp3physics', 'SRCDIR:panda/src/physics'])
TargetAdd('libp3physics_igate.obj', input='libp3physics.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/src/particlesystem/
#
if (PkgSkip("PANDAPHYSICS")==0) and (PkgSkip("PANDAPARTICLESYSTEM")==0) and (not RUNTIME):
OPTS=['DIR:panda/src/particlesystem', 'BUILDING:PANDAPHYSICS']
TargetAdd('p3particlesystem_composite1.obj', opts=OPTS, input='p3particlesystem_composite1.cxx')
TargetAdd('p3particlesystem_composite2.obj', opts=OPTS, input='p3particlesystem_composite2.cxx')
OPTS=['DIR:panda/src/particlesystem']
IGATEFILES=GetDirectoryContents('panda/src/particlesystem', ["*.h", "*_composite*.cxx"])
IGATEFILES.remove('orientedParticle.h')
IGATEFILES.remove('orientedParticleFactory.h')
IGATEFILES.remove('particlefactories.h')
IGATEFILES.remove('emitters.h')
IGATEFILES.remove('particles.h')
TargetAdd('libp3particlesystem.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3particlesystem.in', opts=['IMOD:panda3d.physics', 'ILIB:libp3particlesystem', 'SRCDIR:panda/src/particlesystem'])
TargetAdd('libp3particlesystem_igate.obj', input='libp3particlesystem.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: panda/metalibs/pandaphysics/
#
if (PkgSkip("PANDAPHYSICS")==0) and (not RUNTIME):
OPTS=['DIR:panda/metalibs/pandaphysics', 'BUILDING:PANDAPHYSICS']
TargetAdd('pandaphysics_pandaphysics.obj', opts=OPTS, input='pandaphysics.cxx')
TargetAdd('libpandaphysics.dll', input='pandaphysics_pandaphysics.obj')
TargetAdd('libpandaphysics.dll', input='p3physics_composite1.obj')
TargetAdd('libpandaphysics.dll', input='p3physics_composite2.obj')
TargetAdd('libpandaphysics.dll', input='p3particlesystem_composite1.obj')
TargetAdd('libpandaphysics.dll', input='p3particlesystem_composite2.obj')
TargetAdd('libpandaphysics.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandaphysics.dll', opts=['ADVAPI'])
OPTS=['DIR:panda/metalibs/pandaphysics']
TargetAdd('physics_module.obj', input='libp3physics.in')
if (PkgSkip("PANDAPARTICLESYSTEM")==0):
TargetAdd('physics_module.obj', input='libp3particlesystem.in')
TargetAdd('physics_module.obj', opts=OPTS)
TargetAdd('physics_module.obj', opts=['IMOD:panda3d.physics', 'ILIB:physics', 'IMPORT:panda3d._core'])
TargetAdd('physics.pyd', input='physics_module.obj')
TargetAdd('physics.pyd', input='libp3physics_igate.obj')
if (PkgSkip("PANDAPARTICLESYSTEM")==0):
TargetAdd('physics.pyd', input='libp3particlesystem_igate.obj')
TargetAdd('physics.pyd', input='libpandaphysics.dll')
TargetAdd('physics.pyd', input='libp3interrogatedb.dll')
TargetAdd('physics.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('physics.pyd', opts=['PYTHON'])
#
# DIRECTORY: panda/src/speedtree/
#
if (PkgSkip("SPEEDTREE")==0):
OPTS=['DIR:panda/src/speedtree', 'BUILDING:PANDASPEEDTREE', 'SPEEDTREE']
TargetAdd('pandaspeedtree_composite1.obj', opts=OPTS, input='pandaspeedtree_composite1.cxx')
IGATEFILES=GetDirectoryContents('panda/src/speedtree', ["*.h", "*_composite*.cxx"])
TargetAdd('libpandaspeedtree.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libpandaspeedtree.in', opts=['IMOD:libpandaspeedtree', 'ILIB:libpandaspeedtree', 'SRCDIR:panda/src/speedtree'])
TargetAdd('libpandaspeedtree_igate.obj', input='libpandaspeedtree.in', opts=["DEPENDENCYONLY"])
TargetAdd('libpandaspeedtree_module.obj', input='libpandaspeedtree.in')
TargetAdd('libpandaspeedtree_module.obj', opts=OPTS)
TargetAdd('libpandaspeedtree_module.obj', opts=['IMOD:libpandaspeedtree', 'ILIB:libpandaspeedtree'])
TargetAdd('libpandaspeedtree.dll', input='pandaspeedtree_composite1.obj')
TargetAdd('libpandaspeedtree.dll', input='libpandaspeedtree_igate.obj')
TargetAdd('libpandaspeedtree.dll', input='libpandaspeedtree_module.obj')
TargetAdd('libpandaspeedtree.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandaspeedtree.dll', opts=['SPEEDTREE'])
if SDK["SPEEDTREEAPI"] == 'OpenGL':
TargetAdd('libpandaspeedtree.dll', opts=['GL', 'NVIDIACG', 'CGGL'])
elif SDK["SPEEDTREEAPI"] == 'DirectX9':
TargetAdd('libpandaspeedtree.dll', opts=['DX9', 'NVIDIACG', 'CGDX9'])
#
# DIRECTORY: panda/src/testbed/
#
if (not RTDIST and not RUNTIME and PkgSkip("PVIEW")==0 and GetTarget() != 'android'):
OPTS=['DIR:panda/src/testbed']
TargetAdd('pview_pview.obj', opts=OPTS, input='pview.cxx')
TargetAdd('pview.exe', input='pview_pview.obj')
TargetAdd('pview.exe', input='libp3framework.dll')
TargetAdd('pview.exe', input='libpandaegg.dll')
TargetAdd('pview.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('pview.exe', opts=['ADVAPI', 'WINSOCK2', 'WINSHELL'])
#
# DIRECTORY: panda/src/android/
#
if (not RUNTIME and GetTarget() == 'android'):
native_app_glue = os.path.join(SDK['ANDROID_NDK'], 'sources', 'android', 'native_app_glue')
OPTS=['DIR:panda/src/android', 'DIR:' + native_app_glue]
TargetAdd('p3android_composite1.obj', opts=OPTS, input='p3android_composite1.cxx')
TargetAdd('libp3android.dll', input='p3android_composite1.obj')
TargetAdd('libp3android.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3android.dll', opts=['JNIGRAPHICS'])
TargetAdd('android_native_app_glue.obj', opts=OPTS, input='android_native_app_glue.c')
TargetAdd('android_main.obj', opts=OPTS, input='android_main.cxx')
if (not RTDIST and PkgSkip("PVIEW")==0):
TargetAdd('pview_pview.obj', opts=OPTS, input='pview.cxx')
TargetAdd('pview.exe', input='android_native_app_glue.obj')
TargetAdd('pview.exe', input='android_main.obj')
TargetAdd('pview.exe', input='pview_pview.obj')
TargetAdd('pview.exe', input='libp3framework.dll')
TargetAdd('pview.exe', input='libpandaegg.dll')
TargetAdd('pview.exe', input='libp3android.dll')
TargetAdd('pview.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('AndroidManifest.xml', opts=OPTS, input='pview_manifest.xml')
#
# DIRECTORY: panda/src/androiddisplay/
#
if (GetTarget() == 'android' and PkgSkip("EGL")==0 and PkgSkip("GLES")==0 and not RUNTIME):
DefSymbol('GLES', 'OPENGLES_1', '')
OPTS=['DIR:panda/src/androiddisplay', 'DIR:panda/src/glstuff', 'DIR:' + native_app_glue, 'BUILDING:PANDAGLES', 'GLES', 'EGL']
TargetAdd('pandagles_androiddisplay_composite1.obj', opts=OPTS, input='p3androiddisplay_composite1.cxx')
OPTS=['DIR:panda/metalibs/pandagles', 'BUILDING:PANDAGLES', 'GLES', 'EGL']
TargetAdd('pandagles_pandagles.obj', opts=OPTS, input='pandagles.cxx')
TargetAdd('libpandagles.dll', input='pandagles_pandagles.obj')
TargetAdd('libpandagles.dll', input='p3glesgsg_config_glesgsg.obj')
TargetAdd('libpandagles.dll', input='p3glesgsg_glesgsg.obj')
TargetAdd('libpandagles.dll', input='pandagles_androiddisplay_composite1.obj')
TargetAdd('libpandagles.dll', input='libp3android.dll')
TargetAdd('libpandagles.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libpandagles.dll', opts=['MODULE', 'GLES', 'EGL'])
#
# DIRECTORY: panda/src/tinydisplay/
#
if (not RUNTIME and (GetTarget() in ('windows', 'darwin') or PkgSkip("X11")==0) and PkgSkip("TINYDISPLAY")==0):
OPTS=['DIR:panda/src/tinydisplay', 'BUILDING:TINYDISPLAY']
TargetAdd('p3tinydisplay_composite1.obj', opts=OPTS, input='p3tinydisplay_composite1.cxx')
TargetAdd('p3tinydisplay_composite2.obj', opts=OPTS, input='p3tinydisplay_composite2.cxx')
TargetAdd('p3tinydisplay_ztriangle_1.obj', opts=OPTS, input='ztriangle_1.cxx')
TargetAdd('p3tinydisplay_ztriangle_2.obj', opts=OPTS, input='ztriangle_2.cxx')
TargetAdd('p3tinydisplay_ztriangle_3.obj', opts=OPTS, input='ztriangle_3.cxx')
TargetAdd('p3tinydisplay_ztriangle_4.obj', opts=OPTS, input='ztriangle_4.cxx')
TargetAdd('p3tinydisplay_ztriangle_table.obj', opts=OPTS, input='ztriangle_table.cxx')
if GetTarget() == 'darwin':
TargetAdd('p3tinydisplay_tinyOsxGraphicsWindow.obj', opts=OPTS, input='tinyOsxGraphicsWindow.mm')
TargetAdd('libp3tinydisplay.dll', input='p3tinydisplay_tinyOsxGraphicsWindow.obj')
TargetAdd('libp3tinydisplay.dll', opts=['CARBON', 'AGL', 'COCOA'])
elif GetTarget() == 'windows':
TargetAdd('libp3tinydisplay.dll', input='libp3windisplay.dll')
TargetAdd('libp3tinydisplay.dll', opts=['WINIMM', 'WINGDI', 'WINKERNEL', 'WINOLDNAMES', 'WINUSER', 'WINMM'])
else:
TargetAdd('libp3tinydisplay.dll', input='p3x11display_composite1.obj')
TargetAdd('libp3tinydisplay.dll', opts=['X11', 'XRANDR', 'XF86DGA', 'XCURSOR'])
TargetAdd('libp3tinydisplay.dll', input='p3tinydisplay_composite1.obj')
TargetAdd('libp3tinydisplay.dll', input='p3tinydisplay_composite2.obj')
TargetAdd('libp3tinydisplay.dll', input='p3tinydisplay_ztriangle_1.obj')
TargetAdd('libp3tinydisplay.dll', input='p3tinydisplay_ztriangle_2.obj')
TargetAdd('libp3tinydisplay.dll', input='p3tinydisplay_ztriangle_3.obj')
TargetAdd('libp3tinydisplay.dll', input='p3tinydisplay_ztriangle_4.obj')
TargetAdd('libp3tinydisplay.dll', input='p3tinydisplay_ztriangle_table.obj')
TargetAdd('libp3tinydisplay.dll', input=COMMON_PANDA_LIBS)
#
# DIRECTORY: direct/src/directbase/
#
if (PkgSkip("DIRECT")==0):
OPTS=['DIR:direct/src/directbase', 'PYTHON']
TargetAdd('p3directbase_directbase.obj', opts=OPTS+['BUILDING:DIRECT'], input='directbase.cxx')
if (PkgSkip("PYTHON")==0 and not RTDIST and not RUNTIME):
DefSymbol("BUILDING:PACKPANDA", "IMPORT_MODULE", "direct.directscripts.packpanda")
TargetAdd('packpanda.obj', opts=OPTS+['BUILDING:PACKPANDA'], input='ppython.cxx')
TargetAdd('packpanda.exe', input='packpanda.obj')
TargetAdd('packpanda.exe', opts=['PYTHON'])
DefSymbol("BUILDING:EGGCACHER", "IMPORT_MODULE", "direct.directscripts.eggcacher")
TargetAdd('eggcacher.obj', opts=OPTS+['BUILDING:EGGCACHER'], input='ppython.cxx')
TargetAdd('eggcacher.exe', input='eggcacher.obj')
TargetAdd('eggcacher.exe', opts=['PYTHON'])
#
# DIRECTORY: direct/src/dcparser/
#
if (PkgSkip("DIRECT")==0):
OPTS=['DIR:direct/src/dcparser', 'WITHINPANDA', 'BUILDING:DIRECT', 'BISONPREFIX_dcyy']
CreateFile(GetOutputDir()+"/include/dcParser.h")
TargetAdd('p3dcparser_dcParser.obj', opts=OPTS, input='dcParser.yxx')
TargetAdd('dcParser.h', input='p3dcparser_dcParser.obj', opts=['DEPENDENCYONLY'])
TargetAdd('p3dcparser_dcLexer.obj', opts=OPTS, input='dcLexer.lxx')
TargetAdd('p3dcparser_composite1.obj', opts=OPTS, input='p3dcparser_composite1.cxx')
TargetAdd('p3dcparser_composite2.obj', opts=OPTS, input='p3dcparser_composite2.cxx')
OPTS=['DIR:direct/src/dcparser', 'WITHINPANDA']
IGATEFILES=GetDirectoryContents('direct/src/dcparser', ["*.h", "*_composite*.cxx"])
if "dcParser.h" in IGATEFILES: IGATEFILES.remove("dcParser.h")
if "dcmsgtypes.h" in IGATEFILES: IGATEFILES.remove('dcmsgtypes.h')
TargetAdd('libp3dcparser.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3dcparser.in', opts=['IMOD:panda3d.direct', 'ILIB:libp3dcparser', 'SRCDIR:direct/src/dcparser'])
TargetAdd('libp3dcparser_igate.obj', input='libp3dcparser.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: direct/src/deadrec/
#
if (PkgSkip("DIRECT")==0):
OPTS=['DIR:direct/src/deadrec', 'BUILDING:DIRECT']
TargetAdd('p3deadrec_composite1.obj', opts=OPTS, input='p3deadrec_composite1.cxx')
OPTS=['DIR:direct/src/deadrec']
IGATEFILES=GetDirectoryContents('direct/src/deadrec', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3deadrec.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3deadrec.in', opts=['IMOD:panda3d.direct', 'ILIB:libp3deadrec', 'SRCDIR:direct/src/deadrec'])
TargetAdd('libp3deadrec_igate.obj', input='libp3deadrec.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: direct/src/distributed/
#
if (PkgSkip("DIRECT")==0):
OPTS=['DIR:direct/src/distributed', 'DIR:direct/src/dcparser', 'WITHINPANDA', 'BUILDING:DIRECT', 'OPENSSL']
TargetAdd('p3distributed_config_distributed.obj', opts=OPTS, input='config_distributed.cxx')
TargetAdd('p3distributed_cConnectionRepository.obj', opts=OPTS, input='cConnectionRepository.cxx')
TargetAdd('p3distributed_cDistributedSmoothNodeBase.obj', opts=OPTS, input='cDistributedSmoothNodeBase.cxx')
OPTS=['DIR:direct/src/distributed', 'WITHINPANDA', 'OPENSSL']
IGATEFILES=GetDirectoryContents('direct/src/distributed', ["*.h", "*.cxx"])
TargetAdd('libp3distributed.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3distributed.in', opts=['IMOD:panda3d.direct', 'ILIB:libp3distributed', 'SRCDIR:direct/src/distributed'])
TargetAdd('libp3distributed_igate.obj', input='libp3distributed.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: direct/src/interval/
#
if (PkgSkip("DIRECT")==0):
OPTS=['DIR:direct/src/interval', 'BUILDING:DIRECT']
TargetAdd('p3interval_composite1.obj', opts=OPTS, input='p3interval_composite1.cxx')
OPTS=['DIR:direct/src/interval']
IGATEFILES=GetDirectoryContents('direct/src/interval', ["*.h", "*_composite*.cxx"])
TargetAdd('libp3interval.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3interval.in', opts=['IMOD:panda3d.direct', 'ILIB:libp3interval', 'SRCDIR:direct/src/interval'])
TargetAdd('libp3interval_igate.obj', input='libp3interval.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: direct/src/showbase/
#
if (PkgSkip("DIRECT")==0):
OPTS=['DIR:direct/src/showbase', 'BUILDING:DIRECT']
TargetAdd('p3showbase_showBase.obj', opts=OPTS, input='showBase.cxx')
if GetTarget() == 'darwin':
TargetAdd('p3showbase_showBase_assist.obj', opts=OPTS, input='showBase_assist.mm')
OPTS=['DIR:direct/src/showbase']
IGATEFILES=GetDirectoryContents('direct/src/showbase', ["*.h", "showBase.cxx"])
TargetAdd('libp3showbase.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libp3showbase.in', opts=['IMOD:panda3d.direct', 'ILIB:libp3showbase', 'SRCDIR:direct/src/showbase'])
TargetAdd('libp3showbase_igate.obj', input='libp3showbase.in', opts=["DEPENDENCYONLY"])
#
# DIRECTORY: direct/metalibs/direct/
#
if (PkgSkip("DIRECT")==0):
OPTS=['DIR:direct/metalibs/direct', 'BUILDING:DIRECT']
TargetAdd('p3direct_direct.obj', opts=OPTS, input='direct.cxx')
TargetAdd('libp3direct.dll', input='p3direct_direct.obj')
TargetAdd('libp3direct.dll', input='p3directbase_directbase.obj')
TargetAdd('libp3direct.dll', input='p3dcparser_composite1.obj')
TargetAdd('libp3direct.dll', input='p3dcparser_composite2.obj')
TargetAdd('libp3direct.dll', input='p3dcparser_dcParser.obj')
TargetAdd('libp3direct.dll', input='p3dcparser_dcLexer.obj')
TargetAdd('libp3direct.dll', input='p3showbase_showBase.obj')
if GetTarget() == 'darwin':
TargetAdd('libp3direct.dll', input='p3showbase_showBase_assist.obj')
TargetAdd('libp3direct.dll', input='p3deadrec_composite1.obj')
TargetAdd('libp3direct.dll', input='p3interval_composite1.obj')
TargetAdd('libp3direct.dll', input='p3distributed_config_distributed.obj')
TargetAdd('libp3direct.dll', input='p3distributed_cConnectionRepository.obj')
TargetAdd('libp3direct.dll', input='p3distributed_cDistributedSmoothNodeBase.obj')
TargetAdd('libp3direct.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3direct.dll', opts=['ADVAPI', 'OPENSSL', 'WINUSER', 'WINGDI'])
OPTS=['DIR:direct/metalibs/direct']
TargetAdd('direct_module.obj', input='libp3dcparser.in')
TargetAdd('direct_module.obj', input='libp3showbase.in')
TargetAdd('direct_module.obj', input='libp3deadrec.in')
TargetAdd('direct_module.obj', input='libp3interval.in')
TargetAdd('direct_module.obj', input='libp3distributed.in')
TargetAdd('direct_module.obj', opts=OPTS)
TargetAdd('direct_module.obj', opts=['IMOD:panda3d._direct', 'ILIB:_direct', 'IMPORT:panda3d._core'])
TargetAdd('_direct.pyd', input='libp3dcparser_igate.obj')
TargetAdd('_direct.pyd', input='libp3showbase_igate.obj')
TargetAdd('_direct.pyd', input='libp3deadrec_igate.obj')
TargetAdd('_direct.pyd', input='libp3interval_igate.obj')
TargetAdd('_direct.pyd', input='libp3distributed_igate.obj')
TargetAdd('_direct.pyd', input='direct_module.obj')
TargetAdd('_direct.pyd', input='libp3direct.dll')
TargetAdd('_direct.pyd', input='libp3interrogatedb.dll')
TargetAdd('_direct.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('_direct.pyd', opts=['PYTHON', 'OPENSSL', 'WINUSER', 'WINGDI'])
OPTS=['DIR:direct/src/extensions_native']
TargetAdd('panda3d/direct.py', input='_direct.pyd')
TargetAdd('panda3d/direct.py', opts=OPTS, input='CInterval_extensions.py')
#
# DIRECTORY: direct/src/dcparse/
#
if (PkgSkip("PYTHON")==0 and PkgSkip("DIRECT")==0 and not RTDIST and not RUNTIME):
OPTS=['DIR:direct/src/dcparse', 'DIR:direct/src/dcparser', 'WITHINPANDA', 'ADVAPI']
TargetAdd('dcparse_dcparse.obj', opts=OPTS, input='dcparse.cxx')
TargetAdd('p3dcparse.exe', input='dcparse_dcparse.obj')
TargetAdd('p3dcparse.exe', input='libp3direct.dll')
TargetAdd('p3dcparse.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('p3dcparse.exe', opts=['ADVAPI'])
#
# DIRECTORY: direct/src/plugin/
#
if (RTDIST or RUNTIME):
# Explicitly define this as we don't include dtool_config.h here.
if GetTarget() not in ('windows', 'darwin'):
DefSymbol("RUNTIME", "HAVE_X11", "1")
OPTS=['DIR:direct/src/plugin', 'BUILDING:P3D_PLUGIN', 'RUNTIME', 'OPENSSL']
TargetAdd('plugin_common.obj', opts=OPTS, input='plugin_common_composite1.cxx')
OPTS += ['ZLIB', 'MSIMG']
TargetAdd('plugin_plugin.obj', opts=OPTS, input='p3d_plugin_composite1.cxx')
TargetAdd('plugin_mkdir_complete.obj', opts=OPTS, input='mkdir_complete.cxx')
TargetAdd('plugin_wstring_encode.obj', opts=OPTS, input='wstring_encode.cxx')
TargetAdd('plugin_parse_color.obj', opts=OPTS, input='parse_color.cxx')
TargetAdd('plugin_get_twirl_data.obj', opts=OPTS, input='get_twirl_data.cxx')
TargetAdd('plugin_find_root_dir.obj', opts=OPTS, input='find_root_dir.cxx')
if GetTarget() == 'darwin':
TargetAdd('plugin_find_root_dir_assist.obj', opts=OPTS, input='find_root_dir_assist.mm')
TargetAdd('plugin_binaryXml.obj', opts=OPTS, input='binaryXml.cxx')
TargetAdd('plugin_fileSpec.obj', opts=OPTS, input='fileSpec.cxx')
TargetAdd('plugin_handleStream.obj', opts=OPTS, input='handleStream.cxx')
TargetAdd('plugin_handleStreamBuf.obj', opts=OPTS, input='handleStreamBuf.cxx')
if (RTDIST):
for fname in ("p3d_plugin.dll", "libp3d_plugin_static.ilb"):
TargetAdd(fname, input='plugin_plugin.obj')
TargetAdd(fname, input='plugin_mkdir_complete.obj')
TargetAdd(fname, input='plugin_wstring_encode.obj')
TargetAdd(fname, input='plugin_parse_color.obj')
TargetAdd(fname, input='plugin_find_root_dir.obj')
if GetTarget() == 'darwin':
TargetAdd(fname, input='plugin_find_root_dir_assist.obj')
TargetAdd(fname, input='plugin_fileSpec.obj')
TargetAdd(fname, input='plugin_binaryXml.obj')
TargetAdd(fname, input='plugin_handleStream.obj')
TargetAdd(fname, input='plugin_handleStreamBuf.obj')
TargetAdd(fname, input='libp3tinyxml.ilb')
if GetTarget() == 'darwin':
TargetAdd(fname, input='libp3subprocbuffer.ilb')
TargetAdd(fname, opts=['OPENSSL', 'ZLIB', 'X11', 'ADVAPI', 'WINUSER', 'WINGDI', 'WINSHELL', 'WINCOMCTL', 'WINOLE', 'MSIMG'])
TargetAdd("libp3d_plugin_static.ilb", input='plugin_get_twirl_data.obj')
if (PkgSkip("PYTHON")==0 and RTDIST):
TargetAdd('p3dpython_p3dpython_composite1.obj', opts=OPTS, input='p3dpython_composite1.cxx')
TargetAdd('p3dpython_p3dPythonMain.obj', opts=OPTS, input='p3dPythonMain.cxx')
TargetAdd('p3dpython.exe', input='p3dpython_p3dpython_composite1.obj')
TargetAdd('p3dpython.exe', input='p3dpython_p3dPythonMain.obj')
TargetAdd('p3dpython.exe', input=COMMON_PANDA_LIBS)
TargetAdd('p3dpython.exe', input='libp3tinyxml.ilb')
TargetAdd('p3dpython.exe', opts=['PYTHON', 'WINUSER'])
TargetAdd('libp3dpython.dll', input='p3dpython_p3dpython_composite1.obj')
TargetAdd('libp3dpython.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3dpython.dll', input='libp3tinyxml.ilb')
TargetAdd('libp3dpython.dll', opts=['PYTHON', 'WINUSER'])
if GetTarget() == 'windows':
DefSymbol("NON_CONSOLE", "NON_CONSOLE", "")
OPTS.append("NON_CONSOLE")
TargetAdd('p3dpythonw_p3dpython_composite1.obj', opts=OPTS, input='p3dpython_composite1.cxx')
TargetAdd('p3dpythonw_p3dPythonMain.obj', opts=OPTS, input='p3dPythonMain.cxx')
TargetAdd('p3dpythonw.exe', input='p3dpythonw_p3dpython_composite1.obj')
TargetAdd('p3dpythonw.exe', input='p3dpythonw_p3dPythonMain.obj')
TargetAdd('p3dpythonw.exe', input=COMMON_PANDA_LIBS)
TargetAdd('p3dpythonw.exe', input='libp3tinyxml.ilb')
TargetAdd('p3dpythonw.exe', opts=['SUBSYSTEM:WINDOWS', 'PYTHON', 'WINUSER'])
if (PkgSkip("OPENSSL")==0 and RTDIST):
OPTS=['DIR:direct/src/plugin', 'DIR:panda/src/express', 'OPENSSL']
if GetTarget() == 'darwin':
OPTS += ['OPT:2']
if (PkgSkip("FLTK")==0):
OPTS.append("FLTK")
TargetAdd('plugin_p3dCert.obj', opts=OPTS, input='p3dCert.cxx')
TargetAdd('p3dcert.exe', input='plugin_mkdir_complete.obj')
TargetAdd('p3dcert.exe', input='plugin_wstring_encode.obj')
TargetAdd('p3dcert.exe', input='plugin_p3dCert.obj')
OPTS=['OPENSSL', 'FLTK', 'X11', 'WINCOMCTL', 'WINSOCK', 'WINGDI', 'WINUSER', 'ADVAPI', 'WINOLE', 'WINSHELL', 'SUBSYSTEM:WINDOWS']
if GetTarget() == 'darwin':
OPTS += ['OPT:2']
TargetAdd('p3dcert.exe', opts=OPTS)
elif (PkgSkip("WX")==0):
OPTS.append("WX")
TargetAdd('plugin_p3dCert.obj', opts=OPTS, input='p3dCert_wx.cxx')
TargetAdd('p3dcert.exe', input='plugin_mkdir_complete.obj')
TargetAdd('p3dcert.exe', input='plugin_wstring_encode.obj')
TargetAdd('p3dcert.exe', input='plugin_p3dCert.obj')
OPTS=['OPENSSL', 'WX', 'CARBON', 'WINOLE', 'WINOLEAUT', 'WINUSER', 'ADVAPI', 'WINSHELL', 'WINCOMCTL', 'WINGDI', 'WINCOMDLG']
if GetTarget() == "darwin":
OPTS += ['GL', 'OPT:2']
TargetAdd('p3dcert.exe', opts=OPTS)
#
# DIRECTORY: direct/src/plugin_npapi/
#
if RUNTIME:
OPTS=['DIR:direct/src/plugin_npapi', 'RUNTIME', 'GTK2']
if GetTarget() == 'windows':
nppanda3d_rc = {"name" : "Panda3D Game Engine Plug-in",
"version" : VERSION,
"description" : "Runs 3-D games and interactive applets",
"filename" : "nppanda3d.dll",
"mimetype" : "application/x-panda3d",
"extension" : "p3d",
"filedesc" : "Panda3D applet"}
TargetAdd('nppanda3d.res', opts=OPTS, winrc=nppanda3d_rc)
elif GetTarget() == 'darwin':
TargetAdd('nppanda3d.rsrc', opts=OPTS, input='nppanda3d.r')
OPTS += ['GTK2']
TargetAdd('plugin_npapi_nppanda3d_composite1.obj', opts=OPTS, input='nppanda3d_composite1.cxx')
TargetAdd('nppanda3d.plugin', input='plugin_common.obj')
TargetAdd('nppanda3d.plugin', input='plugin_parse_color.obj')
TargetAdd('nppanda3d.plugin', input='plugin_get_twirl_data.obj')
TargetAdd('nppanda3d.plugin', input='plugin_wstring_encode.obj')
TargetAdd('nppanda3d.plugin', input='plugin_npapi_nppanda3d_composite1.obj')
if GetTarget() == 'windows':
TargetAdd('nppanda3d.plugin', input='nppanda3d.res')
TargetAdd('nppanda3d.plugin', input='nppanda3d.def', ipath=OPTS)
elif GetTarget() == 'darwin':
TargetAdd('nppanda3d.plugin', input='nppanda3d.rsrc')
TargetAdd('nppanda3d.plugin', input='nppanda3d.plist', ipath=OPTS)
TargetAdd('nppanda3d.plugin', input='plugin_find_root_dir_assist.obj')
TargetAdd('nppanda3d.plugin', input='libp3tinyxml.ilb')
TargetAdd('nppanda3d.plugin', opts=['OPENSSL', 'WINGDI', 'WINUSER', 'WINSHELL', 'WINOLE', 'CARBON'])
#
# DIRECTORY: direct/src/plugin_activex/
#
if (RUNTIME and GetTarget() == 'windows' and PkgSkip("MFC")==0):
OPTS=['DIR:direct/src/plugin_activex', 'RUNTIME', 'ACTIVEX', 'MFC']
DefSymbol('ACTIVEX', '_USRDLL', '')
DefSymbol('ACTIVEX', '_WINDLL', '')
DefSymbol('ACTIVEX', '_AFXDLL', '')
DefSymbol('ACTIVEX', '_MBCS', '')
TargetAdd('P3DActiveX.tlb', opts=OPTS, input='P3DActiveX.idl')
TargetAdd('P3DActiveX.res', opts=OPTS, input='P3DActiveX.rc')
TargetAdd('plugin_activex_p3dactivex_composite1.obj', opts=OPTS, input='p3dactivex_composite1.cxx')
TargetAdd('p3dactivex.ocx', input='plugin_common.obj')
TargetAdd('p3dactivex.ocx', input='plugin_parse_color.obj')
TargetAdd('p3dactivex.ocx', input='plugin_get_twirl_data.obj')
TargetAdd('p3dactivex.ocx', input='plugin_wstring_encode.obj')
TargetAdd('p3dactivex.ocx', input='plugin_activex_p3dactivex_composite1.obj')
TargetAdd('p3dactivex.ocx', input='P3DActiveX.res')
TargetAdd('p3dactivex.ocx', input='P3DActiveX.def', ipath=OPTS)
TargetAdd('p3dactivex.ocx', input='libp3tinyxml.ilb')
TargetAdd('p3dactivex.ocx', opts=['MFC', 'WINSOCK2', 'OPENSSL', 'WINGDI', 'WINUSER'])
#
# DIRECTORY: direct/src/plugin_standalone/
#
if (RUNTIME):
OPTS=['DIR:direct/src/plugin_standalone', 'RUNTIME', 'OPENSSL']
TargetAdd('plugin_standalone_panda3d.obj', opts=OPTS, input='panda3d.cxx')
TargetAdd('plugin_standalone_panda3dBase.obj', opts=OPTS, input='panda3dBase.cxx')
if GetTarget() == 'windows':
panda3d_rc = {"name" : "Panda3D Game Engine Plug-in",
"version" : VERSION,
"description" : "Runs 3-D games and interactive applets",
"filename" : "panda3d.exe",
"mimetype" : "application/x-panda3d",
"extension" : "p3d",
"filedesc" : "Panda3D applet",
"icon" : "panda3d.ico"}
TargetAdd('panda3d.res', opts=OPTS, winrc=panda3d_rc)
TargetAdd('plugin_standalone_panda3dMain.obj', opts=OPTS, input='panda3dMain.cxx')
TargetAdd('panda3d.exe', input='plugin_standalone_panda3d.obj')
TargetAdd('panda3d.exe', input='plugin_standalone_panda3dMain.obj')
TargetAdd('panda3d.exe', input='plugin_standalone_panda3dBase.obj')
TargetAdd('panda3d.exe', input='plugin_common.obj')
TargetAdd('panda3d.exe', input='plugin_wstring_encode.obj')
if GetTarget() == 'darwin':
TargetAdd('panda3d.exe', input='plugin_find_root_dir_assist.obj')
elif GetTarget() == 'windows':
TargetAdd('panda3d.exe', input='panda3d.res')
TargetAdd('panda3d.exe', input='libpandaexpress.dll')
TargetAdd('panda3d.exe', input='libp3dtoolconfig.dll')
TargetAdd('panda3d.exe', input='libp3dtool.dll')
TargetAdd('panda3d.exe', input='libp3pystub.lib')
TargetAdd('panda3d.exe', input='libp3tinyxml.ilb')
TargetAdd('panda3d.exe', opts=['NOICON', 'OPENSSL', 'ZLIB', 'WINGDI', 'WINUSER', 'WINSHELL', 'ADVAPI', 'WINSOCK2', 'WINOLE', 'CARBON'])
if (GetTarget() == 'darwin'):
TargetAdd('plugin_standalone_panda3dMac.obj', opts=OPTS, input='panda3dMac.cxx')
TargetAdd('Panda3D.app', input='plugin_standalone_panda3d.obj')
TargetAdd('Panda3D.app', input='plugin_standalone_panda3dMac.obj')
TargetAdd('Panda3D.app', input='plugin_standalone_panda3dBase.obj')
TargetAdd('Panda3D.app', input='plugin_common.obj')
TargetAdd('Panda3D.app', input='plugin_find_root_dir_assist.obj')
TargetAdd('Panda3D.app', input='libpandaexpress.dll')
TargetAdd('Panda3D.app', input='libp3dtoolconfig.dll')
TargetAdd('Panda3D.app', input='libp3dtool.dll')
TargetAdd('Panda3D.app', input='libp3pystub.lib')
TargetAdd('Panda3D.app', input='libp3tinyxml.ilb')
TargetAdd('Panda3D.app', input='panda3d_mac.plist', ipath=OPTS)
TargetAdd('Panda3D.app', input='models/plugin_images/panda3d.icns')
TargetAdd('Panda3D.app', opts=['OPENSSL', 'ZLIB', 'WINGDI', 'WINUSER', 'WINSHELL', 'ADVAPI', 'WINSOCK2', 'WINOLE', 'CARBON'])
elif (GetTarget() == 'windows'):
TargetAdd('plugin_standalone_panda3dWinMain.obj', opts=OPTS, input='panda3dWinMain.cxx')
TargetAdd('panda3dw.exe', input='plugin_standalone_panda3d.obj')
TargetAdd('panda3dw.exe', input='plugin_standalone_panda3dWinMain.obj')
TargetAdd('panda3dw.exe', input='plugin_standalone_panda3dBase.obj')
TargetAdd('panda3dw.exe', input='plugin_wstring_encode.obj')
TargetAdd('panda3dw.exe', input='plugin_common.obj')
TargetAdd('panda3dw.exe', input='libpandaexpress.dll')
TargetAdd('panda3dw.exe', input='libp3dtoolconfig.dll')
TargetAdd('panda3dw.exe', input='libp3dtool.dll')
TargetAdd('panda3dw.exe', input='libp3pystub.lib')
TargetAdd('panda3dw.exe', input='libp3tinyxml.ilb')
TargetAdd('panda3dw.exe', opts=['OPENSSL', 'ZLIB', 'WINGDI', 'WINUSER', 'WINSHELL', 'ADVAPI', 'WINSOCK2', 'WINOLE', 'CARBON'])
if (RTDIST):
OPTS=['BUILDING:P3D_PLUGIN', 'DIR:direct/src/plugin_standalone', 'DIR:direct/src/plugin', 'DIR:dtool/src/dtoolbase', 'DIR:dtool/src/dtoolutil', 'DIR:dtool/src/pystub', 'DIR:dtool/src/prc', 'DIR:dtool/src/dconfig', 'DIR:panda/src/express', 'DIR:panda/src/downloader', 'RUNTIME', 'P3DEMBED', 'OPENSSL', 'ZLIB']
# This is arguably a big fat ugly hack, but doing it otherwise would complicate the build process considerably.
DefSymbol("P3DEMBED", "LINK_ALL_STATIC", "")
TargetAdd('plugin_standalone_panda3dBase.obj', opts=OPTS, input='panda3dBase.cxx')
TargetAdd('plugin_standalone_p3dEmbedMain.obj', opts=OPTS, input='p3dEmbedMain.cxx')
TargetAdd('plugin_standalone_p3dEmbed.obj', opts=OPTS, input='p3dEmbed.cxx')
TargetAdd('plugin_standalone_pystub.obj', opts=OPTS, input='pystub.cxx')
TargetAdd('plugin_standalone_dtoolbase_composite1.obj', opts=OPTS, input='p3dtoolbase_composite1.cxx')
TargetAdd('plugin_standalone_dtoolbase_composite2.obj', opts=OPTS, input='p3dtoolbase_composite2.cxx')
TargetAdd('plugin_standalone_lookup3.obj', opts=OPTS, input='lookup3.c')
TargetAdd('plugin_standalone_indent.obj', opts=OPTS, input='indent.cxx')
TargetAdd('plugin_standalone_dtoolutil_composite1.obj', opts=OPTS, input='p3dtoolutil_composite1.cxx')
TargetAdd('plugin_standalone_dtoolutil_composite2.obj', opts=OPTS, input='p3dtoolutil_composite2.cxx')
if (GetTarget() == 'darwin'):
TargetAdd('plugin_standalone_dtoolutil_filename_assist.obj', opts=OPTS, input='filename_assist.mm')
TargetAdd('plugin_standalone_prc_composite1.obj', opts=OPTS, input='p3prc_composite1.cxx')
TargetAdd('plugin_standalone_prc_composite2.obj', opts=OPTS, input='p3prc_composite2.cxx')
TargetAdd('plugin_standalone_dconfig_composite1.obj', opts=OPTS, input='p3dconfig_composite1.cxx')
TargetAdd('plugin_standalone_express_composite1.obj', opts=OPTS, input='p3express_composite1.cxx')
TargetAdd('plugin_standalone_express_composite2.obj', opts=OPTS, input='p3express_composite2.cxx')
TargetAdd('plugin_standalone_downloader_composite1.obj', opts=OPTS, input='p3downloader_composite1.cxx')
TargetAdd('plugin_standalone_downloader_composite2.obj', opts=OPTS, input='p3downloader_composite2.cxx')
TargetAdd('p3dembed.exe', input='plugin_standalone_panda3dBase.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_p3dEmbedMain.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_p3dEmbed.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_pystub.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_dtoolbase_composite1.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_dtoolbase_composite2.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_lookup3.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_indent.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_dtoolutil_composite1.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_dtoolutil_composite2.obj')
if GetTarget() == 'darwin':
TargetAdd('p3dembed.exe', input='plugin_standalone_dtoolutil_filename_assist.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_prc_composite1.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_prc_composite2.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_dconfig_composite1.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_express_composite1.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_express_composite2.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_downloader_composite1.obj')
TargetAdd('p3dembed.exe', input='plugin_standalone_downloader_composite2.obj')
TargetAdd('p3dembed.exe', input='plugin_common.obj')
if GetTarget() == 'darwin':
TargetAdd('p3dembed.exe', input='plugin_find_root_dir_assist.obj')
TargetAdd('p3dembed.exe', input='libp3subprocbuffer.ilb')
TargetAdd('p3dembed.exe', input='libp3tinyxml.ilb')
TargetAdd('p3dembed.exe', input='libp3d_plugin_static.ilb')
TargetAdd('p3dembed.exe', opts=['NOICON', 'WINGDI', 'WINSOCK2', 'ZLIB', 'WINUSER', 'OPENSSL', 'WINOLE', 'CARBON', 'MSIMG', 'WINCOMCTL', 'ADVAPI', 'WINSHELL', 'X11'])
if GetTarget() == 'windows':
OPTS.append("P3DEMBEDW")
DefSymbol("P3DEMBEDW", "P3DEMBEDW", "")
TargetAdd('plugin_standalone_p3dEmbedWinMain.obj', opts=OPTS, input='p3dEmbedMain.cxx')
TargetAdd('p3dembedw.exe', input='plugin_standalone_panda3dBase.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_p3dEmbedWinMain.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_p3dEmbed.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_pystub.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_dtoolbase_composite1.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_dtoolbase_composite2.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_lookup3.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_indent.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_dtoolutil_composite1.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_dtoolutil_composite2.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_prc_composite1.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_prc_composite2.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_dconfig_composite1.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_express_composite1.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_express_composite2.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_downloader_composite1.obj')
TargetAdd('p3dembedw.exe', input='plugin_standalone_downloader_composite2.obj')
TargetAdd('p3dembedw.exe', input='plugin_common.obj')
TargetAdd('p3dembedw.exe', input='libp3tinyxml.ilb')
TargetAdd('p3dembedw.exe', input='libp3d_plugin_static.ilb')
TargetAdd('p3dembedw.exe', opts=['NOICON', 'WINGDI', 'WINSOCK2', 'ZLIB', 'WINUSER', 'OPENSSL', 'WINOLE', 'MSIMG', 'WINCOMCTL', 'ADVAPI', 'WINSHELL'])
#
# DIRECTORY: pandatool/src/pandatoolbase/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/pandatoolbase']
TargetAdd('p3pandatoolbase_composite1.obj', opts=OPTS, input='p3pandatoolbase_composite1.cxx')
TargetAdd('libp3pandatoolbase.lib', input='p3pandatoolbase_composite1.obj')
#
# DIRECTORY: pandatool/src/converter/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/converter']
TargetAdd('p3converter_somethingToEggConverter.obj', opts=OPTS, input='somethingToEggConverter.cxx')
TargetAdd('p3converter_eggToSomethingConverter.obj', opts=OPTS, input='eggToSomethingConverter.cxx')
TargetAdd('libp3converter.lib', input='p3converter_somethingToEggConverter.obj')
TargetAdd('libp3converter.lib', input='p3converter_eggToSomethingConverter.obj')
#
# DIRECTORY: pandatool/src/progbase/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/progbase', 'ZLIB']
TargetAdd('p3progbase_composite1.obj', opts=OPTS, input='p3progbase_composite1.cxx')
TargetAdd('libp3progbase.lib', input='p3progbase_composite1.obj')
#
# DIRECTORY: pandatool/src/eggbase/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/eggbase']
TargetAdd('p3eggbase_composite1.obj', opts=OPTS, input='p3eggbase_composite1.cxx')
TargetAdd('libp3eggbase.lib', input='p3eggbase_composite1.obj')
#
# DIRECTORY: pandatool/src/bam/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/bam']
TargetAdd('bam-info_bamInfo.obj', opts=OPTS, input='bamInfo.cxx')
TargetAdd('bam-info.exe', input='bam-info_bamInfo.obj')
TargetAdd('bam-info.exe', input='libp3progbase.lib')
TargetAdd('bam-info.exe', input='libp3pandatoolbase.lib')
TargetAdd('bam-info.exe', input='libpandaegg.dll')
TargetAdd('bam-info.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('bam-info.exe', opts=['ADVAPI', 'FFTW'])
TargetAdd('bam2egg_bamToEgg.obj', opts=OPTS, input='bamToEgg.cxx')
TargetAdd('bam2egg.exe', input='bam2egg_bamToEgg.obj')
TargetAdd('bam2egg.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('bam2egg.exe', opts=['ADVAPI', 'FFTW'])
TargetAdd('egg2bam_eggToBam.obj', opts=OPTS, input='eggToBam.cxx')
TargetAdd('egg2bam.exe', input='egg2bam_eggToBam.obj')
TargetAdd('egg2bam.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg2bam.exe', opts=['ADVAPI', 'FFTW'])
#
# DIRECTORY: pandatool/src/cvscopy/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/cvscopy']
TargetAdd('p3cvscopy_composite1.obj', opts=OPTS, input='p3cvscopy_composite1.cxx')
TargetAdd('libp3cvscopy.lib', input='p3cvscopy_composite1.obj')
#
# DIRECTORY: pandatool/src/daeegg/
#
if (PkgSkip("PANDATOOL")==0 and PkgSkip("FCOLLADA")==0):
OPTS=['DIR:pandatool/src/daeegg', 'FCOLLADA']
TargetAdd('p3daeegg_composite1.obj', opts=OPTS, input='p3daeegg_composite1.cxx')
TargetAdd('libp3daeegg.lib', input='p3daeegg_composite1.obj')
TargetAdd('libp3daeegg.lib', opts=['FCOLLADA', 'CARBON'])
#
# DIRECTORY: pandatool/src/assimp
#
if (PkgSkip("PANDATOOL") == 0 and PkgSkip("ASSIMP")==0):
OPTS=['DIR:pandatool/src/assimp', 'BUILDING:ASSIMP', 'ASSIMP', 'MODULE']
TargetAdd('p3assimp_composite1.obj', opts=OPTS, input='p3assimp_composite1.cxx')
TargetAdd('libp3assimp.dll', input='p3assimp_composite1.obj')
TargetAdd('libp3assimp.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3assimp.dll', opts=OPTS)
#
# DIRECTORY: pandatool/src/daeprogs/
#
if (PkgSkip("PANDATOOL")==0 and PkgSkip("FCOLLADA")==0):
OPTS=['DIR:pandatool/src/daeprogs', 'FCOLLADA']
TargetAdd('dae2egg_daeToEgg.obj', opts=OPTS, input='daeToEgg.cxx')
TargetAdd('dae2egg.exe', input='dae2egg_daeToEgg.obj')
TargetAdd('dae2egg.exe', input='libp3daeegg.lib')
TargetAdd('dae2egg.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('dae2egg.exe', opts=['WINUSER', 'FCOLLADA', 'CARBON'])
#
# DIRECTORY: pandatool/src/dxf/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/dxf']
TargetAdd('p3dxf_composite1.obj', opts=OPTS, input='p3dxf_composite1.cxx')
TargetAdd('libp3dxf.lib', input='p3dxf_composite1.obj')
#
# DIRECTORY: pandatool/src/dxfegg/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/dxfegg']
TargetAdd('p3dxfegg_dxfToEggConverter.obj', opts=OPTS, input='dxfToEggConverter.cxx')
TargetAdd('p3dxfegg_dxfToEggLayer.obj', opts=OPTS, input='dxfToEggLayer.cxx')
TargetAdd('libp3dxfegg.lib', input='p3dxfegg_dxfToEggConverter.obj')
TargetAdd('libp3dxfegg.lib', input='p3dxfegg_dxfToEggLayer.obj')
#
# DIRECTORY: pandatool/src/dxfprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/dxfprogs']
TargetAdd('dxf-points_dxfPoints.obj', opts=OPTS, input='dxfPoints.cxx')
TargetAdd('dxf-points.exe', input='dxf-points_dxfPoints.obj')
TargetAdd('dxf-points.exe', input='libp3progbase.lib')
TargetAdd('dxf-points.exe', input='libp3dxf.lib')
TargetAdd('dxf-points.exe', input='libp3pandatoolbase.lib')
TargetAdd('dxf-points.exe', input=COMMON_PANDA_LIBS_PYSTUB)
TargetAdd('dxf-points.exe', opts=['ADVAPI', 'FFTW'])
TargetAdd('dxf2egg_dxfToEgg.obj', opts=OPTS, input='dxfToEgg.cxx')
TargetAdd('dxf2egg.exe', input='dxf2egg_dxfToEgg.obj')
TargetAdd('dxf2egg.exe', input='libp3dxfegg.lib')
TargetAdd('dxf2egg.exe', input='libp3dxf.lib')
TargetAdd('dxf2egg.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('dxf2egg.exe', opts=['ADVAPI', 'FFTW'])
TargetAdd('egg2dxf_eggToDXF.obj', opts=OPTS, input='eggToDXF.cxx')
TargetAdd('egg2dxf_eggToDXFLayer.obj', opts=OPTS, input='eggToDXFLayer.cxx')
TargetAdd('egg2dxf.exe', input='egg2dxf_eggToDXF.obj')
TargetAdd('egg2dxf.exe', input='egg2dxf_eggToDXFLayer.obj')
TargetAdd('egg2dxf.exe', input='libp3dxf.lib')
TargetAdd('egg2dxf.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg2dxf.exe', opts=['ADVAPI', 'FFTW'])
#
# DIRECTORY: pandatool/src/objegg/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/objegg']
TargetAdd('p3objegg_objToEggConverter.obj', opts=OPTS, input='objToEggConverter.cxx')
TargetAdd('p3objegg_eggToObjConverter.obj', opts=OPTS, input='eggToObjConverter.cxx')
TargetAdd('p3objegg_config_objegg.obj', opts=OPTS, input='config_objegg.cxx')
TargetAdd('libp3objegg.lib', input='p3objegg_objToEggConverter.obj')
TargetAdd('libp3objegg.lib', input='p3objegg_eggToObjConverter.obj')
TargetAdd('libp3objegg.lib', input='p3objegg_config_objegg.obj')
#
# DIRECTORY: pandatool/src/objprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/objprogs']
TargetAdd('obj2egg_objToEgg.obj', opts=OPTS, input='objToEgg.cxx')
TargetAdd('obj2egg.exe', input='obj2egg_objToEgg.obj')
TargetAdd('obj2egg.exe', input='libp3objegg.lib')
TargetAdd('obj2egg.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg2obj_eggToObj.obj', opts=OPTS, input='eggToObj.cxx')
TargetAdd('egg2obj.exe', input='egg2obj_eggToObj.obj')
TargetAdd('egg2obj.exe', input='libp3objegg.lib')
TargetAdd('egg2obj.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
#
# DIRECTORY: pandatool/src/palettizer/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/palettizer']
TargetAdd('p3palettizer_composite1.obj', opts=OPTS, input='p3palettizer_composite1.cxx')
TargetAdd('libp3palettizer.lib', input='p3palettizer_composite1.obj')
#
# DIRECTORY: pandatool/src/egg-mkfont/
#
if (PkgSkip("FREETYPE")==0) and (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/egg-mkfont', 'DIR:pandatool/src/palettizer', 'FREETYPE']
TargetAdd('egg-mkfont_eggMakeFont.obj', opts=OPTS, input='eggMakeFont.cxx')
TargetAdd('egg-mkfont_rangeDescription.obj', opts=OPTS, input='rangeDescription.cxx')
TargetAdd('egg-mkfont_rangeIterator.obj', opts=OPTS, input='rangeIterator.cxx')
TargetAdd('egg-mkfont.exe', input='egg-mkfont_eggMakeFont.obj')
TargetAdd('egg-mkfont.exe', input='egg-mkfont_rangeDescription.obj')
TargetAdd('egg-mkfont.exe', input='egg-mkfont_rangeIterator.obj')
TargetAdd('egg-mkfont.exe', input='libp3palettizer.lib')
TargetAdd('egg-mkfont.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-mkfont.exe', opts=['ADVAPI', 'FREETYPE'])
#
# DIRECTORY: pandatool/src/eggcharbase/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/eggcharbase', 'ZLIB']
TargetAdd('p3eggcharbase_composite1.obj', opts=OPTS, input='p3eggcharbase_composite1.cxx')
TargetAdd('libp3eggcharbase.lib', input='p3eggcharbase_composite1.obj')
#
# DIRECTORY: pandatool/src/egg-optchar/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/egg-optchar']
TargetAdd('egg-optchar_config_egg_optchar.obj', opts=OPTS, input='config_egg_optchar.cxx')
TargetAdd('egg-optchar_eggOptchar.obj', opts=OPTS, input='eggOptchar.cxx')
TargetAdd('egg-optchar_eggOptcharUserData.obj', opts=OPTS, input='eggOptcharUserData.cxx')
TargetAdd('egg-optchar_vertexMembership.obj', opts=OPTS, input='vertexMembership.cxx')
TargetAdd('egg-optchar.exe', input='egg-optchar_config_egg_optchar.obj')
TargetAdd('egg-optchar.exe', input='egg-optchar_eggOptchar.obj')
TargetAdd('egg-optchar.exe', input='egg-optchar_eggOptcharUserData.obj')
TargetAdd('egg-optchar.exe', input='egg-optchar_vertexMembership.obj')
TargetAdd('egg-optchar.exe', input='libp3eggcharbase.lib')
TargetAdd('egg-optchar.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-optchar.exe', opts=['ADVAPI', 'FREETYPE'])
#
# DIRECTORY: pandatool/src/egg-palettize/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/egg-palettize', 'DIR:pandatool/src/palettizer']
TargetAdd('egg-palettize_eggPalettize.obj', opts=OPTS, input='eggPalettize.cxx')
TargetAdd('egg-palettize.exe', input='egg-palettize_eggPalettize.obj')
TargetAdd('egg-palettize.exe', input='libp3palettizer.lib')
TargetAdd('egg-palettize.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-palettize.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/egg-qtess/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/egg-qtess']
TargetAdd('egg-qtess_composite1.obj', opts=OPTS, input='egg-qtess_composite1.cxx')
TargetAdd('egg-qtess.exe', input='egg-qtess_composite1.obj')
TargetAdd('egg-qtess.exe', input='libp3eggbase.lib')
TargetAdd('egg-qtess.exe', input='libp3progbase.lib')
TargetAdd('egg-qtess.exe', input='libp3converter.lib')
TargetAdd('egg-qtess.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-qtess.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/eggprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/eggprogs']
TargetAdd('egg-crop_eggCrop.obj', opts=OPTS, input='eggCrop.cxx')
TargetAdd('egg-crop.exe', input='egg-crop_eggCrop.obj')
TargetAdd('egg-crop.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-crop.exe', opts=['ADVAPI'])
TargetAdd('egg-make-tube_eggMakeTube.obj', opts=OPTS, input='eggMakeTube.cxx')
TargetAdd('egg-make-tube.exe', input='egg-make-tube_eggMakeTube.obj')
TargetAdd('egg-make-tube.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-make-tube.exe', opts=['ADVAPI'])
TargetAdd('egg-texture-cards_eggTextureCards.obj', opts=OPTS, input='eggTextureCards.cxx')
TargetAdd('egg-texture-cards.exe', input='egg-texture-cards_eggTextureCards.obj')
TargetAdd('egg-texture-cards.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-texture-cards.exe', opts=['ADVAPI'])
TargetAdd('egg-topstrip_eggTopstrip.obj', opts=OPTS, input='eggTopstrip.cxx')
TargetAdd('egg-topstrip.exe', input='egg-topstrip_eggTopstrip.obj')
TargetAdd('egg-topstrip.exe', input='libp3eggcharbase.lib')
TargetAdd('egg-topstrip.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-topstrip.exe', opts=['ADVAPI'])
TargetAdd('egg-trans_eggTrans.obj', opts=OPTS, input='eggTrans.cxx')
TargetAdd('egg-trans.exe', input='egg-trans_eggTrans.obj')
TargetAdd('egg-trans.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-trans.exe', opts=['ADVAPI'])
TargetAdd('egg2c_eggToC.obj', opts=OPTS, input='eggToC.cxx')
TargetAdd('egg2c.exe', input='egg2c_eggToC.obj')
TargetAdd('egg2c.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg2c.exe', opts=['ADVAPI'])
TargetAdd('egg-rename_eggRename.obj', opts=OPTS, input='eggRename.cxx')
TargetAdd('egg-rename.exe', input='egg-rename_eggRename.obj')
TargetAdd('egg-rename.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-rename.exe', opts=['ADVAPI'])
TargetAdd('egg-retarget-anim_eggRetargetAnim.obj', opts=OPTS, input='eggRetargetAnim.cxx')
TargetAdd('egg-retarget-anim.exe', input='egg-retarget-anim_eggRetargetAnim.obj')
TargetAdd('egg-retarget-anim.exe', input='libp3eggcharbase.lib')
TargetAdd('egg-retarget-anim.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-retarget-anim.exe', opts=['ADVAPI'])
TargetAdd('egg-list-textures_eggListTextures.obj', opts=OPTS, input='eggListTextures.cxx')
TargetAdd('egg-list-textures.exe', input='egg-list-textures_eggListTextures.obj')
TargetAdd('egg-list-textures.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg-list-textures.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/flt/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/flt', 'ZLIB']
TargetAdd('p3flt_composite1.obj', opts=OPTS, input='p3flt_composite1.cxx')
TargetAdd('libp3flt.lib', input=['p3flt_composite1.obj'])
#
# DIRECTORY: pandatool/src/fltegg/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/fltegg']
TargetAdd('p3fltegg_fltToEggConverter.obj', opts=OPTS, input='fltToEggConverter.cxx')
TargetAdd('p3fltegg_fltToEggLevelState.obj', opts=OPTS, input='fltToEggLevelState.cxx')
TargetAdd('libp3fltegg.lib', input=['p3fltegg_fltToEggConverter.obj', 'p3fltegg_fltToEggLevelState.obj'])
#
# DIRECTORY: pandatool/src/fltprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/fltprogs', 'DIR:pandatool/src/flt', 'DIR:pandatool/src/cvscopy']
TargetAdd('egg2flt_eggToFlt.obj', opts=OPTS, input='eggToFlt.cxx')
TargetAdd('egg2flt.exe', input='egg2flt_eggToFlt.obj')
TargetAdd('egg2flt.exe', input='libp3flt.lib')
TargetAdd('egg2flt.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg2flt.exe', opts=['ADVAPI'])
TargetAdd('flt-info_fltInfo.obj', opts=OPTS, input='fltInfo.cxx')
TargetAdd('flt-info.exe', input='flt-info_fltInfo.obj')
TargetAdd('flt-info.exe', input='libp3flt.lib')
TargetAdd('flt-info.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('flt-info.exe', opts=['ADVAPI'])
TargetAdd('flt-trans_fltTrans.obj', opts=OPTS, input='fltTrans.cxx')
TargetAdd('flt-trans.exe', input='flt-trans_fltTrans.obj')
TargetAdd('flt-trans.exe', input='libp3flt.lib')
TargetAdd('flt-trans.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('flt-trans.exe', opts=['ADVAPI'])
TargetAdd('flt2egg_fltToEgg.obj', opts=OPTS, input='fltToEgg.cxx')
TargetAdd('flt2egg.exe', input='flt2egg_fltToEgg.obj')
TargetAdd('flt2egg.exe', input='libp3flt.lib')
TargetAdd('flt2egg.exe', input='libp3fltegg.lib')
TargetAdd('flt2egg.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('flt2egg.exe', opts=['ADVAPI'])
TargetAdd('fltcopy_fltCopy.obj', opts=OPTS, input='fltCopy.cxx')
TargetAdd('fltcopy.exe', input='fltcopy_fltCopy.obj')
TargetAdd('fltcopy.exe', input='libp3cvscopy.lib')
TargetAdd('fltcopy.exe', input='libp3flt.lib')
TargetAdd('fltcopy.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('fltcopy.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/imagebase/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/imagebase']
TargetAdd('p3imagebase_composite1.obj', opts=OPTS, input='p3imagebase_composite1.cxx')
TargetAdd('libp3imagebase.lib', input='p3imagebase_composite1.obj')
#
# DIRECTORY: pandatool/src/imageprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/imageprogs']
TargetAdd('image-info_imageInfo.obj', opts=OPTS, input='imageInfo.cxx')
TargetAdd('image-info.exe', input='image-info_imageInfo.obj')
TargetAdd('image-info.exe', input='libp3imagebase.lib')
TargetAdd('image-info.exe', input='libp3progbase.lib')
TargetAdd('image-info.exe', input='libp3pandatoolbase.lib')
TargetAdd('image-info.exe', input='libpandaegg.dll')
TargetAdd('image-info.exe', input=COMMON_PANDA_LIBS)
TargetAdd('image-info.exe', input='libp3pystub.lib')
TargetAdd('image-info.exe', opts=['ADVAPI'])
TargetAdd('image-resize_imageResize.obj', opts=OPTS, input='imageResize.cxx')
TargetAdd('image-resize.exe', input='image-resize_imageResize.obj')
TargetAdd('image-resize.exe', input='libp3imagebase.lib')
TargetAdd('image-resize.exe', input='libp3progbase.lib')
TargetAdd('image-resize.exe', input='libp3pandatoolbase.lib')
TargetAdd('image-resize.exe', input='libpandaegg.dll')
TargetAdd('image-resize.exe', input=COMMON_PANDA_LIBS)
TargetAdd('image-resize.exe', input='libp3pystub.lib')
TargetAdd('image-resize.exe', opts=['ADVAPI'])
TargetAdd('image-trans_imageTrans.obj', opts=OPTS, input='imageTrans.cxx')
TargetAdd('image-trans.exe', input='image-trans_imageTrans.obj')
TargetAdd('image-trans.exe', input='libp3imagebase.lib')
TargetAdd('image-trans.exe', input='libp3progbase.lib')
TargetAdd('image-trans.exe', input='libp3pandatoolbase.lib')
TargetAdd('image-trans.exe', input='libpandaegg.dll')
TargetAdd('image-trans.exe', input=COMMON_PANDA_LIBS)
TargetAdd('image-trans.exe', input='libp3pystub.lib')
TargetAdd('image-trans.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/pfmprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/pfmprogs']
TargetAdd('pfm-trans_pfmTrans.obj', opts=OPTS, input='pfmTrans.cxx')
TargetAdd('pfm-trans.exe', input='pfm-trans_pfmTrans.obj')
TargetAdd('pfm-trans.exe', input='libp3progbase.lib')
TargetAdd('pfm-trans.exe', input='libp3pandatoolbase.lib')
TargetAdd('pfm-trans.exe', input=COMMON_PANDA_LIBS)
TargetAdd('pfm-trans.exe', input='libp3pystub.lib')
TargetAdd('pfm-trans.exe', opts=['ADVAPI'])
TargetAdd('pfm-bba_pfmBba.obj', opts=OPTS, input='pfmBba.cxx')
TargetAdd('pfm-bba_config_pfm.obj', opts=OPTS, input='config_pfm.cxx')
TargetAdd('pfm-bba.exe', input='pfm-bba_pfmBba.obj')
TargetAdd('pfm-bba.exe', input='pfm-bba_config_pfm.obj')
TargetAdd('pfm-bba.exe', input='libp3progbase.lib')
TargetAdd('pfm-bba.exe', input='libp3pandatoolbase.lib')
TargetAdd('pfm-bba.exe', input=COMMON_PANDA_LIBS)
TargetAdd('pfm-bba.exe', input='libp3pystub.lib')
TargetAdd('pfm-bba.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/lwo/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/lwo']
TargetAdd('p3lwo_composite1.obj', opts=OPTS, input='p3lwo_composite1.cxx')
TargetAdd('libp3lwo.lib', input='p3lwo_composite1.obj')
#
# DIRECTORY: pandatool/src/lwoegg/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/lwoegg']
TargetAdd('p3lwoegg_composite1.obj', opts=OPTS, input='p3lwoegg_composite1.cxx')
TargetAdd('libp3lwoegg.lib', input='p3lwoegg_composite1.obj')
#
# DIRECTORY: pandatool/src/lwoprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/lwoprogs', 'DIR:pandatool/src/lwo']
TargetAdd('lwo-scan_lwoScan.obj', opts=OPTS, input='lwoScan.cxx')
TargetAdd('lwo-scan.exe', input='lwo-scan_lwoScan.obj')
TargetAdd('lwo-scan.exe', input='libp3lwo.lib')
TargetAdd('lwo-scan.exe', input='libp3progbase.lib')
TargetAdd('lwo-scan.exe', input='libp3pandatoolbase.lib')
TargetAdd('lwo-scan.exe', input='libpandaegg.dll')
TargetAdd('lwo-scan.exe', input=COMMON_PANDA_LIBS)
TargetAdd('lwo-scan.exe', input='libp3pystub.lib')
TargetAdd('lwo-scan.exe', opts=['ADVAPI'])
TargetAdd('lwo2egg_lwoToEgg.obj', opts=OPTS, input='lwoToEgg.cxx')
TargetAdd('lwo2egg.exe', input='lwo2egg_lwoToEgg.obj')
TargetAdd('lwo2egg.exe', input='libp3lwo.lib')
TargetAdd('lwo2egg.exe', input='libp3lwoegg.lib')
TargetAdd('lwo2egg.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('lwo2egg.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/maya/
#
for VER in MAYAVERSIONS:
VNUM=VER[4:]
if (PkgSkip(VER)==0) and (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/maya', VER]
TargetAdd('maya'+VNUM+'_composite1.obj', opts=OPTS, input='p3maya_composite1.cxx')
TargetAdd('libmaya'+VNUM+'.lib', input='maya'+VNUM+'_composite1.obj')
#
# DIRECTORY: pandatool/src/mayaegg/
#
for VER in MAYAVERSIONS:
VNUM=VER[4:]
if (PkgSkip(VER)==0) and (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/mayaegg', 'DIR:pandatool/src/maya', VER]
TargetAdd('mayaegg'+VNUM+'_loader.obj', opts=OPTS, input='mayaEggLoader.cxx')
TargetAdd('mayaegg'+VNUM+'_composite1.obj', opts=OPTS, input='p3mayaegg_composite1.cxx')
TargetAdd('libmayaegg'+VNUM+'.lib', input='mayaegg'+VNUM+'_loader.obj')
TargetAdd('libmayaegg'+VNUM+'.lib', input='mayaegg'+VNUM+'_composite1.obj')
#
# DIRECTORY: pandatool/src/maxegg/
#
for VER in MAXVERSIONS:
VNUM=VER[3:]
if (PkgSkip(VER)==0) and (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/maxegg', VER, "WINCOMCTL", "WINCOMDLG", "WINUSER", "MSFORSCOPE", "RTTI"]
TargetAdd('maxEgg'+VNUM+'.res', opts=OPTS, input='maxEgg.rc')
TargetAdd('maxegg'+VNUM+'_loader.obj', opts=OPTS, input='maxEggLoader.cxx')
TargetAdd('maxegg'+VNUM+'_composite1.obj', opts=OPTS, input='p3maxegg_composite1.cxx')
TargetAdd('maxegg'+VNUM+'.dlo', input='maxegg'+VNUM+'_composite1.obj')
TargetAdd('maxegg'+VNUM+'.dlo', input='maxEgg'+VNUM+'.res')
TargetAdd('maxegg'+VNUM+'.dlo', input='maxEgg.def', ipath=OPTS)
TargetAdd('maxegg'+VNUM+'.dlo', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('maxegg'+VNUM+'.dlo', opts=OPTS)
#
# DIRECTORY: pandatool/src/maxprogs/
#
for VER in MAXVERSIONS:
VNUM=VER[3:]
if (PkgSkip(VER)==0) and (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/maxprogs', VER, "WINCOMCTL", "WINCOMDLG", "WINUSER", "MSFORSCOPE", "RTTI"]
TargetAdd('maxImportRes.res', opts=OPTS, input='maxImportRes.rc')
TargetAdd('maxprogs'+VNUM+'_maxeggimport.obj', opts=OPTS, input='maxEggImport.cxx')
TargetAdd('maxeggimport'+VNUM+'.dle', input='maxegg'+VNUM+'_loader.obj')
TargetAdd('maxeggimport'+VNUM+'.dle', input='maxprogs'+VNUM+'_maxeggimport.obj')
TargetAdd('maxeggimport'+VNUM+'.dle', input='libpandaegg.dll')
TargetAdd('maxeggimport'+VNUM+'.dle', input='libpanda.dll')
TargetAdd('maxeggimport'+VNUM+'.dle', input='libpandaexpress.dll')
TargetAdd('maxeggimport'+VNUM+'.dle', input='maxImportRes.res')
TargetAdd('maxeggimport'+VNUM+'.dle', input='maxEggImport.def', ipath=OPTS)
TargetAdd('maxeggimport'+VNUM+'.dle', input=COMMON_DTOOL_LIBS)
TargetAdd('maxeggimport'+VNUM+'.dle', opts=OPTS)
#
# DIRECTORY: pandatool/src/vrml/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/vrml', 'ZLIB', 'BISONPREFIX_vrmlyy']
CreateFile(GetOutputDir()+"/include/vrmlParser.h")
TargetAdd('p3vrml_vrmlParser.obj', opts=OPTS, input='vrmlParser.yxx')
TargetAdd('vrmlParser.h', input='p3vrml_vrmlParser.obj', opts=['DEPENDENCYONLY'])
TargetAdd('p3vrml_vrmlLexer.obj', opts=OPTS, input='vrmlLexer.lxx')
TargetAdd('p3vrml_parse_vrml.obj', opts=OPTS, input='parse_vrml.cxx')
TargetAdd('p3vrml_standard_nodes.obj', opts=OPTS, input='standard_nodes.cxx')
TargetAdd('p3vrml_vrmlNode.obj', opts=OPTS, input='vrmlNode.cxx')
TargetAdd('p3vrml_vrmlNodeType.obj', opts=OPTS, input='vrmlNodeType.cxx')
TargetAdd('libp3vrml.lib', input='p3vrml_parse_vrml.obj')
TargetAdd('libp3vrml.lib', input='p3vrml_standard_nodes.obj')
TargetAdd('libp3vrml.lib', input='p3vrml_vrmlNode.obj')
TargetAdd('libp3vrml.lib', input='p3vrml_vrmlNodeType.obj')
TargetAdd('libp3vrml.lib', input='p3vrml_vrmlParser.obj')
TargetAdd('libp3vrml.lib', input='p3vrml_vrmlLexer.obj')
#
# DIRECTORY: pandatool/src/vrmlegg/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/vrmlegg', 'DIR:pandatool/src/vrml']
TargetAdd('p3vrmlegg_indexedFaceSet.obj', opts=OPTS, input='indexedFaceSet.cxx')
TargetAdd('p3vrmlegg_vrmlAppearance.obj', opts=OPTS, input='vrmlAppearance.cxx')
TargetAdd('p3vrmlegg_vrmlToEggConverter.obj', opts=OPTS, input='vrmlToEggConverter.cxx')
TargetAdd('libp3vrmlegg.lib', input='p3vrmlegg_indexedFaceSet.obj')
TargetAdd('libp3vrmlegg.lib', input='p3vrmlegg_vrmlAppearance.obj')
TargetAdd('libp3vrmlegg.lib', input='p3vrmlegg_vrmlToEggConverter.obj')
#
# DIRECTORY: pandatool/src/xfile/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/xfile', 'ZLIB', 'BISONPREFIX_xyy', 'FLEXDASHI']
CreateFile(GetOutputDir()+"/include/xParser.h")
TargetAdd('p3xfile_xParser.obj', opts=OPTS, input='xParser.yxx')
TargetAdd('xParser.h', input='p3xfile_xParser.obj', opts=['DEPENDENCYONLY'])
TargetAdd('p3xfile_xLexer.obj', opts=OPTS, input='xLexer.lxx')
TargetAdd('p3xfile_composite1.obj', opts=OPTS, input='p3xfile_composite1.cxx')
TargetAdd('libp3xfile.lib', input='p3xfile_composite1.obj')
TargetAdd('libp3xfile.lib', input='p3xfile_xParser.obj')
TargetAdd('libp3xfile.lib', input='p3xfile_xLexer.obj')
#
# DIRECTORY: pandatool/src/xfileegg/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/xfileegg', 'DIR:pandatool/src/xfile']
TargetAdd('p3xfileegg_composite1.obj', opts=OPTS, input='p3xfileegg_composite1.cxx')
TargetAdd('libp3xfileegg.lib', input='p3xfileegg_composite1.obj')
#
# DIRECTORY: pandatool/src/ptloader/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/ptloader', 'DIR:pandatool/src/flt', 'DIR:pandatool/src/lwo', 'DIR:pandatool/src/xfile', 'DIR:pandatool/src/xfileegg', 'DIR:pandatool/src/daeegg', 'BUILDING:PTLOADER', 'FCOLLADA']
TargetAdd('p3ptloader_config_ptloader.obj', opts=OPTS, input='config_ptloader.cxx')
TargetAdd('p3ptloader_loaderFileTypePandatool.obj', opts=OPTS, input='loaderFileTypePandatool.cxx')
TargetAdd('libp3ptloader.dll', input='p3ptloader_config_ptloader.obj')
TargetAdd('libp3ptloader.dll', input='p3ptloader_loaderFileTypePandatool.obj')
TargetAdd('libp3ptloader.dll', input='libp3fltegg.lib')
TargetAdd('libp3ptloader.dll', input='libp3flt.lib')
TargetAdd('libp3ptloader.dll', input='libp3lwoegg.lib')
TargetAdd('libp3ptloader.dll', input='libp3lwo.lib')
TargetAdd('libp3ptloader.dll', input='libp3dxfegg.lib')
TargetAdd('libp3ptloader.dll', input='libp3dxf.lib')
TargetAdd('libp3ptloader.dll', input='libp3objegg.lib')
TargetAdd('libp3ptloader.dll', input='libp3vrmlegg.lib')
TargetAdd('libp3ptloader.dll', input='libp3vrml.lib')
TargetAdd('libp3ptloader.dll', input='libp3xfileegg.lib')
TargetAdd('libp3ptloader.dll', input='libp3xfile.lib')
if (PkgSkip("FCOLLADA")==0): TargetAdd('libp3ptloader.dll', input='libp3daeegg.lib')
TargetAdd('libp3ptloader.dll', input='libp3eggbase.lib')
TargetAdd('libp3ptloader.dll', input='libp3progbase.lib')
TargetAdd('libp3ptloader.dll', input='libp3converter.lib')
TargetAdd('libp3ptloader.dll', input='libp3pandatoolbase.lib')
TargetAdd('libp3ptloader.dll', input='libpandaegg.dll')
TargetAdd('libp3ptloader.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3ptloader.dll', opts=['MODULE', 'ADVAPI', 'FCOLLADA', 'WINUSER'])
#
# DIRECTORY: pandatool/src/miscprogs/
#
# This is a bit of an esoteric tool, and it causes issues because
# it conflicts with tools of the same name in different packages.
#if (PkgSkip("PANDATOOL")==0):
# OPTS=['DIR:pandatool/src/miscprogs']
# TargetAdd('bin2c_binToC.obj', opts=OPTS, input='binToC.cxx')
# TargetAdd('bin2c.exe', input='bin2c_binToC.obj')
# TargetAdd('bin2c.exe', input='libp3progbase.lib')
# TargetAdd('bin2c.exe', input='libp3pandatoolbase.lib')
# TargetAdd('bin2c.exe', input=COMMON_PANDA_LIBS)
# TargetAdd('bin2c.exe', input='libp3pystub.lib')
# TargetAdd('bin2c.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/pstatserver/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/pstatserver']
TargetAdd('p3pstatserver_composite1.obj', opts=OPTS, input='p3pstatserver_composite1.cxx')
TargetAdd('libp3pstatserver.lib', input='p3pstatserver_composite1.obj')
#
# DIRECTORY: pandatool/src/softprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/softprogs', 'OPENSSL']
TargetAdd('softcvs_softCVS.obj', opts=OPTS, input='softCVS.cxx')
TargetAdd('softcvs_softFilename.obj', opts=OPTS, input='softFilename.cxx')
TargetAdd('softcvs.exe', input='softcvs_softCVS.obj')
TargetAdd('softcvs.exe', input='softcvs_softFilename.obj')
TargetAdd('softcvs.exe', input='libp3progbase.lib')
TargetAdd('softcvs.exe', input='libp3pandatoolbase.lib')
TargetAdd('softcvs.exe', input='libpandaegg.dll')
TargetAdd('softcvs.exe', input=COMMON_PANDA_LIBS)
TargetAdd('softcvs.exe', input='libp3pystub.lib')
TargetAdd('softcvs.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/text-stats/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/text-stats']
TargetAdd('text-stats_textMonitor.obj', opts=OPTS, input='textMonitor.cxx')
TargetAdd('text-stats_textStats.obj', opts=OPTS, input='textStats.cxx')
TargetAdd('text-stats.exe', input='text-stats_textMonitor.obj')
TargetAdd('text-stats.exe', input='text-stats_textStats.obj')
TargetAdd('text-stats.exe', input='libp3progbase.lib')
TargetAdd('text-stats.exe', input='libp3pstatserver.lib')
TargetAdd('text-stats.exe', input='libp3pandatoolbase.lib')
TargetAdd('text-stats.exe', input='libpandaegg.dll')
TargetAdd('text-stats.exe', input=COMMON_PANDA_LIBS)
TargetAdd('text-stats.exe', input='libp3pystub.lib')
TargetAdd('text-stats.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/vrmlprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/vrmlprogs', 'DIR:pandatool/src/vrml', 'DIR:pandatool/src/vrmlegg']
TargetAdd('vrml-trans_vrmlTrans.obj', opts=OPTS, input='vrmlTrans.cxx')
TargetAdd('vrml-trans.exe', input='vrml-trans_vrmlTrans.obj')
TargetAdd('vrml-trans.exe', input='libp3vrml.lib')
TargetAdd('vrml-trans.exe', input='libp3progbase.lib')
TargetAdd('vrml-trans.exe', input='libp3pandatoolbase.lib')
TargetAdd('vrml-trans.exe', input=COMMON_PANDA_LIBS)
TargetAdd('vrml-trans.exe', input='libp3pystub.lib')
TargetAdd('vrml-trans.exe', opts=['ADVAPI'])
TargetAdd('vrml2egg_vrmlToEgg.obj', opts=OPTS, input='vrmlToEgg.cxx')
TargetAdd('vrml2egg.exe', input='vrml2egg_vrmlToEgg.obj')
TargetAdd('vrml2egg.exe', input='libp3vrmlegg.lib')
TargetAdd('vrml2egg.exe', input='libp3vrml.lib')
TargetAdd('vrml2egg.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('vrml2egg.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/win-stats/
# DIRECTORY: pandatool/src/gtk-stats/
#
if (PkgSkip("PANDATOOL")==0 and (GetTarget() == 'windows' or PkgSkip("GTK2")==0)):
if GetTarget() == 'windows':
OPTS=['DIR:pandatool/src/win-stats']
TargetAdd('pstats_composite1.obj', opts=OPTS, input='winstats_composite1.cxx')
else:
OPTS=['DIR:pandatool/src/gtk-stats', 'GTK2']
TargetAdd('pstats_composite1.obj', opts=OPTS, input='gtkstats_composite1.cxx')
TargetAdd('pstats.exe', input='pstats_composite1.obj')
TargetAdd('pstats.exe', input='libp3pstatserver.lib')
TargetAdd('pstats.exe', input='libp3progbase.lib')
TargetAdd('pstats.exe', input='libp3pandatoolbase.lib')
TargetAdd('pstats.exe', input=COMMON_PANDA_LIBS)
TargetAdd('pstats.exe', input='libp3pystub.lib')
TargetAdd('pstats.exe', opts=['WINSOCK', 'WINIMM', 'WINGDI', 'WINKERNEL', 'WINOLDNAMES', 'WINUSER', 'WINMM', 'GTK2'])
#
# DIRECTORY: pandatool/src/xfileprogs/
#
if (PkgSkip("PANDATOOL")==0):
OPTS=['DIR:pandatool/src/xfileprogs', 'DIR:pandatool/src/xfile', 'DIR:pandatool/src/xfileegg']
TargetAdd('egg2x_eggToX.obj', opts=OPTS, input='eggToX.cxx')
TargetAdd('egg2x.exe', input='egg2x_eggToX.obj')
TargetAdd('egg2x.exe', input='libp3xfileegg.lib')
TargetAdd('egg2x.exe', input='libp3xfile.lib')
TargetAdd('egg2x.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('egg2x.exe', opts=['ADVAPI'])
TargetAdd('x-trans_xFileTrans.obj', opts=OPTS, input='xFileTrans.cxx')
TargetAdd('x-trans.exe', input='x-trans_xFileTrans.obj')
TargetAdd('x-trans.exe', input='libp3progbase.lib')
TargetAdd('x-trans.exe', input='libp3xfile.lib')
TargetAdd('x-trans.exe', input='libp3pandatoolbase.lib')
TargetAdd('x-trans.exe', input=COMMON_PANDA_LIBS)
TargetAdd('x-trans.exe', input='libp3pystub.lib')
TargetAdd('x-trans.exe', opts=['ADVAPI'])
TargetAdd('x2egg_xFileToEgg.obj', opts=OPTS, input='xFileToEgg.cxx')
TargetAdd('x2egg.exe', input='x2egg_xFileToEgg.obj')
TargetAdd('x2egg.exe', input='libp3xfileegg.lib')
TargetAdd('x2egg.exe', input='libp3xfile.lib')
TargetAdd('x2egg.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
TargetAdd('x2egg.exe', opts=['ADVAPI'])
#
# DIRECTORY: pandatool/src/mayaprogs/
#
for VER in MAYAVERSIONS:
VNUM = VER[4:]
if not PkgSkip(VER) and not PkgSkip("PANDATOOL"):
if GetTarget() == 'darwin' and int(VNUM) >= 2012:
ARCH_OPTS = ['NOARCH:PPC', 'NOARCH:I386']
if len(OSX_ARCHS) != 0 and 'x86_64' not in OSX_ARCHS:
continue
elif GetTarget() == 'darwin' and int(VNUM) >= 2009:
ARCH_OPTS = ['NOARCH:PPC']
else:
ARCH_OPTS = []
OPTS=['DIR:pandatool/src/mayaprogs', 'DIR:pandatool/src/maya', 'DIR:pandatool/src/mayaegg', 'DIR:pandatool/src/cvscopy', 'BUILDING:MISC', VER] + ARCH_OPTS
TargetAdd('mayaeggimport'+VNUM+'_mayaeggimport.obj', opts=OPTS, input='mayaEggImport.cxx')
TargetAdd('mayaeggimport'+VNUM+'.mll', input='mayaegg'+VNUM+'_loader.obj')
TargetAdd('mayaeggimport'+VNUM+'.mll', input='mayaeggimport'+VNUM+'_mayaeggimport.obj')
TargetAdd('mayaeggimport'+VNUM+'.mll', input='libpandaegg.dll')
TargetAdd('mayaeggimport'+VNUM+'.mll', input=COMMON_PANDA_LIBS)
if GetTarget() == 'windows':
TargetAdd('mayaeggimport'+VNUM+'.mll', input='libp3pystub.lib')
TargetAdd('mayaeggimport'+VNUM+'.mll', opts=['ADVAPI', VER]+ARCH_OPTS)
TargetAdd('mayaloader'+VNUM+'_config_mayaloader.obj', opts=OPTS, input='config_mayaloader.cxx')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='mayaloader'+VNUM+'_config_mayaloader.obj')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libmayaegg'+VNUM+'.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3ptloader.dll')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libmaya'+VNUM+'.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3fltegg.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3flt.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3lwoegg.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3lwo.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3dxfegg.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3dxf.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3objegg.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3vrmlegg.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3vrml.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3xfileegg.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3xfile.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3eggbase.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3progbase.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3converter.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libp3pandatoolbase.lib')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input='libpandaegg.dll')
TargetAdd('libp3mayaloader'+VNUM+'.dll', input=COMMON_PANDA_LIBS)
TargetAdd('libp3mayaloader'+VNUM+'.dll', opts=['ADVAPI', VER]+ARCH_OPTS)
TargetAdd('mayapview'+VNUM+'_mayaPview.obj', opts=OPTS, input='mayaPview.cxx')
TargetAdd('libmayapview'+VNUM+'.mll', input='mayapview'+VNUM+'_mayaPview.obj')
TargetAdd('libmayapview'+VNUM+'.mll', input='libmayaegg'+VNUM+'.lib')
TargetAdd('libmayapview'+VNUM+'.mll', input='libmaya'+VNUM+'.lib')
TargetAdd('libmayapview'+VNUM+'.mll', input='libp3framework.dll')
if GetTarget() == 'windows':
TargetAdd('libmayapview'+VNUM+'.mll', input=COMMON_EGG2X_LIBS_PYSTUB)
else:
TargetAdd('libmayapview'+VNUM+'.mll', input=COMMON_EGG2X_LIBS)
TargetAdd('libmayapview'+VNUM+'.mll', opts=['ADVAPI', VER]+ARCH_OPTS)
TargetAdd('maya2egg'+VNUM+'_mayaToEgg.obj', opts=OPTS, input='mayaToEgg.cxx')
TargetAdd('maya2egg'+VNUM+'_bin.exe', input='maya2egg'+VNUM+'_mayaToEgg.obj')
TargetAdd('maya2egg'+VNUM+'_bin.exe', input='libmayaegg'+VNUM+'.lib')
TargetAdd('maya2egg'+VNUM+'_bin.exe', input='libmaya'+VNUM+'.lib')
if GetTarget() == 'windows':
TargetAdd('maya2egg'+VNUM+'_bin.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
else:
TargetAdd('maya2egg'+VNUM+'_bin.exe', input=COMMON_EGG2X_LIBS)
TargetAdd('maya2egg'+VNUM+'_bin.exe', opts=['ADVAPI', VER]+ARCH_OPTS)
TargetAdd('egg2maya'+VNUM+'_eggToMaya.obj', opts=OPTS, input='eggToMaya.cxx')
TargetAdd('egg2maya'+VNUM+'_bin.exe', input='egg2maya'+VNUM+'_eggToMaya.obj')
TargetAdd('egg2maya'+VNUM+'_bin.exe', input='libmayaegg'+VNUM+'.lib')
TargetAdd('egg2maya'+VNUM+'_bin.exe', input='libmaya'+VNUM+'.lib')
if GetTarget() == 'windows':
TargetAdd('egg2maya'+VNUM+'_bin.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
else:
TargetAdd('egg2maya'+VNUM+'_bin.exe', input=COMMON_EGG2X_LIBS)
TargetAdd('egg2maya'+VNUM+'_bin.exe', opts=['ADVAPI', VER]+ARCH_OPTS)
TargetAdd('mayacopy'+VNUM+'_mayaCopy.obj', opts=OPTS, input='mayaCopy.cxx')
TargetAdd('mayacopy'+VNUM+'_bin.exe', input='mayacopy'+VNUM+'_mayaCopy.obj')
TargetAdd('mayacopy'+VNUM+'_bin.exe', input='libp3cvscopy.lib')
TargetAdd('mayacopy'+VNUM+'_bin.exe', input='libmaya'+VNUM+'.lib')
if GetTarget() == 'windows':
TargetAdd('mayacopy'+VNUM+'_bin.exe', input=COMMON_EGG2X_LIBS_PYSTUB)
else:
TargetAdd('mayacopy'+VNUM+'_bin.exe', input=COMMON_EGG2X_LIBS)
TargetAdd('mayacopy'+VNUM+'_bin.exe', opts=['ADVAPI', VER]+ARCH_OPTS)
TargetAdd('mayasavepview'+VNUM+'_mayaSavePview.obj', opts=OPTS, input='mayaSavePview.cxx')
TargetAdd('libmayasavepview'+VNUM+'.mll', input='mayasavepview'+VNUM+'_mayaSavePview.obj')
TargetAdd('libmayasavepview'+VNUM+'.mll', opts=['ADVAPI', VER]+ARCH_OPTS)
TargetAdd('mayapath'+VNUM+'.obj', opts=OPTS, input='mayapath.cxx')
TargetAdd('maya2egg'+VNUM+'.exe', input='mayapath'+VNUM+'.obj')
TargetAdd('maya2egg'+VNUM+'.exe', input='libpandaexpress.dll')
TargetAdd('maya2egg'+VNUM+'.exe', input=COMMON_DTOOL_LIBS_PYSTUB)
TargetAdd('maya2egg'+VNUM+'.exe', opts=['ADVAPI']+ARCH_OPTS)
TargetAdd('egg2maya'+VNUM+'.exe', input='mayapath'+VNUM+'.obj')
TargetAdd('egg2maya'+VNUM+'.exe', input='libpandaexpress.dll')
TargetAdd('egg2maya'+VNUM+'.exe', input=COMMON_DTOOL_LIBS_PYSTUB)
TargetAdd('egg2maya'+VNUM+'.exe', opts=['ADVAPI']+ARCH_OPTS)
TargetAdd('mayacopy'+VNUM+'.exe', input='mayapath'+VNUM+'.obj')
TargetAdd('mayacopy'+VNUM+'.exe', input='libpandaexpress.dll')
TargetAdd('mayacopy'+VNUM+'.exe', input=COMMON_DTOOL_LIBS_PYSTUB)
TargetAdd('mayacopy'+VNUM+'.exe', opts=['ADVAPI']+ARCH_OPTS)
#
# DIRECTORY: contrib/src/ai/
#
if (PkgSkip("CONTRIB")==0 and not RUNTIME):
OPTS=['DIR:contrib/src/ai', 'BUILDING:PANDAAI']
TargetAdd('p3ai_composite1.obj', opts=OPTS, input='p3ai_composite1.cxx')
TargetAdd('libpandaai.dll', input='p3ai_composite1.obj')
TargetAdd('libpandaai.dll', input=COMMON_PANDA_LIBS)
OPTS=['DIR:contrib/src/ai']
IGATEFILES=GetDirectoryContents('contrib/src/ai', ["*.h", "*_composite*.cxx"])
TargetAdd('libpandaai.in', opts=OPTS, input=IGATEFILES)
TargetAdd('libpandaai.in', opts=['IMOD:panda3d.ai', 'ILIB:libpandaai', 'SRCDIR:contrib/src/ai'])
TargetAdd('libpandaai_igate.obj', input='libpandaai.in', opts=["DEPENDENCYONLY"])
TargetAdd('ai_module.obj', input='libpandaai.in')
TargetAdd('ai_module.obj', opts=OPTS)
TargetAdd('ai_module.obj', opts=['IMOD:panda3d.ai', 'ILIB:ai', 'IMPORT:panda3d._core'])
TargetAdd('ai.pyd', input='ai_module.obj')
TargetAdd('ai.pyd', input='libpandaai_igate.obj')
TargetAdd('ai.pyd', input='libpandaai.dll')
TargetAdd('ai.pyd', input='libp3interrogatedb.dll')
TargetAdd('ai.pyd', input=COMMON_PANDA_LIBS)
TargetAdd('ai.pyd', opts=['PYTHON'])
#
# Generate the models directory and samples directory
#
if (PkgSkip("DIRECT")==0 and not RUNTIME):
model_extensions = ["*.egg"]
# Check if we have access to an flt2egg utility, either self-compiled or on the system.
if ((PkgSkip("PANDATOOL")==0 and GetHost()==GetTarget()) or LocateBinary('flt2egg')):
model_extensions.append("*.flt")
for model in GetDirectoryContents("dmodels/src/misc", model_extensions):
if (PkgSkip("ZLIB")==0 and PkgSkip("DEPLOYTOOLS")==0 and not RTDIST):
newname = model[:-4] + ".egg.pz"
else:
newname = model[:-4] + ".egg"
TargetAdd(GetOutputDir()+"/models/misc/"+newname, input="dmodels/src/misc/"+model)
for model in GetDirectoryContents("dmodels/src/gui", model_extensions):
if (PkgSkip("ZLIB")==0 and PkgSkip("DEPLOYTOOLS")==0 and not RTDIST):
newname = model[:-4] + ".egg.pz"
else:
newname = model[:-4] + ".egg"
TargetAdd(GetOutputDir()+"/models/gui/"+newname, input="dmodels/src/gui/"+model)
for model in GetDirectoryContents("models", model_extensions):
if (PkgSkip("ZLIB")==0 and PkgSkip("DEPLOYTOOLS")==0 and not RTDIST):
newname = model[:-4] + ".egg.pz"
else:
newname = model[:-4] + ".egg"
TargetAdd(GetOutputDir()+"/models/"+newname, input="models/"+model)
CopyAllFiles(GetOutputDir()+"/models/audio/sfx/", "dmodels/src/audio/sfx/", ".wav")
CopyAllFiles(GetOutputDir()+"/models/icons/", "dmodels/src/icons/", ".gif")
CopyAllFiles(GetOutputDir()+"/models/maps/", "models/maps/", ".jpg")
CopyAllFiles(GetOutputDir()+"/models/maps/", "models/maps/", ".png")
CopyAllFiles(GetOutputDir()+"/models/maps/", "models/maps/", ".rgb")
CopyAllFiles(GetOutputDir()+"/models/maps/", "models/maps/", ".rgba")
CopyAllFiles(GetOutputDir()+"/models/maps/", "dmodels/src/maps/", ".jpg")
CopyAllFiles(GetOutputDir()+"/models/maps/", "dmodels/src/maps/", ".png")
CopyAllFiles(GetOutputDir()+"/models/maps/", "dmodels/src/maps/", ".rgb")
CopyAllFiles(GetOutputDir()+"/models/maps/", "dmodels/src/maps/", ".rgba")
#
# Build the rtdist.
#
if (RTDIST):
OPTS=['DIR:direct/src/p3d']
TargetAdd('_panda3d', opts=OPTS, input='panda3d.pdef')
TargetAdd('_coreapi', opts=OPTS, input='coreapi.pdef')
TargetAdd('_thirdparty', opts=OPTS, input='thirdparty.pdef')
#
# Distribute prebuilt .p3d files as executable.
#
if (PkgSkip("DIRECT")==0 and not RUNTIME and not RTDIST):
if GetTarget() == 'windows':
OPTS=['DIR:direct/src/p3d']
TargetAdd('p3dWrapper.obj', opts=OPTS, input='p3dWrapper.c')
TargetAdd('p3dWrapper.exe', input='p3dWrapper.obj')
TargetAdd('p3dWrapper.exe', opts=["ADVAPI"])
for g in glob.glob("direct/src/p3d/*.p3d"):
base = os.path.basename(g)
base = base.split(".", 1)[0]
if GetTarget() == 'windows':
TargetAdd(base+".exe", input='p3dWrapper.exe')
CopyFile(GetOutputDir()+"/bin/"+base+".p3d", g)
else:
CopyFile(GetOutputDir()+"/bin/"+base, g)
oscmd("chmod +x "+GetOutputDir()+"/bin/"+base)
##########################################################################################
#
# Dependency-Based Distributed Build System.
#
##########################################################################################
DEPENDENCYQUEUE=[]
for target in TARGET_LIST:
name = target.name
inputs = target.inputs
opts = target.opts
deps = target.deps
DEPENDENCYQUEUE.append([CompileAnything, [name, inputs, opts], [name], deps, []])
def BuildWorker(taskqueue, donequeue):
while True:
try:
task = taskqueue.get(timeout=1)
except:
ProgressOutput(None, "Waiting for tasks...")
task = taskqueue.get()
sys.stdout.flush()
if (task == 0): return
try:
task[0](*task[1])
donequeue.put(task)
except:
donequeue.put(0)
def AllSourcesReady(task, pending):
sources = task[3]
for x in sources:
if (x in pending):
return 0
sources = task[1][1]
for x in sources:
if (x in pending):
return 0
altsources = task[4]
for x in altsources:
if (x in pending):
return 0
return 1
def ParallelMake(tasklist):
# Create the communication queues.
donequeue = queue.Queue()
taskqueue = queue.Queue()
# Build up a table listing all the pending targets
#task = [CompileAnything, [name, inputs, opts], [name], deps, []]
# task[2] = [name]
# task[3] = deps
# The python tool package, in particular fltegg seems to throw parallelmake off
# A hack for now is to divide the tasklist into two parts, one to be built in parallel
# and another subpart to be built sequentially. The most time consuming part of the process
# is the c++ code generation anyways.
tasklist_seq = []
i = 0
while i < len(tasklist):
if tasklist[i][2][0].endswith('.egg') | tasklist[i][2][0].endswith('.egg.pz'):
break
i += 1
if i < len(tasklist):
tasklist_seq = tasklist[i:]
tasklist = tasklist[:i]
iNumStartingTasks = len(tasklist)
pending = {}
for task in tasklist:
for target in task[2]:
pending[target] = 1
# Create the workers
for slave in range(THREADCOUNT):
th = threading.Thread(target=BuildWorker, args=[taskqueue, donequeue])
th.setDaemon(1)
th.start()
# Feed tasks to the workers.
tasksqueued = 0
while True:
if (tasksqueued < THREADCOUNT):
extras = []
for task in tasklist:
if (tasksqueued < THREADCOUNT) and (AllSourcesReady(task, pending)):
if (NeedsBuild(task[2], task[3])):
tasksqueued += 1
taskqueue.put(task)
else:
for target in task[2]:
del pending[target]
else:
extras.append(task)
tasklist = extras
sys.stdout.flush()
if (tasksqueued == 0): break
donetask = donequeue.get()
if (donetask == 0):
exit("Build process aborting.")
sys.stdout.flush()
tasksqueued -= 1
JustBuilt(donetask[2], donetask[3])
for target in donetask[2]:
del pending[target]
# Kill the workers.
for slave in range(THREADCOUNT):
taskqueue.put(0)
# Make sure there aren't any unsatisfied tasks
if len(tasklist) > 0:
exit("Dependency problems: " + str(len(tasklist)) + " tasks not finished. First task unsatisfied: "+str(tasklist[0][2]))
SequentialMake(tasklist_seq)
def SequentialMake(tasklist):
i = 0
for task in tasklist:
if (NeedsBuild(task[2], task[3])):
task[0](*task[1] + [(i * 100.0) / len(tasklist)])
JustBuilt(task[2], task[3])
i += 1
def RunDependencyQueue(tasklist):
if (THREADCOUNT!=0):
ParallelMake(tasklist)
else:
SequentialMake(tasklist)
try:
RunDependencyQueue(DEPENDENCYQUEUE)
except:
SaveDependencyCache()
raise
##########################################################################################
#
# The Installers
#
# Under windows, we can build an 'exe' package using NSIS
# Under linux, we can build a 'deb' package or an 'rpm' package.
# Under OSX, we can make a 'dmg' package.
#
##########################################################################################
def MakeInstallerNSIS(file, title, installdir):
if (os.path.isfile(file)):
os.remove(file)
elif (os.path.isdir(file)):
shutil.rmtree(file)
if GetTargetArch() == 'x64':
regview = '64'
else:
regview = '32'
if (RUNTIME):
# Invoke the make_installer script.
AddToPathEnv("PATH", GetOutputDir() + "\\bin")
AddToPathEnv("PATH", GetOutputDir() + "\\plugins")
cmd = sys.executable + " -B -u direct\\src\\plugin_installer\\make_installer.py"
cmd += " --version %s --regview %s" % (VERSION, regview)
if GetTargetArch() == 'x64':
cmd += " --install \"$PROGRAMFILES64\\Panda3D\" "
else:
cmd += " --install \"$PROGRAMFILES32\\Panda3D\" "
oscmd(cmd)
shutil.move("direct\\src\\plugin_installer\\p3d-setup.exe", file)
return
print("Building "+title+" installer at %s" % (file))
if (COMPRESSOR != "lzma"):
print("Note: you are using zlib, which is faster, but lzma gives better compression.")
if (os.path.exists("nsis-output.exe")):
os.remove("nsis-output.exe")
WriteFile(GetOutputDir()+"/tmp/__init__.py", "")
psource = os.path.abspath(".")
panda = os.path.abspath(GetOutputDir())
nsis_defs = {
'COMPRESSOR' : COMPRESSOR,
'TITLE' : title,
'INSTALLDIR' : installdir,
'OUTFILE' : os.path.join(psource, 'nsis-output.exe'),
'LICENSE' : os.path.join(panda, 'LICENSE'),
'BUILT' : panda,
'SOURCE' : psource,
'PYVER' : SDK["PYTHONVERSION"][6:9],
'PYEXTRAS' : os.path.join(os.path.abspath(GetThirdpartyBase()), 'win-extras'),
'REGVIEW' : regview,
}
if GetHost() == 'windows':
cmd = os.path.join(GetThirdpartyBase(), 'win-nsis', 'makensis') + ' /V2'
for item in nsis_defs.items():
cmd += ' /D%s="%s"' % item
else:
cmd = 'makensis -V2'
for item in nsis_defs.items():
cmd += ' -D%s="%s"' % item
cmd += ' "%s"' % (os.path.join(psource, 'makepanda', 'installer.nsi'))
oscmd(cmd)
os.rename("nsis-output.exe", file)
INSTALLER_DEB_FILE="""
Package: panda3dMAJOR
Version: VERSION
Section: libdevel
Priority: optional
Architecture: ARCH
Essential: no
Depends: DEPENDS
Recommends: RECOMMENDS
Suggests: panda3d-runtime
Provides: panda3d
Conflicts: panda3d
Replaces: panda3d
Maintainer: rdb <me@rdb.name>
Installed-Size: INSTSIZE
Description: Panda3D free 3D engine SDK
Panda3D is a game engine which includes graphics, audio, I/O, collision detection, and other abilities relevant to the creation of 3D games. Panda3D is open source and free software under the revised BSD license, and can be used for both free and commercial game development at no financial cost.
Panda3D's intended game-development language is Python. The engine itself is written in C++, and utilizes an automatic wrapper-generator to expose the complete functionality of the engine in a Python interface.
.
This package contains the SDK for development with Panda3D, install panda3d-runtime for the runtime files.
"""
RUNTIME_INSTALLER_DEB_FILE="""
Package: panda3d-runtime
Version: VERSION
Section: web
Priority: optional
Architecture: ARCH
Essential: no
Depends: DEPENDS
Provides: panda3d-runtime
Maintainer: rdb <me@rdb.name>
Installed-Size: INSTSIZE
Description: Runtime binary and browser plugin for the Panda3D Game Engine
This package contains the runtime distribution and browser plugin of the Panda3D engine. It allows you view webpages that contain Panda3D content and to run games created with Panda3D that are packaged as .p3d file.
"""
# We're not putting "python" in the "Requires" field,
# since the rpm-based distros don't have a common
# naming for the Python package.
INSTALLER_SPEC_FILE="""
Summary: The Panda3D free 3D engine SDK
Name: panda3d
Version: VERSION
Release: RPMRELEASE
License: BSD License
Group: Development/Libraries
BuildRoot: PANDASOURCE/targetroot
%description
Panda3D is a game engine which includes graphics, audio, I/O, collision detection, and other abilities relevant to the creation of 3D games. Panda3D is open source and free software under the revised BSD license, and can be used for both free and commercial game development at no financial cost.
Panda3D's intended game-development language is Python. The engine itself is written in C++, and utilizes an automatic wrapper-generator to expose the complete functionality of the engine in a Python interface.
This package contains the SDK for development with Panda3D, install panda3d-runtime for the runtime files.
%post
/sbin/ldconfig
%postun
/sbin/ldconfig
%files
%defattr(-,root,root)
/etc/Confauto.prc
/etc/Config.prc
/usr/share/panda3d
/usr/share/mime-info/panda3d.mime
/usr/share/mime-info/panda3d.keys
/usr/share/mime/packages/panda3d.xml
/usr/share/application-registry/panda3d.applications
/usr/share/applications/*.desktop
/etc/ld.so.conf.d/panda3d.conf
/usr/%_lib/panda3d
""" + PYTHON_SITEPACKAGES + """
/usr/include/panda3d
"""
RUNTIME_INSTALLER_SPEC_FILE="""
Summary: Runtime binary and browser plugin for the Panda3D Game Engine
Name: panda3d-runtime
Version: VERSION
Release: RPMRELEASE
License: BSD License
Group: Productivity/Graphics/Other
BuildRoot: PANDASOURCE/targetroot
%description
This package contains the runtime distribution and browser plugin of the Panda3D engine. It allows you view webpages that contain Panda3D content and to run games created with Panda3D that are packaged as .p3d file.
%files
%defattr(-,root,root)
/usr/bin/panda3d
/usr/%_lib/nppanda3d.so
/usr/%_lib/mozilla/plugins/nppanda3d.so
/usr/%_lib/mozilla-firefox/plugins/nppanda3d.so
/usr/%_lib/xulrunner-addons/plugins/nppanda3d.so
/usr/share/mime-info/panda3d-runtime.mime
/usr/share/mime-info/panda3d-runtime.keys
/usr/share/mime/packages/panda3d-runtime.xml
/usr/share/application-registry/panda3d-runtime.applications
/usr/share/applications/*.desktop
"""
# plist file for Mac OSX
Info_plist = """<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleIdentifier</key>
<string>%(package_id)s</string>
<key>CFBundleShortVersionString</key>
<string>%(version)s</string>
<key>IFPkgFlagRelocatable</key>
<false/>
<key>IFPkgFlagAuthorizationAction</key>
<string>RootAuthorization</string>
<key>IFPkgFlagAllowBackRev</key>
<true/>
</dict>
</plist>
"""
# FreeBSD pkg-descr
INSTALLER_PKG_DESCR_FILE = """
Panda3D is a game engine which includes graphics, audio, I/O, collision detection, and other abilities relevant to the creation of 3D games. Panda3D is open source and free software under the revised BSD license, and can be used for both free and commercial game development at no financial cost.
Panda3D's intended game-development language is Python. The engine itself is written in C++, and utilizes an automatic wrapper-generator to expose the complete functionality of the engine in a Python interface.
This package contains the SDK for development with Panda3D, install panda3d-runtime for the runtime files.
WWW: http://www.panda3d.org/
"""
def MakeInstallerLinux():
if not RUNTIME and not PkgSkip("PYTHON"):
PYTHONV = SDK["PYTHONVERSION"]
else:
PYTHONV = "python"
PV = PYTHONV.replace("python", "")
# Clean and set up a directory to install Panda3D into
oscmd("rm -rf targetroot data.tar.gz control.tar.gz panda3d.spec")
oscmd("mkdir --mode=0755 targetroot")
dpkg_present = False
if os.path.exists("/usr/bin/dpkg-architecture") and os.path.exists("/usr/bin/dpkg-deb"):
dpkg_present = True
rpmbuild_present = False
if os.path.exists("/usr/bin/rpmbuild"):
rpmbuild_present = True
if dpkg_present and rpmbuild_present:
print("Warning: both dpkg and rpmbuild present.")
if dpkg_present:
# Invoke installpanda.py to install it into a temporary dir
lib_dir = GetDebLibDir()
if RUNTIME:
InstallRuntime(destdir="targetroot", prefix="/usr", outputdir=GetOutputDir(), libdir=lib_dir)
else:
InstallPanda(destdir="targetroot", prefix="/usr", outputdir=GetOutputDir(), libdir=lib_dir)
oscmd("chmod -R 755 targetroot/usr/share/panda3d")
oscmd("mkdir -p targetroot/usr/share/man/man1")
oscmd("cp doc/man/*.1 targetroot/usr/share/man/man1/")
oscmd("dpkg --print-architecture > "+GetOutputDir()+"/tmp/architecture.txt")
pkg_arch = ReadFile(GetOutputDir()+"/tmp/architecture.txt").strip()
if (RUNTIME):
txt = RUNTIME_INSTALLER_DEB_FILE[1:]
else:
txt = INSTALLER_DEB_FILE[1:]
txt = txt.replace("VERSION", DEBVERSION).replace("ARCH", pkg_arch).replace("PV", PV).replace("MAJOR", MAJOR_VERSION)
txt = txt.replace("INSTSIZE", str(GetDirectorySize("targetroot") / 1024))
oscmd("mkdir --mode=0755 -p targetroot/DEBIAN")
oscmd("cd targetroot ; (find usr -type f -exec md5sum {} \;) > DEBIAN/md5sums")
if (not RUNTIME):
oscmd("cd targetroot ; (find etc -type f -exec md5sum {} \;) >> DEBIAN/md5sums")
WriteFile("targetroot/DEBIAN/conffiles","/etc/Config.prc\n")
WriteFile("targetroot/DEBIAN/postinst","#!/bin/sh\necho running ldconfig\nldconfig\n")
oscmd("cp targetroot/DEBIAN/postinst targetroot/DEBIAN/postrm")
# Determine the package name and the locations that
# dpkg-shlibdeps should look in for executables.
pkg_version = DEBVERSION
if RUNTIME:
pkg_name = "panda3d-runtime"
lib_pattern = "debian/%s/usr/%s/*.so" % (pkg_name, lib_dir)
else:
pkg_name = "panda3d" + MAJOR_VERSION
lib_pattern = "debian/%s/usr/%s/panda3d/*.so*" % (pkg_name, lib_dir)
bin_pattern = "debian/%s/usr/bin/*" % (pkg_name)
# dpkg-shlibdeps looks in the debian/{pkg_name}/DEBIAN/shlibs directory
# and also expects a debian/control file, so we create this dummy set-up.
oscmd("mkdir targetroot/debian")
oscmd("ln -s .. targetroot/debian/" + pkg_name)
WriteFile("targetroot/debian/control", "")
dpkg_shlibdeps = "dpkg-shlibdeps"
if GetVerbose():
dpkg_shlibdeps += " -v"
if RUNTIME:
# The runtime doesn't export any useful symbols, so just query the dependencies.
oscmd("cd targetroot; %(dpkg_shlibdeps)s -x%(pkg_name)s %(lib_pattern)s %(bin_pattern)s*" % locals())
depends = ReadFile("targetroot/debian/substvars").replace("shlibs:Depends=", "").strip()
recommends = ""
else:
pkg_name = "panda3d" + MAJOR_VERSION
pkg_dir = "debian/panda3d" + MAJOR_VERSION
# Generate a symbols file so that other packages can know which symbols we export.
oscmd("cd targetroot; dpkg-gensymbols -q -ODEBIAN/symbols -v%(pkg_version)s -p%(pkg_name)s -e%(lib_pattern)s" % locals())
# Library dependencies are required, binary dependencies are recommended.
# We explicitly exclude libphysx-extras since we don't want to depend on PhysX.
oscmd("cd targetroot; LD_LIBRARY_PATH=usr/%(lib_dir)s/panda3d %(dpkg_shlibdeps)s -Tdebian/substvars_dep --ignore-missing-info -x%(pkg_name)s -xlibphysx-extras %(lib_pattern)s" % locals())
oscmd("cd targetroot; LD_LIBRARY_PATH=usr/%(lib_dir)s/panda3d %(dpkg_shlibdeps)s -Tdebian/substvars_rec --ignore-missing-info -x%(pkg_name)s %(bin_pattern)s" % locals())
# Parse the substvars files generated by dpkg-shlibdeps.
depends = ReadFile("targetroot/debian/substvars_dep").replace("shlibs:Depends=", "").strip()
recommends = ReadFile("targetroot/debian/substvars_rec").replace("shlibs:Depends=", "").strip()
if PkgSkip("PYTHON")==0:
depends += ", " + PYTHONV + ", python-pmw"
recommends += ", python-wxversion, python-profiler (>= " + PV + "), python-tk (>= " + PV + ")"
if PkgSkip("NVIDIACG")==0:
depends += ", nvidia-cg-toolkit"
# Write back the dependencies, and delete the dummy set-up.
txt = txt.replace("DEPENDS", depends.strip(', '))
txt = txt.replace("RECOMMENDS", recommends.strip(', '))
WriteFile("targetroot/DEBIAN/control", txt)
oscmd("rm -rf targetroot/debian")
# Package it all up into a .deb file.
oscmd("chmod -R 755 targetroot/DEBIAN")
oscmd("chmod 644 targetroot/DEBIAN/control targetroot/DEBIAN/md5sums")
if not RUNTIME:
oscmd("chmod 644 targetroot/DEBIAN/conffiles targetroot/DEBIAN/symbols")
oscmd("fakeroot dpkg-deb -b targetroot %s_%s_%s.deb" % (pkg_name, pkg_version, pkg_arch))
elif rpmbuild_present:
# Invoke installpanda.py to install it into a temporary dir
if RUNTIME:
InstallRuntime(destdir="targetroot", prefix="/usr", outputdir=GetOutputDir(), libdir=GetRPMLibDir())
else:
InstallPanda(destdir="targetroot", prefix="/usr", outputdir=GetOutputDir(), libdir=GetRPMLibDir())
oscmd("chmod -R 755 targetroot/usr/share/panda3d")
oscmd("rpm -E '%_target_cpu' > "+GetOutputDir()+"/tmp/architecture.txt")
ARCH = ReadFile(GetOutputDir()+"/tmp/architecture.txt").strip()
pandasource = os.path.abspath(os.getcwd())
if RUNTIME:
txt = RUNTIME_INSTALLER_SPEC_FILE[1:]
else:
txt = INSTALLER_SPEC_FILE[1:]
# Add the binaries in /usr/bin explicitly to the spec file
for base in os.listdir(GetOutputDir() + "/bin"):
txt += "/usr/bin/%s\n" % (base)
# Write out the spec file.
txt = txt.replace("VERSION", VERSION)
txt = txt.replace("RPMRELEASE", RPMRELEASE)
txt = txt.replace("PANDASOURCE", pandasource)
txt = txt.replace("PV", PV)
WriteFile("panda3d.spec", txt)
oscmd("fakeroot rpmbuild --define '_rpmdir "+pandasource+"' --buildroot '"+os.path.abspath("targetroot")+"' -bb panda3d.spec")
if (RUNTIME):
oscmd("mv "+ARCH+"/panda3d-runtime-"+VERSION+"-"+RPMRELEASE+"."+ARCH+".rpm .")
else:
oscmd("mv "+ARCH+"/panda3d-"+VERSION+"-"+RPMRELEASE+"."+ARCH+".rpm .")
oscmd("rm -rf "+ARCH, True)
else:
exit("To build an installer, either rpmbuild or dpkg-deb must be present on your system!")
def MakeInstallerOSX():
if (RUNTIME):
# Invoke the make_installer script.
AddToPathEnv("DYLD_LIBRARY_PATH", GetOutputDir() + "/plugins")
cmdstr = sys.executable + " "
if sys.version_info >= (2, 6):
cmdstr += "-B "
cmdstr += "direct/src/plugin_installer/make_installer.py --version %s" % VERSION
oscmd(cmdstr)
return
import compileall
if (os.path.isfile("Panda3D-%s.dmg" % VERSION)): oscmd("rm -f Panda3D-%s.dmg" % VERSION)
if (os.path.exists("dstroot")): oscmd("rm -rf dstroot")
if (os.path.exists("Panda3D-rw.dmg")): oscmd('rm -f Panda3D-rw.dmg')
oscmd("mkdir -p dstroot/base/Developer/Panda3D/lib")
oscmd("mkdir -p dstroot/base/Developer/Panda3D/panda3d")
oscmd("mkdir -p dstroot/base/Developer/Panda3D/etc")
oscmd("cp %s/etc/Config.prc dstroot/base/Developer/Panda3D/etc/Config.prc" % GetOutputDir())
oscmd("cp %s/etc/Confauto.prc dstroot/base/Developer/Panda3D/etc/Confauto.prc" % GetOutputDir())
oscmd("cp -R %s/models dstroot/base/Developer/Panda3D/models" % GetOutputDir())
oscmd("cp -R doc/LICENSE dstroot/base/Developer/Panda3D/LICENSE")
oscmd("cp -R doc/ReleaseNotes dstroot/base/Developer/Panda3D/ReleaseNotes")
oscmd("cp -R %s/Frameworks dstroot/base/Developer/Panda3D/Frameworks" % GetOutputDir())
if os.path.isdir(GetOutputDir()+"/plugins"):
oscmd("cp -R %s/plugins dstroot/base/Developer/Panda3D/plugins" % GetOutputDir())
install_libs = []
for base in os.listdir(GetOutputDir()+"/lib"):
if (not base.endswith(".a")):
install_libs.append("lib/"+base)
for base in os.listdir(GetOutputDir()+"/panda3d"):
if (not base.endswith(".a")):
install_libs.append("panda3d/"+base)
for base in install_libs:
libname = "dstroot/base/Developer/Panda3D/" + base
# We really need to specify -R in order not to follow symlinks
# On OSX, just specifying -P is not enough to do that.
oscmd("cp -R -P " + GetOutputDir() + "/" + base + " " + libname)
oscmd("mkdir -p dstroot/tools/Developer/Tools/Panda3D")
oscmd("mkdir -p dstroot/tools/Developer/Panda3D")
oscmd("mkdir -p dstroot/tools/etc/paths.d")
# Trailing newline is important, works around a bug in OSX
WriteFile("dstroot/tools/etc/paths.d/Panda3D", "/Developer/Tools/Panda3D\n")
oscmd("mkdir -p dstroot/tools/usr/share/man/man1")
oscmd("cp doc/man/*.1 dstroot/tools/usr/share/man/man1/")
for base in os.listdir(GetOutputDir()+"/bin"):
binname = "dstroot/tools/Developer/Tools/Panda3D/" + base
# OSX needs the -R argument to copy symbolic links correctly, it doesn't have -d. How weird.
oscmd("cp -R " + GetOutputDir() + "/bin/" + base + " " + binname)
if PkgSkip("PYTHON")==0:
PV = SDK["PYTHONVERSION"].replace("python", "")
oscmd("mkdir -p dstroot/pythoncode/usr/bin")
oscmd("mkdir -p dstroot/pythoncode/Developer/Panda3D")
oscmd("mkdir -p dstroot/pythoncode/Library/Python/%s/site-packages" % PV)
WriteFile("dstroot/pythoncode/Library/Python/%s/site-packages/Panda3D.pth" % PV, "/Developer/Panda3D")
oscmd("cp -R %s/pandac dstroot/pythoncode/Developer/Panda3D/pandac" % GetOutputDir())
oscmd("cp -R %s/direct dstroot/pythoncode/Developer/Panda3D/direct" % GetOutputDir())
oscmd("ln -s %s dstroot/pythoncode/usr/bin/ppython" % SDK["PYTHONEXEC"])
if os.path.isdir(GetOutputDir()+"/Pmw"):
oscmd("cp -R %s/Pmw dstroot/pythoncode/Developer/Panda3D/Pmw" % GetOutputDir())
compileall.compile_dir("dstroot/pythoncode/Developer/Panda3D/Pmw")
WriteFile("dstroot/pythoncode/Developer/Panda3D/direct/__init__.py", "")
for base in os.listdir("dstroot/pythoncode/Developer/Panda3D/direct"):
if ((base != "extensions") and (base != "extensions_native")):
compileall.compile_dir("dstroot/pythoncode/Developer/Panda3D/direct/"+base)
oscmd("mkdir -p dstroot/headers/Developer/Panda3D")
oscmd("cp -R %s/include dstroot/headers/Developer/Panda3D/include" % GetOutputDir())
if os.path.isdir("samples"):
oscmd("mkdir -p dstroot/samples/Developer/Examples/Panda3D")
oscmd("cp -R samples/* dstroot/samples/Developer/Examples/Panda3D/")
oscmd("chmod -R 0775 dstroot/*")
DeleteVCS("dstroot")
DeleteBuildFiles("dstroot")
# We need to be root to perform a chown. Bleh.
# Fortunately PackageMaker does it for us, on 10.5 and above.
#oscmd("chown -R root:admin dstroot/*", True)
oscmd("mkdir -p dstroot/Panda3D/Panda3D.mpkg/Contents/Packages/")
oscmd("mkdir -p dstroot/Panda3D/Panda3D.mpkg/Contents/Resources/en.lproj/")
pkgs = ["base", "tools", "headers"]
if PkgSkip("PYTHON")==0: pkgs.append("pythoncode")
if os.path.isdir("samples"): pkgs.append("samples")
for pkg in pkgs:
plist = open("/tmp/Info_plist", "w")
plist.write(Info_plist % { "package_id" : "org.panda3d.panda3d.%s.pkg" % pkg, "version" : VERSION })
plist.close()
if not os.path.isdir("dstroot/" + pkg):
os.makedirs("dstroot/" + pkg)
if OSXTARGET and OSXTARGET <= (10, 5):
target = '--target %d.%d' % (OSXTARGET)
else:
target = ''
if os.path.exists("/Developer/usr/bin/packagemaker"):
cmd = '/Developer/usr/bin/packagemaker --info /tmp/Info_plist --version ' + VERSION + ' --out dstroot/Panda3D/Panda3D.mpkg/Contents/Packages/' + pkg + '.pkg ' + target + ' --domain system --root dstroot/' + pkg + '/ --no-relocate'
elif os.path.exists("/Applications/Xcode.app/Contents/Applications/PackageMaker.app/Contents/MacOS/PackageMaker"):
cmd = '/Applications/Xcode.app/Contents/Applications/PackageMaker.app/Contents/MacOS/PackageMaker --info /tmp/Info_plist --version ' + VERSION + ' --out dstroot/Panda3D/Panda3D.mpkg/Contents/Packages/' + pkg + '.pkg ' + target + ' --domain system --root dstroot/' + pkg + '/ --no-relocate'
elif os.path.exists("/Developer/Tools/PackageMaker.app/Contents/MacOS/PackageMaker"):
cmd = '/Developer/Tools/PackageMaker.app/Contents/MacOS/PackageMaker --info /tmp/Info_plist --version ' + VERSION + ' --out dstroot/Panda3D/Panda3D.mpkg/Contents/Packages/' + pkg + '.pkg ' + target + ' --domain system --root dstroot/' + pkg + '/ --no-relocate'
elif os.path.exists("/Developer/Tools/packagemaker"):
cmd = '/Developer/Tools/packagemaker -build -f dstroot/' + pkg + '/ -p dstroot/Panda3D/Panda3D.mpkg/Contents/Packages/' + pkg + '.pkg -i /tmp/Info_plist'
elif os.path.exists("/Applications/PackageMaker.app/Contents/MacOS/PackageMaker"):
cmd = '/Applications/PackageMaker.app/Contents/MacOS/PackageMaker --info /tmp/Info_plist --version ' + VERSION + ' --out dstroot/Panda3D/Panda3D.mpkg/Contents/Packages/' + pkg + '.pkg ' + target + ' --domain system --root dstroot/' + pkg + '/ --no-relocate'
else:
exit("PackageMaker could not be found!")
oscmd(cmd)
if os.path.isfile("/tmp/Info_plist"):
oscmd("rm -f /tmp/Info_plist")
# Now that we've built all of the individual packages, build the metapackage.
dist = open("dstroot/Panda3D/Panda3D.mpkg/Contents/distribution.dist", "w")
dist.write('<?xml version="1.0" encoding="utf-8"?>\n')
dist.write('<installer-script minSpecVersion="1.000000" authoringTool="com.apple.PackageMaker" authoringToolVersion="3.0.3" authoringToolBuild="174">\n')
dist.write(' <title>Panda3D SDK %s</title>\n' % (VERSION))
dist.write(' <options customize="always" allow-external-scripts="no" rootVolumeOnly="false"/>\n')
dist.write(' <license language="en" mime-type="text/plain">%s</license>\n' % ReadFile("doc/LICENSE"))
dist.write(' <choices-outline>\n')
dist.write(' <line choice="base"/>\n')
dist.write(' <line choice="tools"/>\n')
if PkgSkip("PYTHON")==0:
dist.write(' <line choice="pythoncode"/>\n')
if os.path.isdir("samples"):
dist.write(' <line choice="samples"/>\n')
dist.write(' <line choice="headers"/>\n')
dist.write(' </choices-outline>\n')
dist.write(' <choice id="base" title="Panda3D Base Installation" description="This package contains the Panda3D libraries, configuration files and models/textures that are needed to use Panda3D. Location: /Developer/Panda3D/" start_enabled="false">\n')
dist.write(' <pkg-ref id="org.panda3d.panda3d.base.pkg"/>\n')
dist.write(' </choice>\n')
dist.write(' <choice id="tools" title="Tools" tooltip="Useful tools and model converters to help with Panda3D development" description="This package contains the various utilities that ship with Panda3D, including packaging tools, model converters, and many more. Location: /Developer/Tools/Panda3D/">\n')
dist.write(' <pkg-ref id="org.panda3d.panda3d.tools.pkg"/>\n')
dist.write(' </choice>\n')
if PkgSkip("PYTHON")==0:
dist.write(' <choice id="pythoncode" title="Python Code" tooltip="Code you\'ll need for Python development" description="This package contains the \'direct\', \'pandac\' and \'panda3d\' python packages that are needed to do Python development with Panda3D. Location: /Developer/Panda3D/">\n')
dist.write(' <pkg-ref id="org.panda3d.panda3d.pythoncode.pkg"/>\n')
dist.write(' </choice>\n')
if os.path.isdir("samples"):
dist.write(' <choice id="samples" title="Sample Programs" tooltip="Python sample programs that use Panda3D" description="This package contains the Python sample programs that can help you with learning how to use Panda3D. Location: /Developer/Examples/Panda3D/">\n')
dist.write(' <pkg-ref id="org.panda3d.panda3d.samples.pkg"/>\n')
dist.write(' </choice>\n')
dist.write(' <choice id="headers" title="C++ Header Files" tooltip="Header files for C++ development with Panda3D" description="This package contains the C++ header files that are needed in order to do C++ development with Panda3D. You don\'t need this if you want to develop in Python. Location: /Developer/Panda3D/include/" start_selected="false">\n')
dist.write(' <pkg-ref id="org.panda3d.panda3d.headers.pkg"/>\n')
dist.write(' </choice>\n')
dist.write(' <pkg-ref id="org.panda3d.panda3d.base.pkg" installKBytes="%d" version="1" auth="Root">file:./Contents/Packages/base.pkg</pkg-ref>\n' % (GetDirectorySize("dstroot/base") // 1024))
dist.write(' <pkg-ref id="org.panda3d.panda3d.tools.pkg" installKBytes="%d" version="1" auth="Root">file:./Contents/Packages/tools.pkg</pkg-ref>\n' % (GetDirectorySize("dstroot/tools") // 1024))
if PkgSkip("PYTHON")==0:
dist.write(' <pkg-ref id="org.panda3d.panda3d.pythoncode.pkg" installKBytes="%d" version="1" auth="Root">file:./Contents/Packages/pythoncode.pkg</pkg-ref>\n' % (GetDirectorySize("dstroot/pythoncode") // 1024))
if os.path.isdir("samples"):
dist.write(' <pkg-ref id="org.panda3d.panda3d.samples.pkg" installKBytes="%d" version="1" auth="Root">file:./Contents/Packages/samples.pkg</pkg-ref>\n' % (GetDirectorySize("dstroot/samples") // 1024))
dist.write(' <pkg-ref id="org.panda3d.panda3d.headers.pkg" installKBytes="%d" version="1" auth="Root">file:./Contents/Packages/headers.pkg</pkg-ref>\n' % (GetDirectorySize("dstroot/headers") // 1024))
dist.write('</installer-script>\n')
dist.close()
oscmd('hdiutil create Panda3D-rw.dmg -volname "Panda3D SDK %s" -srcfolder dstroot/Panda3D' % (VERSION))
oscmd('hdiutil convert Panda3D-rw.dmg -format UDBZ -o Panda3D-%s.dmg' % (VERSION))
oscmd('rm -f Panda3D-rw.dmg')
def MakeInstallerFreeBSD():
import compileall
oscmd("rm -rf targetroot pkg-descr pkg-plist")
oscmd("mkdir targetroot")
# Invoke installpanda.py to install it into a temporary dir
if RUNTIME:
InstallRuntime(destdir = "targetroot", prefix = "/usr/local", outputdir = GetOutputDir())
else:
InstallPanda(destdir = "targetroot", prefix = "/usr/local", outputdir = GetOutputDir())
if (not os.path.exists("/usr/sbin/pkg_create")):
exit("Cannot create an installer without pkg_create")
if (RUNTIME):
descr_txt = RUNTIME_INSTALLER_PKG_DESCR_FILE[1:]
else:
descr_txt = INSTALLER_PKG_DESCR_FILE[1:]
descr_txt = descr_txt.replace("VERSION", VERSION)
if (RUNTIME):
plist_txt = "@name panda3d-runtime-%s\n" % VERSION
else:
plist_txt = "@name panda3d-%s\n" % VERSION
for root, dirs, files in os.walk("targetroot/usr/local/", True):
for f in files:
plist_txt += os.path.join(root, f)[21:] + "\n"
if (not RUNTIME):
plist_txt += "@exec /sbin/ldconfig -m /usr/local/lib\n"
plist_txt += "@unexec /sbin/ldconfig -R\n"
for remdir in ("lib/panda3d", "share/panda3d", "include/panda3d"):
for root, dirs, files in os.walk("targetroot/usr/local/" + remdir, False):
for d in dirs:
plist_txt += "@dirrm %s\n" % os.path.join(root, d)[21:]
plist_txt += "@dirrm %s\n" % remdir
WriteFile("pkg-plist", plist_txt)
WriteFile("pkg-descr", descr_txt)
cmd = "pkg_create"
if GetVerbose():
cmd += " --verbose"
if PkgSkip("PYTHON")==0:
# If this version of Python was installed from a package, let's mark it as dependency.
oscmd("rm -f %s/tmp/python-pkg.txt" % GetOutputDir())
oscmd("pkg_info -E 'python%s>=%s' > %s/tmp/python-pkg.txt" % (SDK["PYTHONVERSION"][6:9:2], SDK["PYTHONVERSION"][6:9], GetOutputDir()), True)
if (os.path.isfile(GetOutputDir() + "/tmp/python-pkg.txt")):
python_pkg = ReadFile(GetOutputDir() + "/tmp/python-pkg.txt").strip()
if (python_pkg):
cmd += " -P " + python_pkg
cmd += " -p /usr/local -S \"%s\"" % os.path.abspath("targetroot")
if (RUNTIME):
cmd += " -c -\"The Panda3D free 3D engine runtime\" -o graphics/panda3d-runtime"
else:
cmd += " -c -\"The Panda3D free 3D engine SDK\" -o devel/panda3d"
cmd += " -d pkg-descr -f pkg-plist panda3d-%s" % VERSION
oscmd(cmd)
try:
if INSTALLER:
ProgressOutput(100.0, "Building installer")
target = GetTarget()
if target == 'windows':
fn = "Panda3D-"
dir = "C:\\Panda3D-" + VERSION
if RUNTIME:
fn += "Runtime-"
title = "Panda3D " + VERSION
else:
title = "Panda3D SDK " + VERSION
fn += VERSION
if SDK["PYTHONVERSION"] != "python2.7":
fn += '-py' + SDK["PYTHONVERSION"][6:]
if GetOptimize() <= 2:
fn += "-dbg"
if GetTargetArch() == 'x64':
fn += '-x64'
dir += '-x64'
fn += '.exe'
MakeInstallerNSIS(fn, title, dir)
elif (target == 'linux'):
MakeInstallerLinux()
elif (target == 'darwin'):
MakeInstallerOSX()
elif (target == 'freebsd'):
MakeInstallerFreeBSD()
else:
exit("Do not know how to make an installer for this platform")
finally:
SaveDependencyCache()
##########################################################################################
#
# Print final status report.
#
##########################################################################################
WARNINGS.append("Elapsed Time: "+PrettyTime(time.time() - STARTTIME))
printStatus("Makepanda Final Status Report", WARNINGS)
print(GetColor("green") + "Build successfully finished, elapsed time: " + PrettyTime(time.time() - STARTTIME) + GetColor())
Reference in a new issue View git blame Copy permalink