Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def import_all_classes(path=application.asset_folder, debug=False):
path = str(path)
sys.path.append(path)
from ursina.string_utilities import snake_to_camel
from glob import iglob
imported_successfully = list()
for file_path in iglob(path + '**/*.py', recursive=True):
if '\\build\\' in file_path or '__' in file_path:
continue
rel_path = file_path[len(path):][:-3].replace('\\', '.')
if rel_path.startswith('.'):
rel_path = rel_path[1:]
module_name = os.path.basename(file_path).split('.')[0]
class_name = snake_to_camel(module_name)
module_name = module_name
imported_meshes[name] = m
return m
elif filetype == '.blend':
print('found blend file:', filename)
if compress_models(path=path, name=name):
# obj_to_ursinamesh(name=name)
return load_model(name, path)
# else:
return None
# find blender installations
if not hasattr(application, 'blender_paths') and application.development_mode:
application.blender_paths = dict()
if platform.system() == 'Windows':
# get blender path by getting default program for '.blend' file extention
import shlex
import winreg
try:
class_root = winreg.QueryValue(winreg.HKEY_CLASSES_ROOT, '.blend')
with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r'{}\shell\open\command'.format(class_root)) as key:
command = winreg.QueryValueEx(key, '')[0]
default_blender = shlex.split(command)[0]
default_blender = Path(default_blender)
application.blender_paths['default'] = default_blender
blender_foundation_directory = default_blender.parent.parent
self.double_sided = False
# self.always_on_top = False
self.collision = False # toggle collision without changing collider.
self.collider = None # set to 'box'/'sphere'/'mesh' for auto fitted collider.
self.scripts = list() # add with add_script(class_instance). will assign an 'entity' variable to the script.
self.animations = list()
self.hovered = False # will return True if mouse hovers entity.
self.origin = Vec3(0,0,0)
self.position = Vec3(0,0,0) # right, up, forward. can also set self.x, self.y, self.z
self.rotation = Vec3(0,0,0) # can also set self.rotation_x, self.rotation_y, self.rotation_z
self.scale = Vec3(1,1,1) # can also set self.scale_x, self.scale_y, self.scale_z
self.line_definition = None # returns a Traceback(filename, lineno, function, code_context, index).
if application.trace_entity_definition and add_to_scene_entities:
from inspect import getframeinfo, stack
_stack = stack()
caller = getframeinfo(_stack[1][0])
if len(_stack) > 2 and _stack[1].code_context and 'super().__init__()' in _stack[1].code_context[0]:
caller = getframeinfo(_stack[2][0])
self.line_definition = caller
if caller.code_context:
self.code_context = caller.code_context[0]
if (self.code_context.count('(') == self.code_context.count(')') and
' = ' in self.code_context and not 'name=' in self.code_context
and not 'Ursina()' in self.code_context):
self.name = self.code_context.split(' = ')[0].strip().replace('self.', '')
# print('set name to:', self.code_context.split(' = ')[0].strip().replace('self.', ''))
def load_model(name, path=application.asset_folder):
if name in imported_meshes:
# print('load cached model', name)
try:
return copy(imported_meshes[name])
except:
pass
for filetype in ('.bam', '.ursinamesh', '.obj', '.blend'):
# warning: glob is case-insensitive on windows, so m.path will be all lowercase
for filename in path.glob(f'**/{name}{filetype}'):
if filetype in '.bam':
print('loading bam')
return loader.loadModel(filename)
if filetype == '.ursinamesh':
try:
def save(self, name='', path=application.compressed_models_folder):
if not application.compressed_models_folder.exists():
application.compressed_models_folder.mkdir()
if not name and hasattr(self, 'path'):
name = self.path.stem
if not '.' in name:
name += '.ursinamesh'
if name.endswith('ursinamesh'):
with open(path / name, 'w') as f:
recipe = self.recipe.replace('LVector3f', '')
f.write(recipe)
print('saved .ursinamesh to:', path / name)
elif name.endswith('.obj'):
from ursina.mesh_importer import ursina_mesh_to_obj
ursina_mesh_to_obj(self, name, path)
def _fps_counter_update():
if self.fps_counter.i > 60:
self.fps_counter.text = str(int(1//time.dt))
self.fps_counter.i = 0
self.fps_counter.i += 1
self.fps_counter.update = _fps_counter_update
import webbrowser
self.cog_menu = ButtonList({
# 'Build' : Func(print, ' '),
'Asset Store' : Func(webbrowser.open, "https://itch.io/tools/tag-ursina"),
# 'Open Scene Editor' : Func(print, ' '),
'Reload Textures [F6]' : application.hot_reloader.reload_textures,
'Reload Models [F7]' : application.hot_reloader.reload_models,
'Reload Code [F5]' : application.hot_reloader.reload_code,
},
width=.3,
x=.64,
enabled=False,
eternal=True
)
self.cog_menu.on_click = Func(setattr, self.cog_menu, 'enabled', False)
self.cog_menu.y = -.5 + self.cog_menu.scale_y
self.cog_menu.scale *= .75
self.cog_menu.text_entity.x += .025
self.cog_menu.highlight.color = color.azure
self.cog_button = Button(parent=self.editor_ui, eternal=True, model='circle', scale=.015, origin=(1,-1), position=self.bottom_right)
def _toggle_cog_menu():
self.cog_menu.enabled = not self.cog_menu.enabled
self.cog_button.on_click = _toggle_cog_menu
def set_up(self):
self.display_region = base.camNode.get_display_region(0)
win = self.display_region.get_window()
self.perspective_lens = PerspectiveLens()
self.perspective_lens = base.camLens # use panda3d's default for automatic aspect ratio on window resize
self.lens = self.perspective_lens
self.perspective_lens.set_aspect_ratio(16/9)
self.perspective_lens_node = LensNode('perspective_lens_node', self.perspective_lens)
self.lens_node = self.perspective_lens_node
self.orthographic_lens = OrthographicLens()
self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio, self.fov)
self.orthographic_lens_node = LensNode('orthographic_lens_node', self.orthographic_lens)
application.base.cam.node().set_lens(self.lens)
self.orthographic = False
self.fov = 40
self.clip_plane_near = 0.1
self.clip_plane_far = 10000
self.ui_display_region = win.make_display_region()
self.ui_display_region.set_sort(20)
self.ui_camera = NodePath(PandaCamera('ui_camera'))
self.ui_lens = OrthographicLens()
# moved set_film_size() to window module for correct aspect ratio after setting window size
self.ui_lens.set_near_far(-1000, 1000)
self.ui_camera.node().set_lens(self.ui_lens)
self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens)
for f in self.funcs:
if not f.finished and f.delay <= self.t:
f()
if self.t >= self.duration:
if self.loop:
for f in self.funcs:
f.finished = False
self.t = 0
return
if self.auto_destroy and self in application.sequences:
application.sequences.remove(self)
del self
def __init__(self, *args, **kwargs):
super().__init__()
self.args = list(args)
self.t = 0
self.time_step = Sequence.default_time_step
self.duration = 0
self.funcs = list()
self.paused = True
self.loop = False
self.auto_destroy = True
for key, value in kwargs.items():
setattr(self, key, value)
self.generate()
application.sequences.append(self)
def __setattr__(self, name, value):
if name == 'visible':
window.set_cursor_hidden(not value)
application.base.win.requestProperties(window)
if name == 'locked':
try:
object.__setattr__(self, name, value)
window.set_cursor_hidden(value)
application.base.win.requestProperties(window)
except:
pass
try:
super().__setattr__(name, value)
# return
except:
pass