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 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, 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)