mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-26 05:02:31 -06:00
235 lines
8.3 KiB
Python
Executable file
235 lines
8.3 KiB
Python
Executable file
#! /usr/bin/env python
|
|
|
|
usageText = """
|
|
|
|
This command will pack a Panda application, consisting of a directory
|
|
tree of .py files and models, into a p3d file for convenient
|
|
distribution. The resulting p3d file can be run by the Panda3D
|
|
runtime executable, or by the Panda3D web browser plugin.
|
|
|
|
This command will build p3d files that reference Panda3D %s,
|
|
from host %s .
|
|
|
|
Also see ppackage, a more powerful (but more complex) tool that can
|
|
also be used to build p3d applications, using a pdef description file.
|
|
|
|
Usage:
|
|
|
|
%s [opts] -o app.p3d
|
|
|
|
Options:
|
|
|
|
-o app.p3d
|
|
Specify the name of the p3d file to generate. This is required.
|
|
|
|
-d application_root
|
|
Specify the root directory of the application source; this is a
|
|
directory tree that contains all of your .py files and models.
|
|
If this is omitted, the default is the current directory.
|
|
|
|
-m main.py
|
|
Names the Python file that begins the application. This should
|
|
be a file within the root directory. If this is omitted, the
|
|
default is a file named "main.py", or if there is only one Python
|
|
file present, it is used. If this file contains a function
|
|
called main(), that function will be called after importing it
|
|
(this is preferable to having the module start itself immediately
|
|
upon importing).
|
|
|
|
-S file.crt[,chain.crt[,file.key[,\"password\"]]]
|
|
Signs the resulting p3d with the indicated certificate. You may
|
|
specify the signing certificate, the optional authorization
|
|
chain, and the private key in three different files, or they may
|
|
all be combined in the first file. If the private key is
|
|
encrypted, the password will be required to decrypt it.
|
|
|
|
-e ext
|
|
Adds a new extension to be processed as a generic, compressible
|
|
file type. Do not include the leading dot. Files matching this
|
|
extension found within the root directory will be automatically
|
|
added to the p3d file, in compressed form. This option may be
|
|
repeated as necessary.
|
|
|
|
-n ext
|
|
Adds a new extension to be processed as a noncompressible file
|
|
type. Files matching this extension will be added to the p3d
|
|
file, in their original, uncompressed form. You should use this
|
|
instead of -e for files that are uncompressible by their nature
|
|
(e.g. mpg files). This option may be repeated as necessary.
|
|
|
|
-p python_lib_dir
|
|
Adds a directory to search for additional Python modules. You
|
|
can use this to add your system's Python path, to allow packp3d
|
|
to find any system modules not included in the standard Panda3D
|
|
release, but your version of Python must match this one (%s).
|
|
This option may be repeated to add multiple directories.
|
|
|
|
-c config=value
|
|
Sets the indicated config flag in the application. This option
|
|
may be repeated as necessary.
|
|
|
|
-r package[,version[,hostURL]]
|
|
Names an additional package that this application requires at
|
|
startup time. The default package is 'panda3d'; you may repeat
|
|
this option to indicate dependencies on additional packages.
|
|
|
|
-s search_dir
|
|
Additional directories to search for previously-built packages.
|
|
This option may be repeated as necessary. These directories may
|
|
also be specified with the pdef-path Config.prc variable.
|
|
|
|
-D
|
|
Sets the allow_python_dev flag in the application. This enables
|
|
additional runtime debug operations, particularly the -i option
|
|
to the panda3d command, which enables a live Python prompt within
|
|
the application's environment. Setting this flag may be useful
|
|
to develop an application initially, but should not be set on an
|
|
application intended for deployment.
|
|
|
|
"""
|
|
|
|
import sys
|
|
import os
|
|
import getopt
|
|
import glob
|
|
import direct
|
|
from direct.p3d import Packager
|
|
from pandac.PandaModules import *
|
|
|
|
# Temp hack for debugging.
|
|
#from direct.p3d.AppRunner import dummyAppRunner; dummyAppRunner()
|
|
|
|
class ArgumentError(StandardError):
|
|
pass
|
|
|
|
def makePackedApp(args):
|
|
opts, args = getopt.getopt(args, 'o:d:m:S:e:n:p:c:r:s:Dh')
|
|
|
|
packager = Packager.Packager()
|
|
|
|
appFilename = None
|
|
root = Filename('.')
|
|
main = None
|
|
configFlags = []
|
|
requires = []
|
|
allowPythonDev = False
|
|
|
|
for option, value in opts:
|
|
if option == '-o':
|
|
appFilename = Filename.fromOsSpecific(value)
|
|
elif option == '-d':
|
|
root = Filename.fromOsSpecific(value)
|
|
elif option == '-m':
|
|
main = value
|
|
elif option == '-S':
|
|
tokens = value.split(',')
|
|
while len(tokens) < 4:
|
|
tokens.append('')
|
|
certificate, chain, pkey, password = tokens[:4]
|
|
packager.signParams.append((Filename.fromOsSpecific(certificate),
|
|
Filename.fromOsSpecific(chain),
|
|
Filename.fromOsSpecific(pkey),
|
|
Filename.fromOsSpecific(password)))
|
|
elif option == '-e':
|
|
packager.binaryExtensions.append(value)
|
|
elif option == '-n':
|
|
packager.uncompressibleExtensions.append(value)
|
|
elif option == '-p':
|
|
sys.path.append(value)
|
|
elif option == '-c':
|
|
configFlags.append(value.split('=', 1))
|
|
elif option == '-r':
|
|
tokens = value.split(',')
|
|
while len(tokens) < 3:
|
|
tokens.append('')
|
|
name, version, host = tokens[:3]
|
|
requires.append((name, version, host))
|
|
elif option == '-s':
|
|
packager.installSearch.append(Filename.fromOsSpecific(value))
|
|
elif option == '-D':
|
|
allowPythonDev = True
|
|
elif option == '-h':
|
|
print usageText % (
|
|
PandaSystem.getPackageVersionString(),
|
|
PandaSystem.getPackageHostUrl(),
|
|
os.path.split(sys.argv[0])[1],
|
|
'%s.%s' % (sys.version_info[0], sys.version_info[1]))
|
|
sys.exit(1)
|
|
|
|
if not appFilename:
|
|
raise ArgumentError, "No target app specified. Use:\n%s -o app.p3d" % (os.path.split(sys.argv[0])[1])
|
|
|
|
if args:
|
|
raise ArgumentError, "Extra arguments on command line."
|
|
|
|
if appFilename.getExtension() != 'p3d':
|
|
raise ArgumentError, 'Application filename must end in ".p3d".'
|
|
|
|
appDir = Filename(appFilename.getDirname())
|
|
if not appDir:
|
|
appDir = Filename('.')
|
|
appBase = appFilename.getBasenameWoExtension()
|
|
|
|
if not main:
|
|
main = Filename(root, 'main.py')
|
|
if main.exists():
|
|
main = 'main.py'
|
|
else:
|
|
main = glob.glob(os.path.join(root.toOsSpecific(), '*.py'))
|
|
if len(main) == 0:
|
|
raise ArgumentError, 'No Python files in root directory.'
|
|
elif len(main) > 1:
|
|
raise ArgumentError, 'Multiple Python files in root directory; specify the main application with -m "main".'
|
|
main = os.path.split(main[0])[1]
|
|
|
|
main = Filename.fromOsSpecific(main)
|
|
mainModule = Filename(main)
|
|
mainModule.setExtension('')
|
|
|
|
mainModule = mainModule.cStr().replace('/', '.')
|
|
|
|
packager.installDir = appDir
|
|
packager.allowPythonDev = allowPythonDev
|
|
|
|
# Put the root directory on the front of the model-path, so that
|
|
# any texture references in egg or bam files that reference
|
|
# textures from the top of the root directory will be properly
|
|
# resolved.
|
|
getModelPath().prependDirectory(root)
|
|
|
|
try:
|
|
packager.setup()
|
|
packager.beginPackage(appBase, p3dApplication = True)
|
|
|
|
# Pre-require panda3d, to give a less-confusing error message
|
|
# if one of our requirements pulls in a wrong version of
|
|
# panda3d.
|
|
if 'panda3d' not in [t[0] for t in requires]:
|
|
packager.do_require('panda3d')
|
|
|
|
for name, version, host in requires:
|
|
packager.do_require(name, version = version, host = host)
|
|
|
|
if configFlags:
|
|
packager.do_config(**dict(configFlags))
|
|
|
|
packager.do_dir(root)
|
|
packager.do_mainModule(mainModule)
|
|
packager.endPackage()
|
|
packager.close()
|
|
|
|
except Packager.PackagerError:
|
|
# Just print the error message and exit gracefully.
|
|
inst = sys.exc_info()[1]
|
|
print inst.args[0]
|
|
sys.exit(1)
|
|
|
|
try:
|
|
makePackedApp(sys.argv[1:])
|
|
except ArgumentError, e:
|
|
print e.args[0]
|
|
sys.exit(1)
|
|
|
|
# An explicit call to exit() is required to exit the program, when
|
|
# this module is packaged in a p3d file.
|
|
sys.exit(0)
|