def __init__(self, logcsv):
ShowBase.__init__(self)
self.logcsv = logcsv
self.log_count = 0
self.log_time_offset = 0
self.log_time = 0
# Add the spinCameraTask procedure to the task manager.
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
self.taskMgr.add(self.getSerialDataTask, "GetSerialDataTask")
# Load and transform the panda actor.
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.reparentTo(self.render)
# Loop its animation.
self.pandaActor.loop("walk")
node_x, node_y, node_z = self.createAccelNodes(1, 1, 1)
self.np_x = p3d.NodePath(node_x)
self.np_y = p3d.NodePath(node_y)
self.np_z = p3d.NodePath(node_z)
self.np_x.reparentTo(self.render)
self.np_y.reparentTo(self.render)
self.np_z.reparentTo(self.render)
def getSerialDataTask(self, task):
quat, accel, gyro = get_data_via_serial()
if not quat or not accel or not gyro:
return Task.cont
if self.log_time_offset == 0:
self.log_time_offset = time.time()
t = time.time() - self.log_time_offset
self.logcsv.writerow([(t - self.log_time) * 1000, self.log_count] +
quat + accel + gyro)
self.log_count += 1
self.log_time = t
if quat:
self.pandaActor.setQuat(
p3d.LQuaternionf(quat[0], quat[1], quat[2], quat[3]))
if accel:
self.np_x.removeNode()
self.np_y.removeNode()
self.np_z.removeNode()
node_x, node_y, node_z = self.createAccelNodes(
accel[0] * 10, accel[1] * 10, accel[2] * 10)
self.np_x = p3d.NodePath(node_x)
self.np_y = p3d.NodePath(node_y)
self.np_z = p3d.NodePath(node_z)
self.np_x.reparentTo(self.render)
self.np_y.reparentTo(self.render)
self.np_z.reparentTo(self.render)
return Task.cont
def process_tile(x, y):
tile = self._bsp[y][x]
if tile != '.':
tilenp = self._tile_root.attach_new_node('TileNode')
tile_model.instance_to(tilenp)
tile_pos = p3d.LVector3(x - sizex / 2.0, y - sizey / 2.0,
-random.random() * 0.1)
tilenp.set_pos(tile_pos)
if tile == '*':
# Player start
self.player_start.x = tile_pos.x
self.player_start.y = tile_pos.y
elif tile == '&':
# Exit
self.exit_loc.x = tile_pos.x
self.exit_loc.y = tile_pos.y
exitnp = p3d.NodePath('Exit')
tele_model.instance_to(exitnp)
exitnp.set_pos(tile_pos + p3d.LVector3(0, 0, 1))
exitnp.reparent_to(self.model_root)
elif tile == '$':
# Monster spawn
spawnnp = p3d.NodePath('Spawn')
spawn_model.instance_to(spawnnp)
spawnnp.set_pos(tile_pos + p3d.LVector3(0, 0, 1))
spawnnp.set_h(180)
spawnnp.reparent_to(self.model_root)
self.spawners.append(spawnnp)
elif tile.isdigit():
# Teleporter
telenp = self.model_root.attach_new_node('Teleporter')
tele_model.instance_to(telenp)
telenp.set_pos(tile_pos + p3d.LVector3(0, 0, 1))
if tile not in self._telemap:
self._telemap[tile] = [(x, y)]
else:
self._telemap[tile].append((x, y))
# This is the second teleporter we found for this pair so add a link
tlnp = self.model_root.attach_new_node(
'TeleporterLink')
telelink_model.instance_to(tlnp)
tlnp.set_pos(tile_pos + p3d.LVector3(0, 0, 1))
teleloc = self._tile_to_world(
*self._get_tele_loc_from_tile(x, y))
tovec = p3d.LVector3(teleloc, tlnp.get_z())
linkvec = tovec - tlnp.get_pos()
tlnp.set_scale(1, linkvec.length(), 1)
tlnp.look_at(tovec)
def init_components(self, components):
for comp in components[pcomps.NodePathComponent]:
comp.nodepath = p3d.NodePath(p3d.PandaNode(comp.name))
if comp.parent is not None:
comp.nodepath.reparent_to(comp.parent)
for comp in components[pcomps.StaticMeshComponent]:
nodepath = self.get_nodepath(comp)
comp.model = p3d.NodePath(p3d.Loader().get_global_ptr().load_sync(
comp.modelpath))
comp.model.reparent_to(nodepath)
def __init__(self):
super().__init__()
self.assetlib = gestalt.assetlibrary.AssetLibrary()
self.camera = None
# Viewport Widgets
self.viewport_widgets = p3d.NodePath('Viewport Widgets')
self.floorplane = gestalt.floorplane.FloorPlane(scale=1_000)
self.floorplane.nodepath.reparent_to(self.viewport_widgets)
# Scene
self.scene_root = p3d.NodePath('Scene Root')
def three_rings():
node_path = core.NodePath('three_rings')
o1 = obelisk((1.5, 0.8))
o2 = obelisk((1.5, 0.8))
o1.reparent_to(node_path)
o2.reparent_to(node_path)
o1.set_pos(common.TR_O1_OFFSET)
o2.set_pos(common.TR_O2_OFFSET)
random.shuffle(common.TR_COLORS)
rings = []
symbol_cards = []
for r, h, c in zip(common.TR_RADII, common.TR_HEIGHTS, common.TR_COLORS):
rings.append(
node_path.attach_new_node(
sg.cone(origin=core.Vec3(0),
direction=core.Vec3.up(),
radius=r,
polygon=common.TR_POLYGON,
length=h,
color=c,
nac=False)))
symbol_cards.append([])
for i in range(6):
r_node = rings[-1].attach_new_node('rot')
c = core.CardMaker(f'symbol {len(rings)}/{i}')
c.set_frame(core.Vec4(-1, 1, -1, 1))
symbol_cards[-1].append(r_node.attach_new_node(c.generate()))
r_node.set_h(i * 60)
r_node.set_transparency(core.TransparencyAttrib.M_alpha)
r_node.set_alpha_scale(common.TR_SYM_ALPHA)
symbol_cards[-1][-1].set_y(r - 0.5)
symbol_cards[-1][-1].set_z(h)
symbol_cards[-1][-1].set_billboard_axis()
return node_path, rings, symbol_cards
def obelisk(r=(2.5, 1.8)):
node_path = core.NodePath('obelisk')
base = node_path.attach_new_node(
sg.cone(origin=core.Vec3(0),
direction=core.Vec3.up(),
radius=r,
polygon=4,
length=15.0,
smooth=False,
capsule=False,
origin_offset=0,
color=core.Vec4(core.Vec3(0.2), 1),
nac=False))
top = node_path.attach_new_node(
sg.cone(origin=core.Vec3(0),
direction=core.Vec3.up(),
radius=(r[1], 0),
polygon=4,
length=1.5,
smooth=False,
capsule=False,
origin_offset=0,
color=core.Vec4(core.Vec3(0.2), 1),
nac=False))
top.set_z(15)
# mat = core.Material()
# mat.set_emission(core.Vec4(.35, 1.0, 0.52, 0.1))
# mat.set_shininess(5.0)
# node_path.set_material(mat)
return node_path
def test_component_handling():
baseitem = DirectGuiBase()
testoptiondefs = (('test-1', 0, None), )
baseitem.defineoptions({}, testoptiondefs)
assert len(baseitem.components()) == 0
baseitem.createcomponent(
'componentName', # componentName
(), # componentAliases
'componentGroup', # componentGroup
OnscreenText, # widgetClass
(), # *widgetArgs
text='Test', # **kw
parent=core.NodePath())
# check if we have exactly one component now
assert len(baseitem.components()) == 1
# check if we have a component named like the one we just created
assert baseitem.hascomponent('componentName')
# get our new component
component = baseitem.component('componentName')
# check some of its values
assert component.text == 'Test'
# destroy our recently created component
baseitem.destroycomponent('componentName')
# check if it really is gone
assert baseitem.hascomponent('componentName') == False
def light_attrib():
light = core.AmbientLight('amb')
light.color = (1, 1, 1, 1)
light_attrib = core.LightAttrib.make()
light_attrib = light_attrib.add_on_light(core.NodePath(light))
return light_attrib
def __init__(self, room):
self.root = core.NodePath('Room')
self.room_model = room
self.room_model.reparent_to(self.root)
self.name = room.name
self.doors = [i for i in self.room_model.find_all_matches('**/door*')]
self.portals = [Portal(self, i) for i in self.doors]
for i in self.doors:
i.set_transparency(core.TransparencyAttrib.M_alpha)
i.set_alpha_scale(0.0)
i.set_color(core.Vec4(0))
for np in i.find_all_matches('**/+GeomNode'):
geom_node = np.node()
process_geom_node(geom_node)
portal_vert_str = load_shader_str('portal.vert')
portal_frag_str = load_shader_str('portal_screenspace.frag')
portalshader = core.Shader.make(
core.Shader.SL_GLSL,
vertex=portal_vert_str,
fragment=portal_frag_str,
)
for i in self.doors:
i.set_shader(portalshader)
self._active = False
self.room_model.node().set_bounds(core.OmniBoundingVolume())
self.room_model.node().set_final(True)
for i in self.room_model.find_all_matches('**/Sun*/Sun*'):
try:
self.root.set_light(i)
except AssertionError:
pass
def test_glsl_mat4(gsg):
param1 = core.LMatrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
param2 = core.NodePath("param2")
param2.set_mat(core.LMatrix4(
17, 18, 19, 20,
21, 22, 23, 24,
25, 26, 27, 28,
29, 30, 31, 32))
preamble = """
uniform mat4 param1;
uniform mat4 param2;
"""
code = """
assert(param1[0] == vec4(1, 2, 3, 4));
assert(param1[1] == vec4(5, 6, 7, 8));
assert(param1[2] == vec4(9, 10, 11, 12));
assert(param1[3] == vec4(13, 14, 15, 16));
assert(param2[0] == vec4(17, 18, 19, 20));
assert(param2[1] == vec4(21, 22, 23, 24));
assert(param2[2] == vec4(25, 26, 27, 28));
assert(param2[3] == vec4(29, 30, 31, 32));
"""
run_glsl_test(gsg, code, preamble, {'param1': param1, 'param2': param2})
def generate(parent=None, texture=None, foreground=False):
bgnp = p3d.NodePath(p3d.CardMaker('bgimg').generate())
bgnp.set_shader(p3d.Shader.make(p3d.Shader.SL_GLSL, _BG_VERT, _BG_FRAG))
bgnp.set_shader_input('exposure_inv', 1.0 / base.render_pipeline.exposure)
bgnp.set_bin('fixed' if foreground else 'background', 0)
bgnp.set_depth_test(False)
bgnp.set_depth_write(False)
bgnp.node().set_bounds(p3d.OmniBoundingVolume())
bgnp.node().set_final(True)
if parent is not None:
bgnp.reparent_to(parent)
if texture is not None:
suffix = 'fg' if foreground else 'bg'
tex = base.loader.load_texture(f'backgrounds/{texture}{suffix}.png')
if tex.num_components == 4:
bgnp.set_transparency(p3d.TransparencyAttrib.M_alpha)
tex.set_format(p3d.Texture.F_srgb_alpha)
else:
tex.set_format(p3d.Texture.F_srgb)
else:
tex = p3d.Texture()
bgnp.set_shader_input('tex', tex)
return bgnp
def __init__(self, *, scale=10, grid_color=None):
self.scale = scale
if grid_color is None:
grid_color = p3d.LColor(1, 1, 1, 0.8)
# Create a plane
cardmaker = p3d.CardMaker('Floor Plane')
geom = cardmaker.generate()
geomnp = p3d.NodePath(geom)
# Transform the plane
geomnp.set_scale(scale)
geomnp.set_p(-90)
half_scale = scale / 2
geomnp.set_x(-half_scale)
geomnp.set_y(-half_scale)
# Push transforms to the geometry
geomnp.flatten_strong()
# Add a shader to draw grid lines
geomnp.set_transparency(p3d.TransparencyAttrib.M_alpha)
shader = p3d.Shader.make(p3d.Shader.SL_GLSL, FP_VERT, FP_FRAG)
geomnp.set_shader(shader)
geomnp.set_shader_input('grid_color', grid_color)
self.nodepath = geomnp
def __init__(self, refNode, length, key):
self.cosy = pcore.NodePath('cosy')
self.cosy_visible = False
self.refNode = refNode
self.length = length
#for i in range(0,51):
#x_axis = self.printText("X", "|", (1,0,0)).setPos(i,0,0) # note that "X" is the name of the TextNode, not its content.
##Also note that we are going up in increments of 1.
#for i in range(0,51):
#y_axis = self.printText("Y", "|", (0,1,0)).setPos(0,i,0)
#for i in range(-50,51):
#z_axis = self.printText("Z", "-", (0,0,1)).setPos(0,0,i)
(self.x_axis, _, self.x_axis_points,
_) = self.drawLine(0, 0, 0, self.length, 0, 0)
self.x_axis.setColor(1, 0, 0, 1)
(self.y_axis, _, self.y_axis_points,
_) = self.drawLine(0, 0, 0, 0, self.length, 0)
self.y_axis.setColor(0, 1, 0, 1)
(self.z_axis, _, self.z_axis_points,
_) = self.drawLine(0, 0, 0, 0, 0, self.length)
self.z_axis.setColor(0, 0, 1, 1)
x_label = self.printText("XL", "X",
(0, 0, 0)).setPos(self.length / 3., 0, 0)
y_label = self.printText("YL", "Y",
(0, 0, 0)).setPos(0, self.length / 3., 0.5)
z_label = self.printText("YL", "Z",
(0, 0, 0)).setPos(0, 0, self.length / 3.)
self.accept(key, self.switch_on_off)
def optimize_bam(path):
path = core.Filename.from_os_specific(path)
loader = core.Loader.get_global_ptr()
node = loader.load_sync(path)
model = core.NodePath(node)
print("Before:")
analyze_node(node)
any_changed = False
for child in model.find_all_matches('**/+GeomNode'):
gnode = child.node()
for i in range(gnode.get_num_geoms()):
if optimize_geom(gnode, i):
any_changed = True
for tex in model.find_all_textures():
if tex.name and not tex.filename:
rel_path = 'layers/' + tex.name + '.png'
dir = core.Filename(path.get_dirname())
fn = core.Filename(dir, rel_path)
if tex.write(fn):
print(f"{tex.name}: wrote to {fn}")
tex.filename = 'assets/' + dir.get_basename() + '/' + rel_path
tex.fullpath = fn
any_changed = True
if any_changed:
model.write_bam_file(path)
print("After:")
analyze_node(node)
else:
print("File is already optimized, no changes needed.")
def manager3d():
root = core.NodePath("root")
manager = core.AudioManager.create_AudioManager()
manager3d = Audio3DManager(manager, root=root)
yield manager3d
del manager3d
manager.shutdown()
def __init__(self):
super().__init__()
x = float(base.win.get_x_size())
y = float(base.win.get_y_size())
y_aspect = y / x
inventory_base_width = INVENTORY_VERTICAL_FRACTION * y_aspect
inventory_half_width = inventory_base_width * INVENTORY_HORIZONTAL_FACTOR * 0.5
self.region = base.win.make_display_region(
0.5 - inventory_half_width, # left
0.5 + inventory_half_width, # right
0.0, # bottom
INVENTORY_VERTICAL_FRACTION, # top
)
self.region.set_sort(INVENTORY_DISPLAY_REGION_SORT)
self.cam_node = p3d.Camera('inventory_cam')
lens = OrthographicLens()
lens.set_film_size(INVENTORY_HORIZONTAL_FACTOR, 1)
self.cam_node.set_lens(lens)
self.cam_np = NodePath(self.cam_node)
self.region.set_camera(self.cam_np)
self.inventory = NodePath('inventory')
self.cam_np.reparentTo(self.inventory)
background_maker = CardMaker('inventory')
background_maker.set_frame(-INVENTORY_HORIZONTAL_FACTOR / 2.0, INVENTORY_HORIZONTAL_FACTOR / 2.0, 0, 1)
background = p3d.NodePath(background_maker.generate())
background.reparent_to(self.inventory)
background.set_pos(0, 5, -0.5)
def main():
parser = argparse.ArgumentParser(
description=
'A tool for creating BAM files from Panda3D supported file formats')
parser.add_argument('src', type=str, help='source path')
parser.add_argument('dst', type=str, help='destination path')
args = parser.parse_args()
src = p3d.Filename.from_os_specific(os.path.abspath(args.src))
dst = p3d.Filename.from_os_specific(os.path.abspath(args.dst))
dst.make_dir()
loader = p3d.Loader.get_global_ptr()
options = p3d.LoaderOptions()
options.flags |= p3d.LoaderOptions.LF_no_cache
scene = p3d.NodePath(loader.load_sync(src, options))
# Update texture paths
converted_textures = set()
for node in scene.find_all_matches('**/+GeomNode'):
make_texpath_relative(node, src.get_dirname(), converted_textures)
scene.write_bam_file(dst)
def create_lights(self):
# function for converting cylindrical coordinates to cartesian
# coordinates
rtz2xyz = lambda r, t, z: (r * np.cos(t), r * np.sin(t), z)
# positions for point lights
plight_pos = [
rtz2xyz(1.5, 4 * np.pi / 12., 0),
rtz2xyz(1.5, 12 * np.pi / 12., 0),
rtz2xyz(1.5, 20 * np.pi / 12., 0),
(0, 0, 1.3),
]
# create point lights
self.plights = p3d.NodePath("plights")
for i, pos in enumerate(plight_pos):
plight = pm.PointLight('plight%d' % i)
plight.setColor((0.5, 0.5, 0.5, 1.0))
plight.setAttenuation((0, 0, 0.5))
plnp = self.plights.attachNewNode(plight)
plnp.setPos(pos)
self.render.setLight(plnp)
self.plights.reparentTo(self.lights)
self.plights.setPos(0, 0, 4 / 3.)
# update the position and color of the spotlight
slnp = self.lights.find('slight')
slnp.setPos((8, 6, 20))
slnp.lookAt(self.look_at)
slnp.node().setColor((1, 1, 1, 1))
# update the color of the ambient light
alnp = self.lights.find('alight')
alnp.node().setColor((0.2, 0.2, 0.2, 1))
def __init__(self, world):
notify.info('Initializing world geometry')
self.world = world
self.node = core.NodePath('world')
# shader = core.Shader.load(core.Shader.SLGLSL, 'media/shaders/vertex.glsl', 'media/shaders/fragment.glsl')
# self.node.setShader(shader)
self.node.setShaderInput('color_scale', 1.0)
self.bordertexture = loader.loadTexture('media/textures/border.png',
anisotropicDegree=16,
minfilter=core.Texture.FTLinearMipmapLinear)
self.node.setShaderInput('border_texture', self.bordertexture)
self.slices = []
for z in range(self.world.depth):
slice = Slice(self.world, z)
slice.reparentTo(self.node)
self.slices.append(slice)
for x, y in self.world.columns():
f, s, h = self.world.get_raw(x, y, z)
if s and not h:
slice.update_all()
break
self.accept('slice-changed', self.slice_changed)
self.accept('block-update', self.block_update)
self.accept('entity-z-change', self.reparent_entity)
self.accept('designation-add', self.designation)
notify.info('Initializing world geometry complete')
def __init__(self, form, parent_node=None, weapon=None):
self.form = form
mesh = self.form.mesh
if hasattr(builtins, 'base'):
if self._ANIMS is None:
anim_root = base.loader.load_model(self._ANIM_FILE)
self.__class__._ANIMS = p3d.NodePath('anims')
for bundle in anim_root.find_all_matches('**/+AnimBundleNode'):
bundle.reparent_to(self._ANIMS)
model = base.loader.load_model('models/{}.bam'.format(
mesh['bam_file']))
root_node = model.find('**/{}'.format(mesh['root_node']))
if root_node.is_empty():
print(f"Warning: root node ({mesh['root_node']}) not found in "
f"bam_file ({mesh['bam_file']}) for {form.id}")
else:
self._ANIMS.instance_to(root_node)
self._path = Actor(root_node)
if weapon:
self.update_weapon(weapon)
self.play_anim('idle', loop=True)
if parent_node:
self._path.reparent_to(parent_node)
else:
self._path = Actor()
def __init__(self):
ShowBase.__init__(self)
self.accept('escape', sys.exit)
texture = p3d.Texture()
texture.setup_buffer_texture(10, p3d.Texture.T_unsigned_int,
p3d.Texture.F_rgba32,
p3d.GeomEnums.UH_dynamic)
gsg = self.win.get_gsg()
pobs = gsg.get_prepared_objects()
tex_ctx = texture.prepare_now(0, pobs, gsg)
compute_node = p3d.ComputeNode('compute_node')
compute_node.add_dispatch(10, 1, 1)
compute_np = p3d.NodePath(compute_node)
compute_np.reparent_to(self.render)
compute_shader = p3d.Shader.make_compute(p3d.Shader.SL_GLSL,
SHADER_SRC)
compute_np.set_shader(compute_shader)
compute_np.set_shader_input('test_buffer', texture, False, True, -1, 0)
def extract_texture(task):
self.graphics_engine.extract_texture_data(texture,
self.win.get_gsg())
view = memoryview(texture.get_ram_image()).cast('i')
for i in range(10):
print(view[i], end=' ')
print()
return task.cont
taskMgr.add(extract_texture, 'extract_texture', sort=55)
def __init__(self, modelpath=None):
super().__init__()
self.synchronize = True
self._modelpath = modelpath if modelpath else ''
if modelpath is not None:
self.nodepath = base.loader.loadModel(modelpath)
else:
self.nodepath = p3d.NodePath(p3d.PandaNode('node'))
def add(self, w, x, y, z):
n = core.NodePath('designation')
n.setPos(x, y, z)
n.setShader(self.shader)
n.setShaderInput('color', core.Vec4(0.5, 1.0, 0.5, 0.5))
self.model.instanceTo(n)
messenger.send('designation-add', [x, y, z, n])
def __init__(self):
super().__init__()
self.accept('toggle-debug-cam', self.toggle_debug_cam)
self.accept('move', self.move_player)
self.accept('ability1', self.toggle_range, [0])
self.accept('ability2', self.toggle_range, [1])
self.accept('ability3', self.toggle_range, [2])
self.accept('ability4', self.toggle_range, [3])
self.mapgen = 'static'
dungeon = Dungeon(self.mapgen, self.DUNGEON_SX, self.DUNGEON_SY)
dungeon.model_root.reparent_to(self.root_node)
dlight = p3d.DirectionalLight('sun')
dlight.set_color(p3d.LVector3(0.2, 0.2, 0.2))
dlight.set_shadow_caster(True, 4096, 4096)
dlnp = self.root_node.attach_new_node(dlight)
dlnp.set_z(10)
dlnp.set_p(-90)
lens = dlight.get_lens()
lens.set_film_size(60)
lens.set_near(1)
lens.set_far(100)
self.root_node.set_light(dlnp)
dlight2 = p3d.DirectionalLight('ground')
dlight2.set_color(p3d.LVector3(0.1, 0.1, 0.1))
dlnp2 = self.root_node.attach_new_node(dlight2)
self.root_node.set_light(dlnp2)
loader = p3d.Loader.get_global_ptr()
player = p3d.NodePath(
loader.load_sync('dungeon.bam')).find('**/MonsterSpawn').node()
playernp = self.root_node.attach_new_node(player)
playernp.set_pos(dungeon.player_start)
playernp.set_z(1.5)
self.player_ranges = [
RangeIndicator('box', length=5, width=1),
RangeIndicator('circle', radius=2),
RangeIndicator('circle', radius=3),
RangeIndicator('circle', radius=4),
]
for rangeindicator in self.player_ranges:
rangeindicator.graphics.reparent_to(playernp)
rangeindicator.visible = False
# self.root_node.ls()
# self.root_node.analyze()
self.dungeons = [dungeon]
self.dungeon_idx = 0
self.dungeon = dungeon
self.player = playernp
self.last_tele_loc = None
self.target = self.player.get_pos()
self.debug_cam = False
self.reset_camera()
def map_property(**items):
""" Returns a mapping property initialized with the given values. """
# It doesn't matter which property we use; I just happened to pick
# NodePath.tags.
np = core.NodePath("")
for k, v in items.items():
np.set_tag(k, v)
return np.tags
def __init__(self):
super().__init__()
self.physics_world = bullet.BulletWorld()
self.physics_world.set_gravity(p3d.LVector3(0, 0, -9.8))
phydebug = bullet.BulletDebugNode('Physics Debug')
phydebug.show_wireframe(True)
#phydebug.show_bounding_boxes(True)
self._debugnp = p3d.NodePath(phydebug)
self.physics_world.set_debug_node(phydebug)
def __init__(self):
super().__init__()
self.root_node = p3d.NodePath('State Root')
self.root_node.reparent_to(base.render)
self.root_node2d = p3d.NodePath('State Root 2D')
self.root_node2d.reparent_to(base.render2d)
self.dgui = None
self.menu_helper = MenuHelper(self.update_ui)
self._input_state = None
self._next_input_state = None
self._next_state_args = None
self._next_state_kwargs = None
def handle_fade(task):
if base.transitions.fadeOutActive():
base.transitions.fadeIn()
return task.done
base.taskMgr.do_method_later(0, handle_fade, 'Fade In')
def __init__(self, file_path, name=None, layers={}, \
rows=1, cols=1, scale=1.0, two_sided=True, alpha=TRANS_ALPHA, \
repeat_x=1, repeat_y=1, anchor_x=ALIGN_LEFT, anchor_y=ALIGN_BOTTOM):
scale *= self.PIXEL_SCALE
self._animations = {}
self._scale = scale
self._repeat_x = repeat_x
self._repeat_y = repeat_y
self._flip = {'x': False, 'y': False}
self._rows = rows
self._cols = cols
self._current_frame = 0
self._current_anim = None
self._loop_anim = False
self._frame_interrupt = True
self._play_task = None
# Resolve file path
base_img_file = self.__resolve_vfs_relative_path(
file_path=file_path, file_type='spritesheet')
# Create the root node
extension = name if name else base_img_file.get_basename_wo_extension()
node_name = '%s:%s' % (self.__class__.__name__, extension)
self._node = core.NodePath(node_name)
if alpha:
self._node.node().set_attrib(core.TransparencyAttrib.make(alpha))
self._node.set_two_sided(two_sided)
# Load the base sprite sheet
self._img_file = None
self._size_x = 0
self._size_y = 0
self._frames = []
self._real_size_x = 0
self._real_size_y = 0
self._padded_img = None
self._final_img = None
self.__load_base_sheet(base_img_file)
self.__construct_sprite_card(anchor_x, anchor_y)
# Define layers
self._layers = {}
for layer_name in layers:
layer_path = layers[layer_name]
self.add_layer(layer_name, layer_path)
# Build final image
self.__update_final_image()
self.__construct_sprite_texture()
def _place_dense(self, left, right):
# FIXME: Account for possibly more than two prop with 100% density
placed = 0
dense_parts = self._part_mgr.get_prop_by_prefix(self._level, 0)
random.shuffle(dense_parts)
for part in dense_parts:
if placed > 1:
break
if random.random() > part.density:
continue
np = core.NodePath('prop')
part.model.copy_to(np)
np.reparent_to(base.render)
np.set_shader(PROP_SHADER)
np.set_shader_input('i_hue', self._current_hue)
np.set_shader_input('i_zmax', part.bounds.mmax.z)
np.set_shader_input('i_height',
part.bounds.mmax.z - part.bounds.mmin.z)
np.set_shader_input('i_shade', SH_Z_SHADE_COLOR)
np.set_shader_input('i_shade_exp', SH_Z_SHADE_EXP)
np.set_shader_input('i_alpha_f', 1.0)
for n in np.get_children():
bmin, bmax = np.get_tight_bounds()
origin = Vec3(
(bmax.x - bmin.x) / 2 + bmin.x,
(bmax.y - bmin.y) / 2 + bmin.y,
bmax.z,
)
end = Vec3(
(bmax.x - bmin.x) / 2 + bmin.x,
(bmax.y - bmin.y) / 2 + bmin.y,
bmin.z,
)
n.set_shader(LIGHT_SHADER)
n.set_shader_input('i_hue', self._current_hue)
n.set_shader_input('i_end', end)
n.set_shader_input('i_origin', origin)
n.set_shader_input('i_shade', SH_Z_SHADE_COLOR)
n.set_shader_input('i_shade_exp', SH_Z_SHADE_EXP)
n.set_shader_input('i_alpha_f', 0.1)
if (self._dense_counter + placed) % 2:
np.set_scale(PR_SCALE)
np.set_pos(left, self._next_part_y, 0)
else:
np.set_h(180)
np.set_scale(PR_SCALE)
np.set_pos(right, self._next_part_y, 0)
self._parts.append(np)
placed += 1
self._dense_counter += 1
