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 generate_border(path, frame):
cm = core.CardMaker("border")
cm.set_frame(frame[0] - BORDER_WIDTH, frame[0], frame[2] - BORDER_WIDTH,
frame[3] + BORDER_WIDTH)
border = path.attach_new_node(cm.generate())
border.set_shader_off(1)
border.set_color_scale_off(1)
cm.set_frame(frame[1], frame[1] + BORDER_WIDTH, frame[2] - BORDER_WIDTH,
frame[3] + BORDER_WIDTH)
border = path.attach_new_node(cm.generate())
border.set_shader_off(1)
border.set_color_scale_off(1)
cm.set_frame(frame[0] - BORDER_WIDTH, frame[1] + BORDER_WIDTH,
frame[2] - BORDER_WIDTH, frame[2])
border = path.attach_new_node(cm.generate())
border.set_shader_off(1)
border.set_color_scale_off(1)
cm.set_frame(frame[0] - BORDER_WIDTH, frame[1] + BORDER_WIDTH, frame[3],
frame[3] + BORDER_WIDTH)
border = path.attach_new_node(cm.generate())
border.set_shader_off(1)
border.set_color_scale_off(1)
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 __setup_solved_symbols(self):
c = core.CardMaker('solved')
c.set_frame(core.Vec4(0, 0.2, -0.3, 0.3))
c.set_color(core.Vec4(0))
node_path = self.a2dLeftCenter.attach_new_node(c.generate())
node_path.set_transparency(core.TransparencyAttrib.M_alpha)
self.__solved_symbols = []
c = core.CardMaker('s0')
c.set_frame(core.Vec4(0.02, 0.18, -0.3, -0.14))
self.__solved_symbols.append(node_path.attach_new_node(c.generate()))
c = core.CardMaker('s1')
c.set_frame(core.Vec4(0.02, 0.18, -0.08, 0.08))
self.__solved_symbols.append(node_path.attach_new_node(c.generate()))
c = core.CardMaker('s2')
c.set_frame(core.Vec4(0.02, 0.18, 0.14, 0.3))
self.__solved_symbols.append(node_path.attach_new_node(c.generate()))
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, scene: core.NodePath, tile_manager: manager.Manager):
self._scene = scene
self._tile_manager = tile_manager
self._card_maker = core.CardMaker("geometry")
self._card_maker.set_frame(-0.5, 0.5, 0, 1)
self._sprites: typing.List[core.NodePath] = []
def __init__(self, title=""):
self.path = OnscreenText(text=title,
scale=0.2,
pos=(0, 0.5),
fg=UI_COLOR,
font=base.title_font)
if base.blurred_tex:
cm = core.CardMaker("card")
cm.set_frame_fullscreen_quad()
card = render2d.attach_new_node(cm.generate())
card.set_shader(base.blur_shader)
card.set_shader_input("image", base.blurred_tex)
card.set_shader_input("direction", (4, 0))
card.set_shader_input("scale", base.blur_scale)
card.set_transparency(1)
self.blur_card = card
else:
self.blur_card = core.NodePath("")
cm = core.CardMaker("card")
cm.set_frame_fullscreen_quad()
card = render2d.attach_new_node(cm.generate())
if base.quality is None:
card.set_color(core.LColor(0, 0, 0, 0.5))
else:
card.set_color(core.LColor(0, 0, 0, 1))
card.set_transparency(1)
card.set_bin('fixed', 40)
self.fade_card = card
# Start hidden
self.hide_now()
self._first_item = None
self._prev_item = None
def _initializeViewport(self) -> None:
"""
"""
# Initialize our ShowBase instance
wp = p3d.WindowProperties.getDefault()
wp.set_size(self.width(), self.height())
wp.set_origin(0, 0)
wp.set_parent_window(int(self.winId()))
wp.set_undecorated(True)
self.base = showbase.PainterShowBase(windowType='none')
self.base.windowType = 'onscreen'
self.base.openDefaultWindow(props=wp)
self.base.set_background_color(0, 0, 0, 1)
# Setup our task manager step timer
self._pandaTimer = QtCore.QTimer(self)
self._pandaTimer.timeout.connect(base.task_mgr.step)
self._pandaTimer.start(0)
# Create our display quad
cardMaker = p3d.CardMaker("ItemCard")
cardMaker.set_frame(-0.8, 0.8, -0.8, 0.8)
self.itemCard = self.base.aspect2d.attach_new_node(
cardMaker.generate())
runtime.itemCard = self.itemCard
shader = p3d.Shader.load(p3d.Shader.SL_GLSL,
vertex='shader/item.vert.glsl',
fragment='shader/item.frag.glsl')
self.itemCard.set_shader(shader)
self.itemCard.set_shader_input('pnt_RedChannel', p3d.Vec3(0, 0, 0))
self.itemCard.set_shader_input('pnt_GreenChannel', p3d.Vec3(0, 0, 0))
self.itemCard.set_shader_input('pnt_BlueChannel', p3d.Vec3(0, 0, 0))
self.itemCard.set_shader_input('pnt_CyanChannel', p3d.Vec3(0, 0, 0))
self.itemCard.set_shader_input('pnt_MagentaChannel', p3d.Vec3(0, 0, 0))
self.itemCard.set_shader_input('pnt_YellowChannel', p3d.Vec3(0, 0, 0))
self.itemCard.set_shader_input('pnt_BlackoutChannel',
p3d.Vec3(1, 1, 1))
# Configure our VFS and populate our library
vfs.switch_file_functions_to_vfs()
vfs.switch_io_functions_to_vfs()
runtime.library.pullConfiguration()
def __init__(
self,
start_sector: EditorSector,
camera_collection: cameras.Cameras,
clipping_debug: core.NodePath,
sector_offset=core.Point3(0, 0, 0),
):
self._start_sector = start_sector
self._clip_buffer = numpy.array([WallBunch.ABSOLUTE_MAX_Z] *
self._CLIP_WIDTH).astype("float32")
self._camera_collection = camera_collection
self._transformation_matrix = (
core.Mat4.translate_mat(-sector_offset.x, -sector_offset.y, 0) *
self._camera_collection.get_clipping_transform())
self._visible_sectors: typing.Set[EditorSector] = set()
self._sector_offset = sector_offset
self._clipping_debug = clipping_debug
if constants.PORTALS_DEBUGGING_ENABLED:
self._inverse_transformation_matrix = core.Mat4()
self._inverse_transformation_matrix.invert_from(
self._transformation_matrix)
self._clip_view: core.NodePath = self._clipping_debug.attach_new_node(
"clip_view")
self._clip_view.set_transparency(True)
self._clip_view.set_bin("fixed", constants.FRONT_MOST)
self._clip_card_maker = core.CardMaker("clip_view")
self._clip_buffer_colours = numpy.array(
[[0, 0, 0]] * self._CLIP_WIDTH).astype("float32")
self._debug_colour_index = 0
self._debug_geometry_node = core.GeomNode("clipper")
self._debug_geometry: core.NodePath = self._clipping_debug.attach_new_node(
self._debug_geometry_node)
self._debug_geometry.set_depth_write(False)
self._debug_geometry.set_depth_test(False)
self._debug_geometry.set_bin("fixed", constants.FRONT_MOST)
self._debug_geometry.set_transparency(True)
inverse_projection = core.Mat4().invert_from(
self._transformation_matrix)
def __generate_solution_cards(self):
for i in range(3):
c = core.CardMaker('nbg')
c.set_frame(core.Vec4(-0.5, 0.5, -0.5, 0.5))
self.__solution[i] = self.aspect2d.attach_new_node(c.generate())
im = self.symbols[self.__nonogram_gen.chosen_symbols[i]][0]
a = np.zeros(im.size + (3,), dtype=np.uint8)
a[:, :, 0] = np.array(im)
a[:, :, 1] = np.array(im)
a[:, :, 2] = np.array(im)
tex = core.Texture(f'solution{i}')
tex.setup_2d_texture(
*a.shape[:2],
core.Texture.T_unsigned_byte,
core.Texture.F_rgb
)
tex.set_ram_image_as(a, 'RGB')
tex.reload()
self.__solution[i].set_texture(tex, 1)
self.__solution[i].hide()
def __toggle_nonogram(self, index):
if self.__tutorial:
self.__tutorial = False
c = core.CardMaker('tut')
c.set_frame_fullscreen_quad()
self.__tut_np = self.aspect2d.attach_new_node(c.generate())
tex = self.loader.load_texture('nonogram_wikipedia.png')
self.__tut_np.set_texture(tex, 1)
self.accept_once('space-up', self.__remove_tut)
self.accept_once('enter-up', self.__remove_tut)
self.accept_once('mouse2-up', self.__remove_tut)
self.accept_once('mouse3-up', self.__remove_tut)
self.__inner_bounds = True
self.__ng_last_active = self.global_clock.get_frame_time()
if index == self.__nonogram.current_nonogram_id:
return
if not self.__nonogram.nonogram_loaded:
self.__nonogram.start_nonogram(index)
if not self.__nonogram.is_nonogram_solved(index):
self.__nonogram.set_nonogram_callback(self.__solved, (index, ))
def _move_selection_marquee(self, total_delta: core.Vec2,
delta: core.Vec2):
self._clear_marquee_display()
self._marquee_end = self._marquee_start + total_delta
start, end = self._get_marquee()
card_maker = core.CardMaker("marquee")
card_maker.set_frame(
core.Point3(start.x, start.y, -constants.REALLY_BIG_NUMBER),
core.Point3(start.x, end.y, -constants.REALLY_BIG_NUMBER),
core.Point3(end.x, end.y, -constants.REALLY_BIG_NUMBER),
core.Point3(end.x, start.y, -constants.REALLY_BIG_NUMBER),
)
card_maker.set_color(1, 1, 0, 0.5)
marquee_node = card_maker.generate()
self._marquee_display: core.NodePath = (
self._camera_collection.scene.attach_new_node(marquee_node))
self._marquee_display.set_transparency(True)
def render_depth_pixel(region, distance, near, far, clear=None, write=True, state=None):
"""Renders a fragment at the specified distance using the specified render
settings, and returns the resulting depth value."""
# Set up the scene with a blank card rendering at specified distance.
scene = core.NodePath("root")
scene.set_attrib(core.DepthTestAttrib.make(core.RenderAttrib.M_always))
scene.set_depth_write(write)
if state:
scene.set_state(scene.get_state().compose(state))
camera = scene.attach_new_node(core.Camera("camera"))
camera.node().get_lens(0).set_near_far(near, far)
camera.node().set_cull_bounds(core.OmniBoundingVolume())
if distance is not None:
cm = core.CardMaker("card")
cm.set_frame(-1, 1, -1, 1)
card = scene.attach_new_node(cm.generate())
card.set_pos(0, distance, 0)
card.set_scale(60)
region.active = True
region.camera = camera
if clear is not None:
region.set_clear_depth_active(True)
region.set_clear_depth(clear)
depth_texture = core.Texture("depth")
region.window.add_render_texture(depth_texture,
core.GraphicsOutput.RTM_copy_ram,
core.GraphicsOutput.RTP_depth)
region.window.engine.render_frame()
region.window.clear_render_textures()
col = core.LColor()
depth_texture.peek().lookup(col, 0.5, 0.5)
return col[0]
def create_rectangle(parent_node, r, phi, theta, Dphi, Dtheta, color):
cm = pcore.CardMaker('card')
card = parent_node.attachNewNode(cm.generate())
width = 2 * math.tan(math.radians(Dphi) / 2.) * r
height = 2 * math.tan(math.radians(Dtheta) / 2.) * r
card.setHpr(90. + phi, 90. + theta, 0)
card.setScale(width, 1, height)
card.setPos(
r * math.sin(math.radians(theta)) * math.cos(math.radians(phi)),
r * math.sin(math.radians(theta)) * math.sin(math.radians(phi)) -
width / 2,
r * math.cos(math.radians(theta)) + height / 2.)
card.setTwoSided(True)
card.setColor(color / 255., color / 255., color / 255., 1)
return card
def __construct_sprite_card(self, anchor_x, anchor_y):
"""
Constructs the sprite frame out of a card maker using the requested
anchor points and size
"""
# Create the geometry card
card = core.CardMaker('%s-geom' % self.__class__.__name__)
# Handle positioning based on anchors
if anchor_x == self.ALIGN_LEFT:
self._pos_left = 0
self._pos_right = (self._col_size / self._scale) * self._repeat_x
elif anchor_x == self.ALIGN_CENTER:
self._pos_left = -(self._col_size / 2.0 /
self._scale) * self._repeat_x
self._pos_right = (self._col_size / 2.0 /
self._scale) * self._repeat_x
elif anchor_x == self.ALIGN_RIGHT:
self._pos_left = -(self._col_size / self._scale) * self._repeat_x
self._pos_right = 0
if anchor_y == self.ALIGN_BOTTOM:
self._pos_top = 0
self._pos_bottom = (self._row_size / self._scale) * self._repeat_y
elif anchor_y == self.ALIGN_CENTER:
self._pos_top = -(self._row_size / 2.0 /
self._scale) * self._repeat_y
self._pos_bottom = (self._row_size / 2.0 /
self._scale) * self._repeat_y
elif anchor_y == self.ALIGN_TOP:
self._pos_top = -(self._row_size / self._scale) * self._repeat_y
self._pos_bottom = 0
card.set_frame(self._pos_left, self._pos_right, self._pos_top,
self._pos_bottom)
card.set_has_uvs(True)
assert self._node != None
self._card = self._node.attach_new_node(card.generate())
def __init__(
self,
camera_collection: cameras.Cameras,
tile_manager: manager.Manager,
start_tile: int,
sky_offsets: typing.List[int],
):
camera = camera_collection.make_gui_camera("sky")
camera.display_region.set_sort(constants.BACK_MOST)
camera.display_region.set_active(True)
display_node = core.PandaNode("sky")
self._display: core.NodePath = core.NodePath(display_node)
camera.camera_node.set_scene(self._display)
textures = [
tile_manager.get_tile(start_tile + offset, 0)
for offset in sky_offsets
]
width = 2 / len(textures)
card_maker = core.CardMaker("sky_part")
card_maker.set_frame(-1, -1 + width, 1, -1)
card_node = card_maker.generate()
card: core.NodePath = self._display.attach_new_node(card_node)
card.set_bin("fixed", constants.BACK_MOST)
card.set_depth_write(False)
card.set_two_sided(True)
left = 0.0
for texture_index, texture in enumerate(textures):
sky_part = self._display.attach_new_node(f"sky_{texture_index}")
card.copy_to(sky_part)
card.set_texture(texture, 1)
sky_part.set_x(left)
left += width
card.remove_node()
def __init__(self, shape, **kwargs):
sdftex = None
frame = p3d.LVector4(-1, 1, -1, 1)
scale = p3d.LVector3(1, 1, 1)
offset = p3d.LVector3(0, 0, 0)
if shape == 'circle':
sdftex = _SDF_CIRCLE
scale *= kwargs['radius']
elif shape == 'box':
sdftex = _SDF_BOX
scale = p3d.LVector3(kwargs['width'] / 2.0, 1,
kwargs['length'] / 2.0)
offset = p3d.LVector3(0, kwargs['length'] / 2.0, 0)
else:
raise ValueError(
"Unknown shape for RangeIndicator: {}".format(shape))
cardmaker = p3d.CardMaker('RI_' + shape)
cardmaker.set_frame(frame)
card = p3d.NodePath(cardmaker.generate())
card.set_p(-90)
card.set_scale(scale)
card.set_pos(offset)
card.set_transparency(p3d.TransparencyAttrib.MAlpha)
card.set_texture(sdftex)
card.set_shader(_SHADER)
card.set_shader_input('sdftex', sdftex)
card.set_shader_input('ricolor', p3d.LVector4(0.8, 0.0, 0.0, 0.3))
card.set_shader_input('outline_color',
p3d.LVector4(0.0, 0.0, 0.0, 0.8))
self.graphics = card
def __init__(self):
# Preliminary capabilities check.
if not ape.base().win.getGsg().getSupportsBasicShaders():
self.t = addTitle(
"Shadow Demo: Video driver reports that shaders are not supported."
)
return
if not ape.base().win.getGsg().getSupportsDepthTexture():
self.t = addTitle(
"Shadow Demo: Video driver reports that depth textures are not supported."
)
return
self.inst_p = addInstructions(0.06,
'P : stop/start the Panda Rotation')
self.inst_w = addInstructions(0.12, 'W : stop/start the Walk Cycle')
self.inst_t = addInstructions(0.18, 'T : stop/start the Teapot')
self.inst_l = addInstructions(0.24,
'L : move light source far or close')
self.inst_v = addInstructions(0.30,
'V : View the Depth-Texture results')
self.inst_u = addInstructions(0.36,
'U : toggle updating the shadow map')
self.inst_x = addInstructions(
0.42, 'Left/Right Arrow : switch camera angles')
ape.base().setBackgroundColor(0, 0, 0.2, 1)
ape.base().camLens.setNearFar(1.0, 10000)
ape.base().camLens.setFov(75)
ape.base().disableMouse()
# Load the scene.
floorTex = ape.loader().loadTexture('maps/envir-ground.jpg')
cm = p3dc.CardMaker('')
cm.setFrame(-2, 2, -2, 2)
floor = ape.render().attachNewNode(p3dc.PandaNode("floor"))
for y in range(12):
for x in range(12):
nn = floor.attachNewNode(cm.generate())
nn.setP(-90)
nn.setPos((x - 6) * 4, (y - 6) * 4, 0)
floor.setTexture(floorTex)
floor.flattenStrong()
self.pandaAxis = ape.render().attachNewNode('panda axis')
self.pandaModel = Actor('panda-model', {'walk': 'panda-walk4'})
self.pandaModel.reparentTo(self.pandaAxis)
self.pandaModel.setPos(9, 0, 0)
self.pandaModel.setScale(0.01)
self.pandaWalk = self.pandaModel.actorInterval('walk', playRate=1.8)
self.pandaWalk.loop()
self.pandaMovement = self.pandaAxis.hprInterval(
20.0, p3dc.LPoint3(-360, 0, 0), startHpr=p3dc.LPoint3(0, 0, 0))
self.pandaMovement.loop()
self.teapot = ape.loader().loadModel('teapot')
self.teapot.reparentTo(ape.render())
self.teapot.setPos(0, -20, 10)
self.teapotMovement = self.teapot.hprInterval(
50, p3dc.LPoint3(0, 360, 360))
self.teapotMovement.loop()
self.accept('escape', sys.exit)
self.accept("arrow_left", self.incrementCameraPosition, [-1])
self.accept("arrow_right", self.incrementCameraPosition, [1])
self.accept("p", self.toggleInterval, [self.pandaMovement])
self.accept("t", self.toggleInterval, [self.teapotMovement])
self.accept("w", self.toggleInterval, [self.pandaWalk])
self.accept("v", ape.base().bufferViewer.toggleEnable)
self.accept("u", self.toggleUpdateShadowMap)
self.accept("l", self.incrementLightPosition, [1])
self.accept("o", ape.base().oobe)
self.light = ape.render().attachNewNode(p3dc.Spotlight("Spot"))
self.light.node().setScene(ape.render())
self.light.node().setShadowCaster(True)
self.light.node().showFrustum()
self.light.node().getLens().setFov(40)
self.light.node().getLens().setNearFar(10, 100)
ape.render().setLight(self.light)
self.alight = ape.render().attachNewNode(p3dc.AmbientLight("Ambient"))
self.alight.node().setColor(p3dc.LVector4(0.2, 0.2, 0.2, 1))
ape.render().setLight(self.alight)
# Important! Enable the shader generator.
ape.render().setShaderAuto()
# default values
self.cameraSelection = 0
self.lightSelection = 0
self.incrementCameraPosition(0)
self.incrementLightPosition(0)
def __init__(self, transparent=True, size=None, parent=None):
super().__init__()
# Common application settings
app_settings = {
"windowless_rendering_enabled": True,
}
cef_mod_dir_root = cefpython.GetModuleDirectory()
if sys.platform == "darwin":
app_settings['external_message_pump'] = True
# Detect if we are running in a bundled app, and if so fix the path
# to the framework resources
main_dir = p3d.ExecutionEnvironment.getEnvironmentVariable(
"MAIN_DIR")
if main_dir.startswith(cef_mod_dir_root):
app_settings['browser_subprocess_path'] = os.path.normpath(
os.path.join(cef_mod_dir_root, '../Frameworks/subprocess'))
app_settings['framework_dir_path'] = os.path.normpath(
os.path.join(
cef_mod_dir_root,
'../Resources/Chromium Embedded Framework.framework'))
else:
app_settings['locales_dir_path'] = os.path.join(
cef_mod_dir_root, 'locales')
app_settings['resources_dir_path'] = cef_mod_dir_root
app_settings['browser_subprocess_path'] = os.path.join(
cef_mod_dir_root, 'subprocess')
command_line_settings = {
# Tweaking OSR performance by setting the same Chromium flags as the
# cefpython SDL2 example (also see cefpython issue #240)
"disable-gpu-compositing": "",
"enable-begin-frame-scheduling": "",
}
browser_settings = {
"windowless_frame_rate": 60,
}
cefpython.Initialize(app_settings, command_line_settings)
self._cef_texture = p3d.Texture()
self._cef_texture.set_compression(p3d.Texture.CMOff)
self._cef_texture.set_component_type(p3d.Texture.TUnsignedByte)
self._cef_texture.set_format(p3d.Texture.FRgba4)
card_maker = p3d.CardMaker("browser2d")
if size is None:
size = [-1, 1, -1, 1]
card_maker.set_frame(*size)
self._size = size
node = card_maker.generate()
if parent is None:
self._cef_node = base.render2d.attachNewNode(node)
else:
self._cef_node = parent.attachNewNode(node)
self._cef_node.set_texture(self._cef_texture)
if transparent:
self._cef_node.set_transparency(p3d.TransparencyAttrib.MAlpha)
winhnd = base.win.getWindowHandle().getIntHandle()
wininfo = cefpython.WindowInfo()
wininfo.SetAsOffscreen(winhnd)
wininfo.SetTransparentPainting(True)
self.browser = cefpython.CreateBrowserSync(wininfo,
browser_settings,
navigateUrl='')
self.browser.SetClientHandler(CefClientHandler(self._cef_texture))
self._is_loaded = False
self._js_onload_queue = []
self._js_func_onload_queue = []
self.browser.SetClientCallback("OnLoadEnd", self._load_end)
self.jsbindings = cefpython.JavascriptBindings()
self.browser.SendFocusEvent(True)
self._set_browser_size(base.win)
self.accept('window-event', self._set_browser_size)
base.buttonThrowers[0].node().setKeystrokeEvent('keystroke')
self.accept('keystroke', self._handle_text)
self.accept('arrow_left', self._handle_key, [cefpython.VK_LEFT])
self.accept('arrow_right', self._handle_key, [cefpython.VK_RIGHT])
self.accept('arrow_up', self._handle_key, [cefpython.VK_UP])
self.accept('arrow_down', self._handle_key, [cefpython.VK_DOWN])
self.accept('home', self._handle_key, [cefpython.VK_HOME])
self.accept('end', self._handle_key, [cefpython.VK_END])
self.accept('mouse1', self._handle_mouse, [False])
self.accept('mouse1-up', self._handle_mouse, [True])
self._msg_loop_task = base.taskMgr.add(self._cef_message_loop,
'CEFMessageLoop')
sys.excepthook = cefpython.ExceptHook
atexit.register(self._shutdown_cef)
self.use_mouse = True
def __init__(self, anim_root):
self.move_root = base.render.attach_new_node('hobot')
self.anim_root = anim_root
self.model = Actor('hobot/hobot.bam')
self.hand = self.model.expose_joint(None, 'modelRoot', 'hand')
head = self.model.expose_joint(None, 'modelRoot', 'head')
self.model.reparent_to(self.anim_root)
self.model.set_two_sided(True)
self.model.find("**/+GeomNode").set_transform(
self.model.get_joint_transform_state('modelRoot',
'hobot root').get_inverse())
self.model.set_z(0.1)
self.facing = 1.0
self.move_control = self.model.get_anim_control('move_forward')
self.speed = 0.0
self.locked = True
self.model.wrt_reparent_to(self.move_root)
self.model.hide()
light_texture = loader.load_texture('hobot/light_on.png')
light_texture.set_wrap_u(core.SamplerState.WM_clamp)
light_texture.set_wrap_v(core.SamplerState.WM_clamp)
cm = core.CardMaker('card')
cm.set_frame(-0.15, 0.15, 0.15, 0.45)
self.lightbulb = head.attach_new_node(cm.generate())
self.lightbulb.set_texture(light_texture)
self.lightbulb.set_attrib(
core.ColorBlendAttrib.make(core.ColorBlendAttrib.M_add,
core.ColorBlendAttrib.O_incoming_alpha,
core.ColorBlendAttrib.O_one))
self.lightbulb.set_depth_test(False)
self.lightbulb.set_bin('fixed', 0)
self.lightbulb.set_p(-90)
self.lightbulb.set_billboard_point_eye()
self.lightbulb.set_two_sided(True)
self.lightbulb.hide()
shadow_texture = loader.load_texture('hobot/drop_shadow.png')
shadow_texture.set_wrap_u(core.SamplerState.WM_clamp)
shadow_texture.set_wrap_v(core.SamplerState.WM_clamp)
cm = core.CardMaker('card')
cm.set_frame(-0.35, 0.35, -0.45, -0.1)
self.shadow = self.model.attach_new_node(cm.generate())
self.shadow.set_texture(shadow_texture)
self.shadow.set_attrib(
core.ColorBlendAttrib.make(
core.ColorBlendAttrib.M_add, core.ColorBlendAttrib.O_zero,
core.ColorBlendAttrib.O_one_minus_incoming_alpha))
self.shadow.set_p(-90)
self.shadow.set_depth_write(False)
self.shadow.set_x(0.2)
self.shadow.set_billboard_point_eye()
self.shadow.set_two_sided(True)
self.shadow.set_bin('transparent', 0)
self.shadow.set_alpha_scale(0)
self.shadow_fade = None
self.ding_sfx = loader.load_sfx('hobot/sfx/ding.wav')
self.ding_sfx.set_volume(0.5)
self.move_sfx = loader.load_sfx('hobot/sfx/move.wav')
self.move_sfx.set_loop(True)
self.action_callback = None
def __init__(self):
# Preliminary capabilities check.
if not ape.base().win.getGsg().getSupportsBasicShaders():
self.t = addTitle(
"Shadow Demo: Video driver reports that shaders are not supported."
)
return
if not ape.base().win.getGsg().getSupportsDepthTexture():
self.t = addTitle(
"Shadow Demo: Video driver reports that depth textures are not supported."
)
return
# creating the offscreen buffer.
winprops = p3dc.WindowProperties(size=(512, 512))
props = p3dc.FrameBufferProperties()
props.setRgbColor(1)
props.setAlphaBits(1)
props.setDepthBits(1)
LBuffer = ape.base().graphicsEngine.makeOutput(
ape.base().pipe, "offscreen buffer", -2, props, winprops,
p3dc.GraphicsPipe.BFRefuseWindow,
ape.base().win.getGsg(),
ape.base().win)
self.buffer = LBuffer
if not LBuffer:
self.t = addTitle(
"Shadow Demo: Video driver cannot create an offscreen buffer.")
return
Ldepthmap = p3dc.Texture()
LBuffer.addRenderTexture(Ldepthmap, p3dc.GraphicsOutput.RTMBindOrCopy,
p3dc.GraphicsOutput.RTPDepthStencil)
if ape.base().win.getGsg().getSupportsShadowFilter():
Ldepthmap.setMinfilter(p3dc.Texture.FTShadow)
Ldepthmap.setMagfilter(p3dc.Texture.FTShadow)
# Adding a color texture is totally unnecessary, but it helps with
# debugging.
Lcolormap = p3dc.Texture()
LBuffer.addRenderTexture(Lcolormap, p3dc.GraphicsOutput.RTMBindOrCopy,
p3dc.GraphicsOutput.RTPColor)
self.inst_p = addInstructions(0.06,
'P : stop/start the Panda Rotation')
self.inst_w = addInstructions(0.12, 'W : stop/start the Walk Cycle')
self.inst_t = addInstructions(0.18, 'T : stop/start the Teapot')
self.inst_l = addInstructions(0.24,
'L : move light source far or close')
self.inst_v = addInstructions(0.30,
'V : View the Depth-Texture results')
self.inst_u = addInstructions(0.36,
'U : toggle updating the shadow map')
self.inst_x = addInstructions(
0.42, 'Left/Right Arrow : switch camera angles')
self.inst_a = addInstructions(0.48,
'Something about A/Z and push bias')
ape.base().setBackgroundColor(0, 0, 0.2, 1)
ape.base().camLens.setNearFar(1.0, 10000)
ape.base().camLens.setFov(75)
ape.base().disableMouse()
# Load the scene.
floorTex = ape.loader().loadTexture('maps/envir-ground.jpg')
cm = p3dc.CardMaker('')
cm.setFrame(-2, 2, -2, 2)
floor = ape.render().attachNewNode(p3dc.PandaNode("floor"))
for y in range(12):
for x in range(12):
nn = floor.attachNewNode(cm.generate())
nn.setP(-90)
nn.setPos((x - 6) * 4, (y - 6) * 4, 0)
floor.setTexture(floorTex)
floor.flattenStrong()
self.pandaAxis = ape.render().attachNewNode('panda axis')
self.pandaModel = Actor('panda-model', {'walk': 'panda-walk4'})
self.pandaModel.reparentTo(self.pandaAxis)
self.pandaModel.setPos(9, 0, 0)
self.pandaModel.setShaderInput("scale", (0.01, 0.01, 0.01, 1.0))
self.pandaWalk = self.pandaModel.actorInterval('walk', playRate=1.8)
self.pandaWalk.loop()
self.pandaMovement = self.pandaAxis.hprInterval(
20.0, p3dc.LPoint3(-360, 0, 0), startHpr=p3dc.LPoint3(0, 0, 0))
self.pandaMovement.loop()
self.teapot = ape.loader().loadModel('teapot')
self.teapot.reparentTo(ape.render())
self.teapot.setPos(0, -20, 10)
self.teapot.setShaderInput("texDisable", (1, 1, 1, 1))
self.teapotMovement = self.teapot.hprInterval(
50, p3dc.LPoint3(0, 360, 360))
self.teapotMovement.loop()
self.accept('escape', sys.exit)
self.accept("arrow_left", self.incrementCameraPosition, [-1])
self.accept("arrow_right", self.incrementCameraPosition, [1])
self.accept("p", self.toggleInterval, [self.pandaMovement])
self.accept("t", self.toggleInterval, [self.teapotMovement])
self.accept("w", self.toggleInterval, [self.pandaWalk])
self.accept("v", ape.base().bufferViewer.toggleEnable)
self.accept("u", self.toggleUpdateShadowMap)
self.accept("l", self.incrementLightPosition, [1])
self.accept("o", ape.base().oobe)
self.accept('a', self.adjustPushBias, [1.1])
self.accept('z', self.adjustPushBias, [0.9])
self.LCam = ape.base().makeCamera(LBuffer)
self.LCam.node().setScene(ape.render())
self.LCam.node().getLens().setFov(40)
self.LCam.node().getLens().setNearFar(10, 100)
# default values
self.pushBias = 0.04
self.ambient = 0.2
self.cameraSelection = 0
self.lightSelection = 0
# setting up shader
ape.render().setShaderInput('light', self.LCam)
ape.render().setShaderInput('Ldepthmap', Ldepthmap)
ape.render().setShaderInput('ambient', (self.ambient, 0, 0, 1.0))
ape.render().setShaderInput('texDisable', (0, 0, 0, 0))
ape.render().setShaderInput('scale', (1, 1, 1, 1))
# Put a shader on the Light camera.
lci = p3dc.NodePath(p3dc.PandaNode("Light Camera Initializer"))
lci.setShader(ape.loader().loadShader('shadows_caster.sha'))
self.LCam.node().setInitialState(lci.getState())
# Put a shader on the Main camera.
# Some video cards have special hardware for shadow maps.
# If the card has that, use it. If not, use a different
# shader that does not require hardware support.
mci = p3dc.NodePath(p3dc.PandaNode("Main Camera Initializer"))
if ape.base().win.getGsg().getSupportsShadowFilter():
mci.setShader(ape.loader().loadShader('shadows_shadow.sha'))
else:
mci.setShader(
ape.loader().loadShader('shadows_shadow-nosupport.sha'))
ape.base().cam.node().setInitialState(mci.getState())
self.incrementCameraPosition(0)
self.incrementLightPosition(0)
self.adjustPushBias(1.0)
def __init__(self):
super().__init__()
cef_mod_dir = cefpython.GetModuleDirectory()
app_settings = {
"windowless_rendering_enabled": True,
"locales_dir_path": os.path.join(cef_mod_dir, 'locales'),
"resources_dir_path": cefpython.GetModuleDirectory(),
"browser_subprocess_path": os.path.join(cef_mod_dir, 'subprocess'),
}
command_line_settings = {
# Tweaking OSR performance by setting the same Chromium flags as the
# cefpython SDL2 example (also see cefpython issue #240)
"disable-gpu-compositing": "",
"enable-begin-frame-scheduling": "",
}
browser_settings = {
"windowless_frame_rate": 60,
}
cefpython.Initialize(app_settings, command_line_settings)
self._cef_texture = p3d.Texture()
self._cef_texture.set_compression(p3d.Texture.CMOff)
self._cef_texture.set_component_type(p3d.Texture.TUnsignedByte)
self._cef_texture.set_format(p3d.Texture.FRgba4)
card_maker = p3d.CardMaker("browser2d")
card_maker.set_frame(-self._UI_SCALE, self._UI_SCALE, -self._UI_SCALE,
self._UI_SCALE)
node = card_maker.generate()
self._cef_node = base.render2d.attachNewNode(node)
self._cef_node.set_texture(self._cef_texture)
self._cef_node.set_transparency(p3d.TransparencyAttrib.MAlpha)
winhnd = base.win.getWindowHandle().getIntHandle()
wininfo = cefpython.WindowInfo()
wininfo.SetAsOffscreen(winhnd)
wininfo.SetTransparentPainting(True)
self.browser = cefpython.CreateBrowserSync(wininfo,
browser_settings,
navigateUrl='')
self.browser.SetClientHandler(CefClientHandler(self._cef_texture))
self._is_loaded = False
self._js_onload_queue = []
self._js_func_onload_queue = []
self.browser.SetClientCallback("OnLoadEnd", self._load_end)
self.jsbindings = cefpython.JavascriptBindings()
self.browser.SendFocusEvent(True)
self._set_browser_size()
self.accept('window-event', self._set_browser_size)
base.buttonThrowers[0].node().setKeystrokeEvent('keystroke')
self.accept('keystroke', self._handle_text)
self.accept('arrow_left', self._handle_key, [cefpython.VK_LEFT])
self.accept('arrow_right', self._handle_key, [cefpython.VK_RIGHT])
self.accept('arrow_up', self._handle_key, [cefpython.VK_UP])
self.accept('arrow_down', self._handle_key, [cefpython.VK_DOWN])
self.accept('home', self._handle_key, [cefpython.VK_HOME])
self.accept('end', self._handle_key, [cefpython.VK_END])
self.accept('mouse1', self._handle_mouse, [False])
self.accept('mouse1-up', self._handle_mouse, [True])
self._msg_loop_task = base.taskMgr.add(self._cef_message_loop,
'CEFMessageLoop')
sys.excepthook = cefpython.ExceptHook
atexit.register(self._shutdown_cef)
self.use_mouse = True
def build(self): #, old_geometry):
# configure beamer
self.set_arena_mode('greenHDMI')
#new_geometry = []
self.off_center = self.parent.mainNode.attachNewNode("off_center")
self.off_center.setPos(205, 0, 0)
# define cylinder 1
self.cylinder1_height = 10
self.cylinder1_radius = 200
self.cylinder1 = tools.create_cylinder_parts(self.parent.mainNode, 1,
360)
self.cylinder1.reparentTo(self.off_center)
self.cylinder1.setPos(0, 0, 0)
self.cylinder1.setScale(self.cylinder1_radius, self.cylinder1_radius,
self.cylinder1_height)
self.cylinder1.setHpr(0, 0, 0)
self.cylinder1.setAttrib(
pcore.CullFaceAttrib.make(
pcore.CullFaceAttrib.MCullCounterClockwise))
# define cylinder 2
self.cylinder2_height = 10
self.cylinder2_radius = 210
self.cylinder2 = tools.create_cylinder_parts(self.parent.mainNode, 1,
360)
self.cylinder2.reparentTo(self.off_center)
self.cylinder2.setPos(0, 0, 0)
self.cylinder2.setScale(self.cylinder2_radius, self.cylinder2_radius,
self.cylinder2_height)
self.cylinder2.setHpr(0, 0, 0)
# define top
cm = pcore.CardMaker('top')
self.top = self.off_center.attachNewNode(cm.generate())
self.top.setPos(-220, 220, 5)
self.top.setHpr(0, 90, 0)
self.top.setScale(440, 1, 440)
# define bottom
self.bottom = self.off_center.attachNewNode(cm.generate())
self.bottom.setPos(-220, -220, -5)
self.bottom.setHpr(0, -90, 0)
self.bottom.setScale(440, 1, 440)
# load wall textures
N_vertical = 1.
N_horizontal = self.cylinder1_radius * 2 * math.pi / self.cylinder1_height
self.cylinder1.setTexScale(pcore.TextureStage.getDefault(),
N_horizontal, N_vertical)
self.cylinder2.setTexScale(pcore.TextureStage.getDefault(),
N_horizontal, N_vertical)
baum_file = tools.make_panda3d_path(self.shared.arena_path,
"stimuli/default/baum.jpg")
baum_tex = loader.loadTexture(baum_file)
self.cylinder1.setTexture(baum_tex)
berg_file = tools.make_panda3d_path(self.shared.arena_path,
"stimuli/default/baum.jpg")
berg_tex = loader.loadTexture(berg_file)
self.cylinder2.setTexture(berg_tex)
# load top texture
sky_file = tools.make_panda3d_path(self.shared.arena_path,
"stimuli/default/sky.jpg")
sky_tex = loader.loadTexture(sky_file)
self.top.setTexture(sky_tex)
self.top.setTexScale(pcore.TextureStage.getDefault(), 220, 220)
# generate chessboard texture / bottom texture
chess_image = pcore.PNMImage(2, 2)
chess_image.setXelA(0, 0, 0, 0, 0, 1)
chess_image.setXelA(1, 1, 0, 0, 0, 1)
chess_image.setXelA(0, 1, 1, 1, 1, 1)
chess_image.setXelA(1, 0, 1, 1, 1, 1)
chess_tex = pcore.Texture()
chess_tex.load(chess_image)
chess_tex.setMagfilter(pcore.Texture.FTNearest)
# set bottom texture
self.bottom.setTexScale(pcore.TextureStage.getDefault(), 220, 220)
self.bottom.setTexture(chess_tex)
def __setup(self):
# self.start_nonogram(0)
if None in self.__solution:
self.__generate_solution_cards()
self.__root = None
self.__base.get_children().detach()
self.__root = self.__base.attach_new_node('CellRoot')
self.__root.set_pos(
-(common.NG_RADIUS * 2 + common.NG_PAD) * self.__yx[1] / 2,
0,
(common.NG_RADIUS * 2 + common.NG_PAD) * self.__yx[0] / 2
)
c = core.CardMaker('nbg')
c.set_frame(core.Vec4(-100, 100, -100, 100))
self.__card = self.__base.attach_new_node(c.generate())
self.__card.set_color(common.NG_BG_COLOR)
self.__card.set_transparency(core.TransparencyAttrib.M_alpha)
o = core.Vec3(0)
o.xz = common.NG_OFFSET.xz
self.__card.set_pos(o)
self.__card.set_bin('fixed', 0)
self.__card.set_depth_test(False)
self.__card.set_depth_write(False)
self.__h_txt_grid = [
[] for _ in range(self.__yx[0])
] # type: List[List[core.NodePath]]
self.__h_txt_values = [
[
'' for _ in range(5)
] for _ in range(self.__yx[0])
] # type: List[List[str]]
for h in self.__h_txt_values:
h[0] = '0'
self.__v_txt_grid = [
[] for _ in range(self.__yx[1])
] # type: List[List[core.NodePath]]
self.__v_txt_values = [
[
'' for _ in range(5)
] for _ in range(self.__yx[0])
] # type: List[List[str]]
for v in self.__v_txt_values:
v[0] = '0'
tex = core.Texture('cell_tex')
tex.setup_2d_texture(
*tuple(reversed(common.NG_TEX)),
core.Texture.T_float,
core.Texture.F_rgba
)
tex.set_ram_image_as(util.bw_tex(*common.NG_TEX), 'RGBA')
tex.set_wrap_u(core.Texture.WM_clamp)
tex.set_wrap_v(core.Texture.WM_clamp)
tex.reload()
if self.__grid_nodes:
self.__grid_nodes = []
self.__root.get_children().detach()
cell_np = self.__root.attach_new_node(
self.__sg.sphere(
core.Vec3(0),
core.Vec3.up(),
common.NG_RADIUS,
common.NG_POLY,
name='cell 0/0',
nac=False
)
)
ts = core.TextureStage('ts')
cell_np.set_texture(ts, tex, 1)
cell_np.set_tex_offset(ts, 0.25, 0)
cell_np.set_bin('fixed', 0)
cell_np.set_depth_test(False)
cell_np.set_depth_write(False)
for y in range(self.__yx[0]):
self.__grid_nodes.append([])
for x in range(self.__yx[1]):
if x or y:
node_path = self.__root.attach_new_node(f'cell {x}/{y}')
cell_np.copy_to(node_path)
node_path.set_pos(
x * (common.NG_RADIUS + common.NG_PAD),
0,
-y * (common.NG_RADIUS + common.NG_PAD)
)
self.__grid_nodes[-1].append(node_path)
else:
self.__grid_nodes[-1].append(cell_np)
def start(self):
self.setBackgroundColor((0, 0, 0, 0))
# Preliminary capabilities check.
if not self.win.getGsg().getSupportsBasicShaders():
NC(
1,
"Firefly Demo: Video driver reports that Cg shaders are not supported."
)
return
if not self.win.getGsg().getSupportsDepthTexture():
NC(
1,
"Firefly Demo: Video driver reports that depth textures are not supported."
)
return
# This algorithm uses two offscreen buffers, one of which has
# an auxiliary bitplane, and the offscreen buffers share a single
# depth buffer. This is a heck of a complicated buffer setup.
self.modelbuffer = self.makeFBO("model buffer", 1)
self.lightbuffer = self.makeFBO("light buffer", 0)
# Creation of a high-powered buffer can fail, if the graphics card
# doesn't support the necessary OpenGL extensions.
if self.modelbuffer is None or self.lightbuffer is None:
NC(
1,
"Firefly Demo: Video driver does not support multiple render targets"
)
return
# Create four render textures: depth, normal, albedo, and final.
# attach them to the various bitplanes of the offscreen buffers.
self.texDepth = p3dc.Texture()
self.texDepth.setFormat(p3dc.Texture.FDepthStencil)
self.texAlbedo = p3dc.Texture()
self.texNormal = p3dc.Texture()
self.texFinal = p3dc.Texture()
self.modelbuffer.addRenderTexture(self.texDepth,
p3dc.GraphicsOutput.RTMBindOrCopy,
p3dc.GraphicsOutput.RTPDepthStencil)
self.modelbuffer.addRenderTexture(self.texAlbedo,
p3dc.GraphicsOutput.RTMBindOrCopy,
p3dc.GraphicsOutput.RTPColor)
self.modelbuffer.addRenderTexture(self.texNormal,
p3dc.GraphicsOutput.RTMBindOrCopy,
p3dc.GraphicsOutput.RTPAuxRgba0)
self.lightbuffer.addRenderTexture(self.texFinal,
p3dc.GraphicsOutput.RTMBindOrCopy,
p3dc.GraphicsOutput.RTPColor)
# Set the near and far clipping planes.
self.cam.node().getLens().setNear(50.0)
self.cam.node().getLens().setFar(500.0)
lens = self.cam.node().getLens()
# This algorithm uses three cameras: one to render the models into the
# model buffer, one to render the lights into the light buffer, and
# one to render "plain" stuff (non-deferred shaded) stuff into the
# light buffer. Each camera has a bitmask to identify it.
self.modelMask = 1
self.lightMask = 2
self.plainMask = 4
self.modelcam = self.makeCamera(self.modelbuffer,
lens=lens,
scene=self.render,
mask=self.modelMask)
self.lightcam = self.makeCamera(self.lightbuffer,
lens=lens,
scene=self.render,
mask=self.lightMask)
self.plaincam = self.makeCamera(self.lightbuffer,
lens=lens,
scene=self.render,
mask=self.plainMask)
# Panda's main camera is not used.
self.cam.node().setActive(0)
# Take explicit control over the order in which the three
# buffers are rendered.
self.modelbuffer.setSort(1)
self.lightbuffer.setSort(2)
self.win.setSort(3)
# Within the light buffer, control the order of the two cams.
self.lightcam.node().getDisplayRegion(0).setSort(1)
self.plaincam.node().getDisplayRegion(0).setSort(2)
# By default, panda usually clears the screen before every
# camera and before every window. Tell it not to do that.
# Then, tell it specifically when to clear and what to clear.
self.modelcam.node().getDisplayRegion(0).disableClears()
self.lightcam.node().getDisplayRegion(0).disableClears()
self.plaincam.node().getDisplayRegion(0).disableClears()
self.cam.node().getDisplayRegion(0).disableClears()
self.cam2d.node().getDisplayRegion(0).disableClears()
self.modelbuffer.disableClears()
self.win.disableClears()
self.modelbuffer.setClearColorActive(1)
self.modelbuffer.setClearDepthActive(1)
self.lightbuffer.setClearColorActive(1)
self.lightbuffer.setClearColor((0, 0, 0, 1))
# Miscellaneous stuff.
self.disableMouse()
self.camera.setPos(-9.112, -211.077, 46.951)
self.camera.setHpr(0, -7.5, 2.4)
random.seed()
# Calculate the projection parameters for the final shader.
# The math here is too complex to explain in an inline comment,
# I've put in a full explanation into the HTML intro.
proj = self.cam.node().getLens().getProjectionMat()
proj_x = 0.5 * proj.getCell(3, 2) / proj.getCell(0, 0)
proj_y = 0.5 * proj.getCell(3, 2)
proj_z = 0.5 * proj.getCell(3, 2) / proj.getCell(2, 1)
proj_w = -0.5 - 0.5 * proj.getCell(1, 2)
# Configure the render state of the model camera.
tempnode = p3dc.NodePath(p3dc.PandaNode("temp node"))
tempnode.setAttrib(
p3dc.AlphaTestAttrib.make(p3dc.RenderAttrib.MGreaterEqual, 0.5))
tempnode.setShader(self.loader.loadShader("fireflies_model.sha"))
tempnode.setAttrib(
p3dc.DepthTestAttrib.make(p3dc.RenderAttrib.MLessEqual))
self.modelcam.node().setInitialState(tempnode.getState())
# Configure the render state of the light camera.
tempnode = p3dc.NodePath(p3dc.PandaNode("temp node"))
tempnode.setShader(self.loader.loadShader("fireflies_light.sha"))
tempnode.setShaderInput("texnormal", self.texNormal)
tempnode.setShaderInput("texalbedo", self.texAlbedo)
tempnode.setShaderInput("texdepth", self.texDepth)
tempnode.setShaderInput("proj", (proj_x, proj_y, proj_z, proj_w))
tempnode.setAttrib(
p3dc.ColorBlendAttrib.make(p3dc.ColorBlendAttrib.MAdd,
p3dc.ColorBlendAttrib.OOne,
p3dc.ColorBlendAttrib.OOne))
tempnode.setAttrib(
p3dc.CullFaceAttrib.make(
p3dc.CullFaceAttrib.MCullCounterClockwise))
# The next line causes problems on Linux.
# tempnode.setAttrib(p3dc.DepthTestAttrib.make(p3dc.RenderAttrib.MGreaterEqual))
tempnode.setAttrib(
p3dc.DepthWriteAttrib.make(p3dc.DepthWriteAttrib.MOff))
self.lightcam.node().setInitialState(tempnode.getState())
# Configure the render state of the plain camera.
rs = p3dc.RenderState.makeEmpty()
self.plaincam.node().setInitialState(rs)
# Clear any render attribs on the root node. This is necessary
# because by default, panda assigns some attribs to the root
# node. These default attribs will override the
# carefully-configured render attribs that we just attached
# to the cameras. The simplest solution is to just clear
# them all out.
self.render.setState(p3dc.RenderState.makeEmpty())
# My artist created a model in which some of the polygons
# don't have textures. This confuses the shader I wrote.
# This little hack guarantees that everything has a texture.
white = self.loader.loadTexture("fireflies_models/white.jpg")
self.render.setTexture(white, 0)
# Create two subroots, to help speed cull traversal.
self.lightroot = p3dc.NodePath(p3dc.PandaNode("lightroot"))
self.lightroot.reparentTo(self.render)
self.modelroot = p3dc.NodePath(p3dc.PandaNode("modelroot"))
self.modelroot.reparentTo(self.render)
self.lightroot.hide(p3dc.BitMask32(self.modelMask))
self.modelroot.hide(p3dc.BitMask32(self.lightMask))
self.modelroot.hide(p3dc.BitMask32(self.plainMask))
# Load the model of a forest. Make it visible to the model camera.
# This is a big model, so we load it asynchronously while showing a
# load text. We do this by passing in a callback function.
self.loading = addTitle("Loading models...")
self.forest = p3dc.NodePath(p3dc.PandaNode("Forest Root"))
self.forest.reparentTo(self.render)
self.forest.hide(p3dc.BitMask32(self.lightMask | self.plainMask))
self.loader.loadModel([
"fireflies_models/background", "fireflies_models/foliage01",
"fireflies_models/foliage02", "fireflies_models/foliage03",
"fireflies_models/foliage04", "fireflies_models/foliage05",
"fireflies_models/foliage06", "fireflies_models/foliage07",
"fireflies_models/foliage08", "fireflies_models/foliage09"
],
callback=self.finishLoading)
# Cause the final results to be rendered into the main window on a card.
self.card = self.lightbuffer.getTextureCard()
self.card.setTexture(self.texFinal)
self.card.reparentTo(self.render2d)
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
self.bufferViewer.setPosition("llcorner")
self.bufferViewer.setCardSize(0, 0.40)
self.bufferViewer.setLayout("vline")
self.toggleCards()
self.toggleCards()
# Firefly parameters
self.fireflies = []
self.sequences = []
self.scaleseqs = []
self.glowspheres = []
self.fireflysize = 1.0
self.spheremodel = self.loader.loadModel("misc/sphere")
# Create the firefly model, a fuzzy dot
dotSize = 1.0
cm = p3dc.CardMaker("firefly")
cm.setFrame(-dotSize, dotSize, -dotSize, dotSize)
self.firefly = p3dc.NodePath(cm.generate())
self.firefly.setTexture(
self.loader.loadTexture("fireflies_models/firefly.png"))
self.firefly.setAttrib(
p3dc.ColorBlendAttrib.make(p3dc.ColorBlendAttrib.M_add,
p3dc.ColorBlendAttrib.O_incoming_alpha,
p3dc.ColorBlendAttrib.O_one))
# these allow you to change parameters in realtime
self.accept("arrow_up", self.incFireflyCount, [1.1111111])
self.accept("arrow_down", self.decFireflyCount, [0.9000000])
self.accept("arrow_right", self.setFireflySize, [1.1111111])
self.accept("arrow_left", self.setFireflySize, [0.9000000])
self.accept("v", self.toggleCards)
self.accept("V", self.toggleCards)
def __init__(self, base, world, scale=1.0):
self.is_paused = False
self.base = base
self.world = world
self.scale = scale
self.addBlock_func = add_block_func
self.pauseScr = base.aspect2d.attachNewNode("pause")
self.loadScr = base.aspect2d.attachNewNode(
"load") # It also helps for flipping between screens
self.saveScr = base.aspect2d.attachNewNode("save")
cm = core.CardMaker('card')
self.dim = base.render2d.attachNewNode(cm.generate())
self.dim.setPos(-1, 0, -1)
self.dim.setScale(2)
self.dim.setTransparency(1)
self.dim.setColor(0, 0, 0, 0.5)
self.buttonModel = base.loader.loadModel('gfx/button')
input_texture = base.loader.loadTexture('gfx/tex/button_press.png')
# Pause Screen
self.unpauseButton = DirectButton(
geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
relief=None,
parent=self.pauseScr,
scale=0.5,
pos=(0, 0, 0.3),
text="Resume Game",
text_fg=(1, 1, 1, 1),
text_scale=0.1,
text_pos=(0, -0.04),
command=self.pause)
self.saveButton = DirectButton(
geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
relief=None,
parent=self.pauseScr,
scale=0.5,
pos=(0, 0, 0.15),
text="Save Game",
text_fg=(1, 1, 1, 1),
text_scale=0.1,
text_pos=(0, -0.04),
command=self.show_save)
self.loadButton = DirectButton(
geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
relief=None,
parent=self.pauseScr,
scale=0.5,
pos=(0, 0, -0.15),
text="Load Game",
text_fg=(1, 1, 1, 1),
text_scale=0.1,
text_pos=(0, -0.04),
command=self.show_load)
self.exitButton = DirectButton(
geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
relief=None,
parent=self.pauseScr,
scale=0.5,
pos=(0, 0, -0.3),
text="Quit Game",
text_fg=(1, 1, 1, 1),
text_scale=0.1,
text_pos=(0, -0.04),
command=exit)
# Save Screen
self.saveText = DirectLabel(text="Type in a name for your world",
text_fg=(1, 1, 1, 1),
frameColor=(0, 0, 0, 0),
parent=self.saveScr,
scale=0.075,
pos=(0, 0, 0.35))
self.saveText2 = DirectLabel(text="",
text_fg=(1, 1, 1, 1),
frameColor=(0, 0, 0, 0),
parent=self.saveScr,
scale=0.06,
pos=(0, 0, -0.45))
self.saveName = DirectEntry(text="",
scale=.15,
command=self.save,
initialText="My World",
numLines=1,
focus=1,
frameTexture=input_texture,
parent=self.saveScr,
text_fg=(1, 1, 1, 1),
pos=(-0.6, 0, 0.1),
text_scale=0.75)
self.saveGameBtn = DirectButton(
geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
relief=None,
parent=self.saveScr,
scale=0.5,
pos=(0, 0, -0.1),
text="Save",
text_fg=(1, 1, 1, 1),
text_scale=0.1,
text_pos=(0, -0.04),
command=self.save)
self.backButton = DirectButton(
geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
relief=None,
parent=self.saveScr,
scale=0.5,
pos=(0, 0, -0.25),
text="Back",
text_fg=(1, 1, 1, 1),
text_scale=0.1,
text_pos=(0, -0.04),
command=self.show_pause)
# Load Screen
num_items_visible = 3
item_height = 0.15
self.loadList = DirectScrolledList(
decButton_pos=(0.35, 0, 0.5),
decButton_text="^",
decButton_text_scale=0.04,
decButton_text_pos=(0, -0.025),
decButton_text_fg=(1, 1, 1, 1),
decButton_borderWidth=(0.005, 0.005),
decButton_scale=(1.5, 1, 2),
decButton_geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
decButton_geom_scale=0.1,
decButton_relief=None,
incButton_pos=(0.35, 0, 0),
incButton_text="^",
incButton_text_scale=0.04,
incButton_text_pos=(0, -0.025),
incButton_text_fg=(1, 1, 1, 1),
incButton_borderWidth=(0.005, 0.005),
incButton_hpr=(0, 180, 0),
incButton_scale=(1.5, 1, 2),
incButton_geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
incButton_geom_scale=0.1,
incButton_relief=None,
frameSize=(-0.4, 1.1, -0.1, 0.59),
frameTexture=input_texture,
frameColor=(1, 1, 1, 0.75),
pos=(-0.45, 0, -0.25),
scale=1.25,
numItemsVisible=num_items_visible,
forceHeight=item_height,
itemFrame_frameSize=(-0.2, 0.2, -0.37, 0.11),
itemFrame_pos=(0.35, 0, 0.4),
itemFrame_frameColor=(0, 0, 0, 0),
parent=self.loadScr)
self.backButton = DirectButton(
geom=(self.buttonModel.find('**/button_up'),
self.buttonModel.find('**/button_press'),
self.buttonModel.find('**/button_over'),
self.buttonModel.find('**/button_disabled')),
relief=None,
parent=self.loadScr,
scale=0.5,
pos=(0, 0, -0.5),
text="Back",
text_fg=(1, 1, 1, 1),
text_scale=0.1,
text_pos=(0, -0.04),
command=self.show_pause)
self.loadText = DirectLabel(text="Select World",
text_fg=(1, 1, 1, 1),
frameColor=(0, 0, 0, 0),
parent=self.loadScr,
scale=0.075,
pos=(0, 0, 0.55))
self.loadText2 = DirectLabel(text="",
text_fg=(1, 1, 1, 1),
frameColor=(0, 0, 0, 0),
parent=self.loadScr,
scale=0.075,
pos=(0, 0, -0.7))
self.hide()
def __init__(self, parent):
actor = Actor(self.model_path)
actor.set_two_sided(True)
actor.reparent_to(parent)
#print(actor.get_anim_names())
#actor.list_joints()
self.actor = actor
self.actor.hide()
if self.walkable_path:
self.walk_map = PNMImage()
self.load_walk_map(self.walkable_path)
else:
self.walk_map = None
if self.music_path:
self.music = base.loader.load_music(self.music_path)
self.music.set_loop(True)
self.music.set_volume(0.5)
self.music.play()
else:
self.music = None
self.sfx = {}
for s in self.sound_names:
self.sfx[s] = base.loader.load_sfx(
Filename(self.sound_path, s + ".wav"))
# Make subparts for hobot.
actor.make_subpart('hobot', [
'hobot root', 'chain_a', 'chain_b', 'hand', 'wheel', 'neck',
'head', 'tuit', 'eyes'
])
# Make a copy for inspection of the animations, specifically to be able
# to obtain the starting position of hobot in each animation.
self.shadow_actor = Actor(self.model_path)
self.shadow_hobot_root = self.shadow_actor.expose_joint(
None, 'modelRoot', 'hobot root')
# Make sure hobot is in a defined state in the actor
actor.pose('entrance', 0)
self.hobot_root = actor.expose_joint(None, 'modelRoot', 'hobot root')
self.hobot_hand = actor.expose_joint(None, 'modelRoot', 'hand')
self.hobot = Hobot(self.hobot_root)
shadow_texture = loader.load_texture('hobot/drop_shadow.png')
shadow_texture.set_wrap_u(core.SamplerState.WM_clamp)
shadow_texture.set_wrap_v(core.SamplerState.WM_clamp)
cm = core.CardMaker('card')
cm.set_frame(-0.35, 0.35, -0.45, -0.1)
self.shadow = self.hobot_root.attach_new_node(cm.generate())
self.shadow.set_texture(shadow_texture)
self.shadow.set_attrib(
core.ColorBlendAttrib.make(
core.ColorBlendAttrib.M_add, core.ColorBlendAttrib.O_zero,
core.ColorBlendAttrib.O_one_minus_incoming_alpha))
self.shadow.set_p(-90)
self.shadow.set_depth_write(False)
self.shadow.set_x(0.2)
self.shadow.set_billboard_point_eye()
self.shadow.set_two_sided(True)
self.shadow.set_bin('transparent', 0)
self.shadow.set_alpha_scale(0)
self.shadow_fade = None
self.carrying_joint = None
self.carrying_joint_name = None
def __init__(self):
super().__init__()
gdb = gamedb.get_instance()
self.player = base.blackboard['player']
self.monster_selection = 0
self.monster_actors = []
self.monsters_root = self.root_node.attach_new_node('monsters')
# Setup lighting
self.lights_root = self.root_node.attach_new_node('light root')
self.lighting = CommonLighting(self.lights_root,
calc_shadow_bounds=False)
self.lights_root.set_h(45)
# Pre-load all monster models
forms = gdb['forms'].values()
self.load_monster_models(forms)
# Load and display the player monster models
self.load_monster_models()
# Setup plane to catch shadows
if p3d.ConfigVariableBool('enable-shadows').get_value():
shadow_catcher = p3d.CardMaker('shadow_catcher').generate()
shadow_catcher = self.root_node.attach_new_node(shadow_catcher)
shadow_catcher.set_p(-90)
shadow_catcher.set_scale(30)
shadow_catcher.set_pos(-15, -15, 0)
shadow_catcher.flatten_strong()
shadow_catcher.set_transparency(p3d.TransparencyAttrib.M_alpha)
shadow_catcher.set_shader(
p3d.Shader.make(p3d.Shader.SL_GLSL, SHADOW_CATCH_V,
SHADOW_CATCH_F))
# Setup backgrounds
self.background_textures = {
'base': (
base.loader.load_texture('backgrounds/ranchbg.png'),
base.loader.load_texture('backgrounds/ranchfg.png'),
),
'foundry': (
base.loader.load_texture('backgrounds/marketbg.png'),
base.loader.load_texture('backgrounds/marketfg.png'),
),
}
for tex in (i for texs in self.background_textures.values()
for i in texs):
if tex.get_num_components() == 4:
tex.set_format(p3d.Texture.F_srgb_alpha)
else:
tex.set_format(p3d.Texture.F_srgb)
self.background_image = bgnode.generate(self.root_node)
self.foreground_image = bgnode.generate(self.root_node,
foreground=True)
self.foreground_image.set_transparency(p3d.TransparencyAttrib.M_alpha)
# Setup Background Music
self.play_bg_music('woodland_fantasy')
# Setup Camera
base.camera.set_pos(0, -5, 6)
base.camera.look_at(0, 0, 1)
# UI
self.message = ""
self.message_modal = False
self.load_ui('workshop')
# Set initial input state
if self.player.monsters:
self.input_state = 'MAIN'
else:
self.input_state = 'FOUNDRY'
