def test_loader_compressed(test_pz_filename):
"""Tests for loading .pz files and the supports_compressed flag."""
class TestLoader:
extensions = ["test"]
@staticmethod
def load_file(path, options, record=None):
return ModelRoot("loaded")
# Test with property absent
with registered_type(TestLoader):
model = Loader.get_global_ptr().load_sync(
test_pz_filename, LoaderOptions(LoaderOptions.LF_no_cache))
assert model is None
# Test with property False, should give same result
TestLoader.supports_compressed = False
with registered_type(TestLoader):
model = Loader.get_global_ptr().load_sync(
test_pz_filename, LoaderOptions(LoaderOptions.LF_no_cache))
assert model is None
# Test with property True, should work
TestLoader.supports_compressed = True
with registered_type(TestLoader):
model = Loader.get_global_ptr().load_sync(
test_pz_filename, LoaderOptions(LoaderOptions.LF_no_cache))
assert model is not None
assert model.name == "loaded"
# Test with property invalid type, should not register
TestLoader.supports_compressed = None
with pytest.raises(TypeError):
LoaderFileTypeRegistry.get_global_ptr().register_type(TestLoader)
def test_loader_ram_cache(test_filename):
"""Tests that the Python loader plug-ins write to the RAM cache."""
# Ensure a clean slate.
from panda3d.core import ModelPool
ModelPool.release_all_models()
with registered_type(DummyLoader):
model1 = Loader.get_global_ptr().load_sync(
test_filename,
LoaderOptions(LoaderOptions.LF_no_disk_cache
| LoaderOptions.LF_allow_instance))
assert model1 is not None
assert model1.name == "loaded"
assert ModelPool.has_model(test_filename)
assert ModelPool.get_model(test_filename, True) == model1
model2 = Loader.get_global_ptr().load_sync(
test_filename,
LoaderOptions(LoaderOptions.LF_cache_only
| LoaderOptions.LF_allow_instance))
assert model2 is not None
assert model1 == model2
ModelPool.release_model(model2)
def __init__(self,
scene,
suncgDatasetRoot,
size=(512, 512),
mode='offscreen',
zNear=0.1,
zFar=1000.0,
fov=40.0,
cameraTransform=None):
# Off-screen buffers are not supported in OSX
if sys.platform == 'darwin':
mode = 'onscreen'
super(Panda3dSemanticsRenderer, self).__init__()
self.__dict__.update(scene=scene,
suncgDatasetRoot=suncgDatasetRoot,
size=size,
mode=mode,
zNear=zNear,
zFar=zFar,
fov=fov,
cameraTransform=cameraTransform)
self.categoryMapping = ModelCategoryMapping(
os.path.join(self.suncgDatasetRoot, 'metadata',
'ModelCategoryMapping.csv'))
self.cameraMask = BitMask32.bit(1)
self.graphicsEngine = GraphicsEngine.getGlobalPtr()
self.loader = Loader.getGlobalPtr()
self.graphicsEngine.setDefaultLoader(self.loader)
self._initModels()
selection = GraphicsPipeSelection.getGlobalPtr()
self.pipe = selection.makeDefaultPipe()
logger.debug('Using %s' % (self.pipe.getInterfaceName()))
# Attach a camera to every agent in the scene
self.cameras = []
for agentNp in self.scene.scene.findAllMatches('**/agents/agent*'):
camera = agentNp.attachNewNode(ModelNode('camera-semantics'))
if self.cameraTransform is not None:
camera.setTransform(cameraTransform)
camera.node().setPreserveTransform(ModelNode.PTLocal)
self.cameras.append(camera)
# Reparent node below the existing physic node (if any)
physicsNp = agentNp.find('**/physics')
if not physicsNp.isEmpty():
camera.reparentTo(physicsNp)
self.rgbBuffers = dict()
self.rgbTextures = dict()
self._initRgbCapture()
self.scene.worlds['render-semantics'] = self
def __init__(self, base):
self.base = base
self.loader = PandaLoader.getGlobalPtr()
self.hook = "async_loader_%s" % (Loader.loaderIndex)
Loader.loaderIndex += 1
self.accept(self.hook, self.__gotAsyncObject)
def _loader_(self, in_Q, out_Q):
_alive = True
# print("FART", self.fart_node)
loader = Loader()
while _alive:
file_name = in_Q.get()
if file_name == "close":
model = None
_alive = False
else:
model = loader.loadSync(file_name)
geom = NodePath(model.getChildren()[0])
geom = geom.__reduce_persist__(geom)
## mp = pickler.dumps(model)
print("OUT:", model)
out_Q.put((file_name, geom))
def __init__(self, input_file, output_file=None, prefabs=""):
self.dir = os.path.dirname(input_file)
self.depth = 0
self.cardmaker = CardMaker("image")
self.cardmaker.set_frame(-0.5, 0.5, -0.5, 0.5)
self.linesegs = LineSegs()
self.textnode = TextNode("text")
self.tilesheets = [] # Every tsx file loaded.
self.tiles = {} # Every unique tile/card.
self.node = NodePath("tmx_root")
# load prefab models
self.prefabs = {}
if prefabs:
loader = Loader.get_global_ptr()
for prefab_node in loader.load_sync(prefabs).get_children():
prefab_node.clear_transform()
self.prefabs[prefab_node.name] = NodePath(prefab_node)
self.tmx = ET.parse(input_file).getroot()
self.xscale = int(self.tmx.get("tilewidth"))
self.yscale = int(self.tmx.get("tileheight"))
self.size = [0, 0]
self.load_group(self.tmx)
if output_file:
self.export_bam(output_file)
def __init__(self, base):
self.base = base
self.loader = PandaLoader.getGlobalPtr()
self.hook = "async_loader_%s" % (Loader.loaderIndex)
Loader.loaderIndex += 1
self.accept(self.hook, self.__gotAsyncObject)
def test_loader_success(test_filename):
"""Tests that a normal dummy loader successfully loads."""
with registered_type(DummyLoader):
model = Loader.get_global_ptr().load_sync(
test_filename, LoaderOptions(LoaderOptions.LF_no_cache))
assert model is not None
assert model.name == "loaded"
def loadModel(modelPath):
loader = Loader.getGlobalPtr()
loaderOptions = LoaderOptions()
node = loader.loadSync(Filename(modelPath), loaderOptions)
if node is not None:
nodePath = NodePath(node)
nodePath.setTag('model-filename', os.path.abspath(modelPath))
else:
raise IOError('Could not load model file: %s' % (modelPath))
return nodePath
def __init__(self):
DirectObject.__init__(self)
self.loader = Loader.getGlobalPtr()
self.modelPool = {}
self.requests = {}
self.asyncRequestDoneEvent = self.getUniqueName() + '-asyncRequestDone'
self.accept(self.asyncRequestDoneEvent, self.__handleAsyncRequestDone)
def __init__(self):
DirectObject.__init__(self)
self.loader = Loader.getGlobalPtr()
self.modelPool = {}
self.requests = {}
self.asyncRequestDoneEvent = self.getUniqueName() + '-asyncRequestDone'
self.accept(self.asyncRequestDoneEvent, self.__handleAsyncRequestDone)
def __init__(self, base):
self.base = base
self.loader = PandaLoader.getGlobalPtr()
self._requests = {}
self.hook = "async_loader_%s" % (Loader.loaderIndex)
Loader.loaderIndex += 1
self.accept(self.hook, self.__gotAsyncObject)
self._loadPythonFileTypes()
def loadModel(modelPath):
loader = Loader.getGlobalPtr()
# NOTE: disable disk and RAM caching to avoid filling memory when loading multiple scenes
loaderOptions = LoaderOptions(LoaderOptions.LF_no_cache)
node = loader.loadSync(Filename(modelPath), loaderOptions)
if node is not None:
nodePath = NodePath(node)
nodePath.setTag('model-filename', os.path.abspath(modelPath))
else:
raise IOError('Could not load model file: %s' % (modelPath))
return nodePath
def __init__(self, base):
self.base = base
self.loader = PandaLoader.getGlobalPtr()
self._requests = {}
self.hook = "async_loader_%s" % (Loader.loaderIndex)
Loader.loaderIndex += 1
self.accept(self.hook, self.__gotAsyncObject)
if ConfigVariableBool('loader-support-entry-points', True):
self._loadPythonFileTypes()
def test_loader_extensions(test_filename):
"""Tests multi-extension loaders."""
class MultiExtensionLoader:
extensions = ["test1", "teSt2"]
@staticmethod
def load_file(path, options, record=None):
return ModelRoot("loaded")
fp1 = tempfile.NamedTemporaryFile(suffix='.test1', delete=False)
fp1.write(b"test1")
fp1.close()
fn1 = Filename.from_os_specific(fp1.name)
fn1.make_true_case()
fp2 = tempfile.NamedTemporaryFile(suffix='.TEST2', delete=False)
fp2.write(b"test2")
fp2.close()
fn2 = Filename.from_os_specific(fp2.name)
fn2.make_true_case()
try:
with registered_type(MultiExtensionLoader):
model1 = Loader.get_global_ptr().load_sync(
fn1, LoaderOptions(LoaderOptions.LF_no_cache))
assert model1 is not None
assert model1.name == "loaded"
model2 = Loader.get_global_ptr().load_sync(
fn2, LoaderOptions(LoaderOptions.LF_no_cache))
assert model2 is not None
assert model2.name == "loaded"
finally:
os.unlink(fp1.name)
os.unlink(fp2.name)
# Ensure that both were unregistered.
registry = LoaderFileTypeRegistry.get_global_ptr()
assert not registry.get_type_from_extension("test1")
assert not registry.get_type_from_extension("test2")
def test_loader_exception(test_filename):
"""Tests for a loader that raises an exception."""
class FailingLoader:
extensions = ["test"]
@staticmethod
def load_file(path, options, record=None):
raise Exception("test error")
with registered_type(FailingLoader):
model = Loader.get_global_ptr().load_sync(
test_filename, LoaderOptions(LoaderOptions.LF_no_cache))
assert model is None
class Loader(object):
## TODO:
#
# Make Loader than can load models and textures:
#
# PandaLoader.loadAsync
# TexturePool.loadTexture
panda_loader = PandaLoader.getGlobalPtr()
texture_loader = TexturePool
load_model = panda_loader.loadSync
load_texture = texture_loader.loadTexture
loadSync = load_model
loadModel = load_model
def __init__(self, scene, size=(512, 512), shadowing=False, mode='offscreen', zNear=0.1, zFar=1000.0, fov=40.0,
depth=True, modelLightsInfo=None, cameraTransform=None):
# Off-screen buffers are not supported in OSX
if sys.platform == 'darwin':
mode = 'onscreen'
super(Panda3dRenderer, self).__init__()
self.__dict__.update(scene=scene, size=size, mode=mode, zNear=zNear, zFar=zFar, fov=fov,
depth=depth, shadowing=shadowing, modelLightsInfo=modelLightsInfo,
cameraTransform=cameraTransform)
self.cameraMask = BitMask32.bit(0)
self.graphicsEngine = GraphicsEngine.getGlobalPtr()
self.loader = Loader.getGlobalPtr()
self.graphicsEngine.setDefaultLoader(self.loader)
# Change some scene attributes for rendering
self.scene.scene.setAttrib(RescaleNormalAttrib.makeDefault())
self.scene.scene.setTwoSided(0)
self._initModels()
selection = GraphicsPipeSelection.getGlobalPtr()
self.pipe = selection.makeDefaultPipe()
logger.debug('Using %s' % (self.pipe.getInterfaceName()))
# Attach a camera to every agent in the scene
self.cameras = []
for agentNp in self.scene.scene.findAllMatches('**/agents/agent*'):
camera = agentNp.attachNewNode(ModelNode('camera-rgbd'))
if self.cameraTransform is not None:
camera.setTransform(cameraTransform)
camera.node().setPreserveTransform(ModelNode.PTLocal)
self.cameras.append(camera)
self.rgbBuffers = dict()
self.rgbTextures = dict()
self.depthBuffers = dict()
self.depthTextures = dict()
self._initRgbCapture()
if self.depth:
self._initDepthCapture()
self._addDefaultLighting()
self.scene.worlds['render'] = self
def test_loader_nonexistent():
"""Verifies that non-existent files fail before calling load_file."""
flag = [False]
class AssertiveLoader:
extensions = ["test"]
@staticmethod
def load_file(path, options, record=None):
flag[0] = True
assert False, "should never get here"
with registered_type(AssertiveLoader):
model = Loader.get_global_ptr().load_sync(
"/non-existent", LoaderOptions(LoaderOptions.LF_no_cache))
assert model is None
assert not flag[0]
from panda3d.core import Loader, NodePath, CharacterJoint, PartBundle, AnimBundle, AnimGroup, PartGroup, AnimChannelACMatrixSwitchType
from panda3d.core import GeomVertexReader, InternalName, TransformBlend, TransformBlendTable, Vec3, Vec2, GeomVertexArrayFormat
from panda3d.core import TransformState, Mat4, Filename, AnimBundleNode, JointVertexTransform
import math
import os
loader = Loader.getGlobalPtr()
def loadModel(path):
return NodePath(loader.loadSync(path))
unknown = 0
def getUnknownName():
global unknown
name = "unknown{0}".format(unknown)
unknown += 1
return name
def boneFrameString(boneId, pos, rot):
return "{0} {1:.6f} {2:.6f} {3:.6f} {4:.6f} {5:.6f} {6:.6f}\n".format(
boneId, pos[0], pos[1], pos[2], rot[0], rot[1], rot[2])
FLT_EPSILON = 1e-5
print('ToontownStart: Starting the game.')
from toontown.toonbase.ToontownModules import *
from panda3d.core import Loader as PandaLoader
if launcher.isDummy():
# Create a dummy HTTPClient so we can get that stupid openSSL
# random seed computed before we attempt to open the window. (We
# only need do this if we don't have a launcher. If we do have a
# launcher, it's already been created.)
http = HTTPClient()
else:
http = launcher.http
# Preload the background scene before the window is even created
tempLoader = PandaLoader()
backgroundNode = tempLoader.loadSync(
Filename('phase_3/models/gui/loading-background'))
from direct.gui import DirectGuiGlobals
print('ToontownStart: setting default font')
from . import ToontownGlobals
DirectGuiGlobals.setDefaultFontFunc(ToontownGlobals.getInterfaceFont)
# First open a window so we can show the loading screen
# Set the error code indicating failure opening a window in case we
# crash while opening it (the GSG code will just exit if it fails to
# get the window open).
launcher.setPandaErrorCode(7)
import sys
sys.path.insert(0, "../../")
from Native.RSNative import MeshSplitterWriter
from panda3d.core import Loader, NodePath
# TODO: Make input- and output-file command line parameters, something like:
# convert.py -o output.rpsg input.bam
INPUT_FILE = "Scene.bam"
OUTPUT_FILE = "model.rpsg"
loader = Loader.get_global_ptr()
model = NodePath(loader.load_sync(INPUT_FILE))
# Flatten the transform of the model, since we don't store the transform
model.flatten_strong()
print("Loaded model ...")
writer = MeshSplitterWriter()
# Collect all geoms of the model and register them to the writer
geom_nodes = model.find_all_matches("**/+GeomNode")
for geom_node in geom_nodes:
geom_node = geom_node.node()
for geom_idx in range(geom_node.get_num_geoms()):
geom = geom_node.get_geom(geom_idx)
geom_state = geom_node.get_geom_state(geom_idx)
