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'