def setLightColor(color): light.setColor( Vec4(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0, color[3] / 255.0)) # Update color chip button pButton['bg'] = getTkColorString(color)
def __init__(self): ShowBase.__init__(self) engine.tq_graphics_basics.init_engine(render, aspect2d, loader) base.setFrameRateMeter(True) engine.tq_graphics_basics.tq_render.setAntialias(AntialiasAttrib.MAuto) shade_of_gray = 0.2 base.setBackgroundColor(shade_of_gray, shade_of_gray, shade_of_gray) cg = cameras.Orbiter.OrbiterOrtho(base.cam, r_init=1.) cs = CoordinateSystemP3dPlain() cs.attach_to_render() # # ----------- # lens = OrthographicLens() # far = 1. # near = -1. # lens.setNearFar(near, far) # x_filmsize = 2 * 1. # y_filmsize = x_filmsize * 9./16. * 2 # # x_filmsize = 2 * 1. # # y_filmsize = 2 * 1. # # x_filmsize = 1. # # y_filmsize = 1. # lens.setFilmSize(x_filmsize, y_filmsize) # base.cam.node().setLens(lens) # print("proj mat (1): ") # print(base.cam.node().getLens().getProjectionMat()) # print(base.cam.node().getLens().getFilmSize()) # # ----------- # ----------- lens = MatrixLens() # lens.setNearFar(-500., 500.) # x_filmsize = 2 * 1. # y_filmsize = x_filmsize * 9./16. # lens.setFilmSize(x_filmsize, y_filmsize) far = 100. near = -100. x_filmsize = 2 * 1.5 y_filmsize = x_filmsize * 9./16. right = x_filmsize/2. left = -right up = y_filmsize/2. bottom = -up proj_mat = math_utils.get_ortho_projection_matrix(right, left, up, bottom, near, far) lens.setUserMat(math_utils.to_forrowvecs(proj_mat)) # lens.setUserMat(np.flatten(proj_mat)) base.cam.node().setLens(lens) print("proj mat (2): ") print(base.cam.node().getLens().getProjectionMat()) print(base.cam.node().getLens().getFilmSize()) # ----------- # base.cam.setLens() # cs = CoordinateSystem(cg) # cs.attach_to_render() # base.accept("d", lambda: exec("import ipdb; ipdb.set_trace()")) # dep = DraggableEdgePlayer("/home/chris/Desktop/playbacktest2.wav", cg, taskMgr) # f2d3 = Frame2d(camera_gear=cg, attach_to_space="render", update_labels_orientation=True) # # f2d3.set_figsize(0.8, 0.5) # sffr = StreamFramesFromRecorder(f2d3) # plot_audio_file_profile(cg) a = Vector() a.setTipPoint(Vec3(0., 0., 1.)*0.2) a.setTailPoint(Vec3(0., 0., 0.)) a.reparentTo_p3d(render) a.setColor(Vec4(0., 1., 1., 1.), 1) # cg.set_view_to_xz_plane() # df = DraggableFrame(cg) # df.setPos(Vec3(0., 0., 0.6)) # df.attach_to_render() # df = DraggableFrame(cg) # df.setPos(Vec3(0., 0., 0.6)) # df.attach_to_render() # df = DraggableFrame(cg, height=0.2, width=0.7) # df.setPos(Vec3(-0.8, 0., 0.7)) # df.setColor(Vec4(0., 1., 0., 1.), 1) # df.attach_to_render() # quad = Quad(height=0.5, width=0.7, thickness=5.) # quad.setColor(Vec4(0., 1., 0., 1.), 1) # quad.reparentTo_p3d(render) # line = Line1dSolid(thickness=5.) # line.setColor(1.0, 1.0, 0., 1.) # line.setTailPoint(Vec3(0.25, 0., 0.)) # line.setTipPoint(Vec3(0.75, 0., 0.)) # line.reparentTo_p3d(render) # line.setColor(Vec4(0., 1., 1., 1.), 1) # line.setPos(Vec3(-0.8, 0., 0.7)) # df = DraggableResizableFrame(cg, height=0.2, width=0.7) # df.attach_to_render() # df.setPos(Vec3(0.1, 0., 0.)) # df.setColor(Vec4(0., 1., 1., 1.), 1) # self.vecp0 = Vector() # # self.vecp0.setTipPoint(Vec3(-1., 0., 1.)) # self.vecp0.setTipPoint(Vec3(0., 0., 0.)) # self.vecp0.setTailPoint(Vec3(0., 0., 0.)) # self.vecp0.reparentTo(engine.tq_graphics_basics.tq_render) # self.vecp0.setColor(Vec4(0., 0., 0., 1.), 1) # ------------- # slp = primitives.SegmentedLinePrimitive(color=get_color("yellow"), thickness=2) # slp.extendCoords([np.array([0., 0., 0.]), np.array([1., 1., 1.]), np.array([1., 0., 0.])]) # slp.attach_to_render() # slp.extendCoords([np.array([1., 1., 0.])]) # slp.attach_to_render() # ------------- gn = GroupNode() gn.attach_to_render() slp = primitives.SegmentedLinePrimitive(color=get_color("yellow"), thickness=2) slp.extendCoords([np.array([0., 0., 0.]), np.array([1., 1., 1.]), np.array([1., 0., 0.])]) slp.reparentTo(gn) slp.extendCoords([np.array([1., 1., 0.])]) slp.reparentTo(gn)
def render_hints(self): """ render various on-hover things: - cursors - time labels """ get_hover_points_success, ray_direction, ray_aufpunkt, edge_p1, edge_p2, c1, c2 = ( self.get_hover_points()) if get_hover_points_success is True: if math_utils.isPointBetweenTwoPoints(edge_p1, edge_p2, c1): self.shortest_distance_line.setTipPoint(math_utils.np_to_p3d_Vec3(c1)) self.shortest_distance_line.setTailPoint(math_utils.np_to_p3d_Vec3(c2)) self.shortest_distance_line.show() # -- set the time label # ---- set the position of the label to the position of the mouse cursor, # but a bit higher self.time_label.textNodePath.show() self.time_label.setPos(*(ray_aufpunkt + ray_direction * 1.)) a = self.get_a_param(c2) t = a * self.edge_graphics.get_duration_func() self.time_label.setText("t = {0:.2f}, a = {1:.2f}".format(t, a)) self.time_label.update() self.time_label.textNodePath.setScale(0.04) # -- color edges # on hover, change the color to be # darker than otherwise primary_color = self.edge_graphics.get_primary_color() darkening_factor = 0.5 new_rgb_v3 = np.array([ primary_color[0], primary_color[1], primary_color[2]]) * darkening_factor new_color = Vec4(new_rgb_v3[0], new_rgb_v3[1], new_rgb_v3[2], 1.) # when hovered-over self.edge_graphics.set_primary_color(new_color, change_logical_primary_color=False) else: self.shortest_distance_line.setColor(Vec4(1., 1., 1., 1.), 1) # when not hovered-over self.edge_graphics.set_primary_color(self.edge_graphics.get_primary_color()) self.shortest_distance_line.hide() self.time_label.textNodePath.hide() # -- color point # ---- find closest point, # within a certain radius d_min_point = None closestpoint = None playerline_limiting_positions = [self.edge_graphics.get_inset_v1(), self.edge_graphics.get_inset_v2()] for pos in playerline_limiting_positions: d = np.linalg.norm( math_utils.p3d_to_np(pos) - math_utils.p3d_to_np(ray_aufpunkt)) if d_min_point is not None: if d < d_min_point: d_min_point = d closestpoint = pos else: d_min_point = d closestpoint = pos
Zones.FunnyFarm: 2, Zones.DonaldsDreamland: 2, Zones.OutdoorZone: 2, Zones.BossbotHQ: 2, Zones.SellbotHQ: 43, Zones.CashbotHQ: 2, Zones.LawbotHQ: 2, Zones.GolfZone: 2, Zones.PartyHood: 2 } # Amount of building floors required to achieve a particular star above a toon's head TrophyStarLevels = (10, 20, 30, 50, 75, 100) # Colors of building stars TrophyStarColors = ( Vec4(0.9, 0.6, 0.2, 1), # Bronze Static Vec4(0.9, 0.6, 0.2, 1), # Bronze Spinning Vec4(0.8, 0.8, 0.8, 1), # Silver Static Vec4(0.8, 0.8, 0.8, 1), # Silver Spinning Vec4(1, 1, 0, 1), # Gold Static Vec4(1, 1, 0, 1) # Gold Spinning ) # Speeds of various characters NPCSpeed = { "mickey": 5.0, "vampireMickey": 1.15, "minnie": 3.2, "witchMinnie": 1.8, "donald": 3.68, "frankenDonald": 0.9,
def __init__(self): self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0} self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.opponents = dict() self.logStat = -1 self.id = 0 self.username = "" host = "localhost" port = 9252 self.connection = self.cManager.openTCPClientConnection(host, port, 10000) self.received = 1 self.playersText = [] if self.connection: self.cReader.addConnection(self.connection) taskMgr.add(self.updateRoutine, 'updateRoutine') taskMgr.add(self.login, 'login') taskMgr.doMethodLater(.1, self.heartbeat, 'heartbeat') # Replace with actual, dynamic list of players from the server self.players = dict() # Placeholder, replace with actual # of players later self.numberOfPlayers = 2 # Stores the OnScreenText for each player in the players list # Populated and depopulated using listPlayers and delistPlayers self.playersText = [] # Stores all the player objects currently logged in self.playerObjects = [] base.win.setClearColor(Vec4(0,0,0,1)) # Post the instructions #self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)") #self.inst1 = addInstructions(0.95, "[ESC]: Quit") #self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left") #self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right") #self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward") #self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left") #self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right") #self.inst8 = addInstructions(0.60, "[Q]: Display List Of Connected Players") # Set up the environment # # This environment model contains collision meshes. If you look # in the egg file, you will see the following: # # <Collide> { Polyset keep descend } # # This tag causes the following mesh to be converted to a collision # mesh -- a mesh which is optimized for collision, not rendering. # It also keeps the original mesh, so there are now two copies --- # one optimized for rendering, one for collisions. self.environ = loader.loadModel("models/world") self.environ.reparentTo(render) self.environ.setPos(0,0,0) # Create the main character, Ralph ralphStartPos = self.environ.find("**/start_point").getPos() self.ralph = Actor("models/ralph", {"run":"models/ralph-run", "walk":"models/ralph-walk"}) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.ralph.setPos(ralphStartPos) ralphStartPos.setY(ralphStartPos.getY()-10) self.ralph.setPos(ralphStartPos.getX(),ralphStartPos.getY(),ralphStartPos.getZ()) self.initx = ralphStartPos.getX() # Add our Ralph to list to Ralphs self.playerObjects.append(self.ralph) # Load and transform the panda actor. self.pandaActor = Actor("models/panda-model", {"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.003, 0.003, 0.003) self.pandaActor.reparentTo(render) # Loop its animation. #self.pandaActor.loop("walk") self.pandaActor.setPos(ralphStartPos.getX(),ralphStartPos.getY()-20,ralphStartPos.getZ()) # Create a floater object. We use the "floater" as a temporary # variable in a variety of calculations. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Accept the control keys for movement and rotation self.accept("escape", self.disconnect) self.accept("arrow_left", self.setKey, ["left",1]) self.accept("arrow_right", self.setKey, ["right",1]) self.accept("arrow_up", self.setKey, ["forward",1]) self.accept("a", self.setKey, ["cam-left",1]) self.accept("s", self.setKey, ["cam-right",1]) self.accept("arrow_left-up", self.setKey, ["left",0]) self.accept("arrow_right-up", self.setKey, ["right",0]) self.accept("arrow_up-up", self.setKey, ["forward",0]) self.accept("a-up", self.setKey, ["cam-left",0]) self.accept("s-up", self.setKey, ["cam-right",0]) self.accept("q", self.listPlayers) self.accept("q-up", self.delistPlayers) taskMgr.add(self.move,"moveTask") # Call whenever a ralph has logged in, use arg "out" for logouts self.displayLoginText() # Game state variables self.isMoving = False # Set up the camera base.disableMouse() base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2) # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above ralph's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0,0,1000) self.ralphGroundRay.setDirection(0,0,-1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) self.pandaActorGroundRay = CollisionRay() self.pandaActorGroundRay.setOrigin(0,0,1000) self.pandaActorGroundRay.setDirection(0,0,-1) self.pandaActorGroundCol = CollisionNode('pandaActorRay') self.pandaActorGroundCol.addSolid(self.pandaActorGroundRay) self.pandaActorGroundCol.setFromCollideMask(BitMask32.bit(0)) self.pandaActorGroundCol.setIntoCollideMask(BitMask32.allOff()) self.pandaActorGroundColNp = self.pandaActor.attachNewNode(self.pandaActorGroundCol) self.pandaActorGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.pandaActorGroundColNp, self.pandaActorGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0,0,1000) self.camGroundRay.setDirection(0,0,-1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(BitMask32.bit(0)) self.camGroundCol.setIntoCollideMask(BitMask32.allOff()) self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays #self.ralphGroundColNp.show() #self.camGroundColNp.show() self.miniMap = miniMap(self.ralph) self.miniMap.setNpc('tower_1', 'models/hexahedron.png', 0.05, 0.2, 0.3) self.miniMap.setNpc('tower_2', 'models/hexahedron.png', 0.05, -0.4, -0.5) # Uncomment this line to show a visual representation of the # collisions occuring #self.cTrav.showCollisions(render) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-5, -5, -5)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) self.setAI()
from .MapWritable import MapWritable from src.leveleditor import LEGlobals from .TransformProperties import OriginProperty, AnglesProperty, ScaleProperty, ShearProperty from . import MetaData from .ObjectProperty import ObjectProperty from src.leveleditor.math.Line import Line from src.leveleditor.geometry.Box import Box from src.leveleditor.geometry.GeomView import GeomView from src.leveleditor.viewport.ViewportType import VIEWPORT_2D_MASK, VIEWPORT_3D_MASK from enum import IntEnum BoundsBox3DState = RenderState.make( ColorAttrib.makeFlat(Vec4(1, 1, 0, 1)) ) BoundsBox2DState = RenderState.make( ColorAttrib.makeFlat(Vec4(1, 0, 0, 1)), CullBinAttrib.make("selected-foreground", 0) ) MapObjectInit = PStatCollector("Arch:CreateSolid:MapObjInit") # Base class for any object in the map (brush, entity, etc) class MapObject(MapWritable): ObjectName = "object" def __init__(self, id):
def __init__(self): __builtin__.main = self self.cManager = ConnectionManager() self.startConnection() self.taskMgr = taskMgr self.base = base self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0 } self.characters = dict() self.cpList = dict() base.win.setClearColor(Vec4(0, 0, 0, 1)) #self.environ = loader.loadModel("models/world") self.environ = loader.loadModel("models/land") """ self.swordLeft = loader.loadModel("models/Sword_Left") self.swordRight = loader.loadModel("models/Sword_Right") self.shieldLeft = loader.loadModel("models/Shield_Left") self.shieldRight = loader.loadModel("models/Shield_Right") self.money = loader.loadModel("models/Money") """ self.left_atk_tower = loader.loadModel("models/attack_tower") self.left_def_tower = loader.loadModel("models/defense_tower") self.right_atk_tower = loader.loadModel("models/attack_tower") self.right_def_tower = loader.loadModel("models/defense_tower") self.money_cp = loader.loadModel("models/money_point") self.left_atk_tower.setPos(141.016, 0.440607, 0) self.left_def_tower.setPos(210.984, 115.005, 0) self.right_atk_tower.setPos(-149.953, 0.674369, 0) self.right_def_tower.setPos(-210.771, 113.753, 0) self.money_cp.setPos(-0.903916, 11.3765, 0) self.left_atk_tower.setScale(2.0) self.right_atk_tower.setScale(2.0) self.left_def_tower.setScale(2.0) self.right_def_tower.setScale(2.0) self.money_cp.setScale(2.0) self.left_atk_tower.reparentTo(render) self.right_atk_tower.reparentTo(render) self.left_def_tower.reparentTo(render) self.right_def_tower.reparentTo(render) self.money_cp.reparentTo(render) self.environ.reparentTo(render) """ self.swordLeft.reparentTo(render) self.swordRight.reparentTo(render) self.shieldLeft.reparentTo(render) self.shieldRight.reparentTo(render) self.money.reparentTo(render) """ self.environ.setPos(0, 0, 0) self.environ.setH(90) """ self.swordLeft.setH(90) self.swordRight.setH(90) self.shieldLeft.setH(90) self.shieldRight.setH(90) self.money.setH(90) """ mySound = loader.loadSfx("sound/Retribution.mp3") mySound.setLoop(True) mySound.play() fp = FilterProperties() #fp.addReverb(0.6, 0.5, 0.1, 0.1, 0.1) base.sfxManagerList[0].configureFilters(fp) ## swordsmanStartPos = self.environ.find("**/start_point").getPos() ## self.player = Swordsman("Swordsman", 0) ## self.player._character.reparentTo(render) ## self.player._character.setScale(.1) ## self.player._character.setPos(swordsmanStartPos) ## swordsmanStartPos.setY(swordsmanStartPos.getY()-10) ## self.player._character.setPos(swordsmanStartPos.getX(),swordsmanStartPos.getY(),swordsmanStartPos.getZ()) ## self.initx = swordsmanStartPos.getX() self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) ## self.characters["Axeman"] = Axeman("Axeman", 1) ## self.characters["Axeman"]._character.reparentTo(render) ## self.characters["Axeman"]._character.setScale(.1) ## self.characters["Axeman"]._character.setPos(swordsmanStartPos) ## swordsmanStartPos.setY(swordsmanStartPos.getY()-10) ## self.characters["Axeman"]._character.setPos(swordsmanStartPos.getX(),swordsmanStartPos.getY() - 10,swordsmanStartPos.getZ()) ## self.characters["Axeman"]._character.loop("idle") self.accept("a", self.setKey, ["left", 1]) self.accept("s", self.setKey, ["backward", 1]) self.accept("w", self.setKey, ["forward", 1]) self.accept("d", self.setKey, ["right", 1]) self.accept("a-up", self.setKey, ["left", 0]) self.accept("s-up", self.setKey, ["backward", 0]) self.accept("w-up", self.setKey, ["forward", 0]) self.accept("d-up", self.setKey, ["right", 0]) self.accept("arrow_left", self.setKey, ["cam-left", 1]) self.accept("arrow_right", self.setKey, ["cam-right", 1]) self.accept("arrow_left-up", self.setKey, ["cam-left", 0]) self.accept("arrow_right-up", self.setKey, ["cam-right", 0]) self.accept("mouse1", self.attack, [3]) self.accept("mouse3", self.attack, [4]) self.username = str(raw_input("Username: "******"Type: ") faction = input("Faction: ") self.cManager.sendRequest(Constants.CMSG_AUTH, [self.username, type, faction]) #taskMgr.add(self.move,"moveTask") taskMgr.doMethodLater(.10, self.refresh, "heartbeat") base.disableMouse() #base.camera.setPos(self.player._character.getX(),self.player._character.getY()+10,2) ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-5, -5, -5)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) directionalLight2 = DirectionalLight("directionalLight2") directionalLight2.setDirection(Vec3(5, 5, 5)) directionalLight2.setColor(Vec4(1, 1, 1, 1)) directionalLight2.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(directionalLight2)) Chat(self.cManager) # Create control points self.cpList[1] = ControlPoint(1, 210.984, 115.005, -5, 10, RED) self.cpList[2] = ControlPoint(2, 141.016, 0.440607, -5, 10, RED) self.cpList[3] = ControlPoint(3, -0.903916, 11.3765, -2, 10, RED) self.cpList[4] = ControlPoint(4, -210.771, 113.753, -2, 10, BLUE) self.cpList[5] = ControlPoint(5, -149.953, 0.674369, -2, 10, BLUE) # Create the control point Bar UI self.cp_bar = ControlPointBar() # self.resource_bar = ResourceBar() taskMgr.doMethodLater(0.1, self.refresh, "heartbeat") taskMgr.doMethodLater(1, self.CPHandler, "CPHandler") taskMgr.doMethodLater(0.1, self.CPBarHandler, 'CPBarHandler') '''NPC Code Additions''' #self.isChased =[False,False] #self.npcList = [0,0] self.isChased = False self.npcList = 0 self.controlNpc = NPCController(render) taskMgr.add(self.taskAIUpdate, "AIUpdate") taskMgr.add(self.moveNpc, "Move")
def __init__(self): ShowBase.__init__(self) self.scene = self.loader.loadModel(models_dir + "hallway.bam") # Load the environment model self.scene.reparentTo(self.render) self.scene.setScale(1, 1, 1) self.scene.setPos(0, 0, 1) self.scene.setHpr(90, 0, 0) # Add an ambient light and set sky color sky_col = VBase3(135 / 255.0, 206 / 255.0, 235 / 255.0) self.set_background_color(sky_col) alight = AmbientLight("sky") alight.set_color(VBase4(sky_col * 0.04, 1)) alight_path = self.render.attachNewNode(alight) self.render.set_light(alight_path) # # 4 perpendicular lights (flood light) for light_no in range(4): d_light = DirectionalLight('directionalLight') d_light.setColor(Vec4(*([0.3] * 4))) d_light_NP = self.render.attachNewNode(d_light) d_light_NP.setHpr(-90 * light_no, 0, 0) self.render.setLight(d_light_NP) # # 1 directional light (Sun) sun_light = DirectionalLight('directionalLight') sun_light.setColor(Vec4(*([0.7] * 4))) # directional light is dim green sun_light.getLens().setFilmSize(Vec2(0.8, 0.8)) sun_light.getLens().setNearFar(-0.3, 12) sun_light.setShadowCaster(True, 2 ** 7, 2 ** 7) self.dlightNP = self.render.attachNewNode(sun_light) self.dlightNP.setHpr(0, -65, 0) # Turning shader and lights on self.render.setLight(self.dlightNP) # Load and transform the quadrotor actor. self.quad_model = self.loader.loadModel(models_dir + f'{quad_model_filename}.egg') self.prop_models = [] for prop_no in range(4): prop = self.loader.loadModel(models_dir + 'propeller.egg') x = 0 if prop_no % 2 == 1 else (-0.26 if prop_no == 0 else 0.26) y = 0 if prop_no % 2 == 0 else (-0.26 if prop_no == 3 else 0.26) prop.setPos(x, y, 0) prop.reparentTo(self.quad_model) self.prop_models.append(prop) self.prop_models = tuple(self.prop_models) # self.quad_model.reparentTo(self.scene) self.quad_model.setPos(0, 0, 2) self.quad_neutral_hpr = (90, 0, 0) self.quad_model.setHpr(*self.quad_neutral_hpr) # env cam self.cam_neutral_pos = (0, -4, 3) self.cam.reparentTo(self.scene) # self.cam_neutral_pos = (-4, 0, 1) # self.cam.reparentTo(self.quad_model) self.cam.setPos(*self.cam_neutral_pos) self.cam.lookAt(self.quad_model) self.enableParticles() node = NodePath("PhysicsNode") node.reparentTo(self.scene) self.actor_node = ActorNode("quadrotor-physics") # self.actor_node.getPhysicsObject().setMass(1) self.actor_node_physics = node.attachNewNode(self.actor_node) self.physicsMgr.attachPhysicalNode(self.actor_node) self.quad_model.reparentTo(self.actor_node_physics) # add gravity # gravity_force_node = ForceNode('world-forces') # gravityForce = LinearVectorForce(0, 0, -0.1) # gravity acceleration # gravity_force_node.addForce(gravityForce) # self.physicsMgr.addLinearForce(gravityForce) self.time = datetime.datetime.today().strftime('%Y-%m-%d-%H.%M.%S') self.simulation_folder = "\sims\\" + self.time + '\\' self.simulation_folder_path = ROOT_DIR + self.simulation_folder os.makedirs(self.simulation_folder_path) self.movements = '' self.taskMgr.add(self.camera_move, 'Camera Movement') self.taskMgr.add(self.quad_move, 'Quad Movement') self.taskMgr.add(self.rotate_propellers, 'Propellers Rotation') self.taskMgr.add(self.save_image, 'Screenshot Capture') # self.buffer: GraphicsBuffer = self.win.makeTextureBuffer(name='buffer', x_size=84, y_size=84, tex=None, to_ram=True) # self.buffer.setActive(1) self.images = [] self.image_index = 1
def setup(self): #self.targetAlt = r.randrange(100,300) self.Valves = np.array([0.15,0.2,0.15]) self.EngObs = self.vulcain.predict_data_point(np.array(self.Valves).reshape(1,-1)) if self.VISUALIZE is True: self.worldNP = self.render.attachNewNode('World') else: self.root = NodePath(PandaNode("world root")) self.worldNP = self.root.attachNewNode('World') self.world = BulletWorld() self.world.setGravity(Vec3(0, 0, -9.80665)) # World self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug')) self.debugNP.node().showWireframe(True) self.debugNP.node().showConstraints(True) self.debugNP.node().showBoundingBoxes(False) self.debugNP.node().showNormals(True) self.debugNP.show() self.world.setDebugNode(self.debugNP.node()) # self.debugNP.showTightBounds() # self.debugNP.showBounds() # Ground (static) shape = BulletPlaneShape(Vec3(0, 0, 1), 1) self.groundNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground')) self.groundNP.node().addShape(shape) self.groundNP.setPos(0, 0, 0) self.groundNP.setCollideMask(BitMask32.allOn()) self.world.attachRigidBody(self.groundNP.node()) # Rocket shape = BulletCylinderShape(self.radius, self.length, ZUp) self.rocketNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Cylinder')) self.rocketNP.node().setMass(27200 * self.scale) self.rocketNP.node().addShape(shape) #self.rocketNP.setPos(20,20,250) self.rocketNP.setPos(r.randrange(-200,200), 20, r.randrange(300, 500)) #self.rocketNP.setPos(r.randrange(-self.lateralError, self.lateralError, 1), r.randrange(-self.lateralError, self.lateralError, 1), self.height) # self.rocketNP.setPos(0, 0, self.length*10) self.rocketNP.setCollideMask(BitMask32.allOn()) # self.rocketNP.node().setCollisionResponse(0) self.rocketNP.node().notifyCollisions(True) self.world.attachRigidBody(self.rocketNP.node()) for i in range(4): leg = BulletCylinderShape(0.1 * self.radius, 0.5 * self.length, XUp) self.rocketNP.node().addShape(leg, TransformState.makePosHpr( Vec3(6 * self.radius * math.cos(i * math.pi / 2), 6 * self.radius * math.sin(i * math.pi / 2), -0.6 * self.length), Vec3(i * 90, 0, 30))) shape = BulletConeShape(0.75 * self.radius, 0.5 * self.radius, ZUp) self.rocketNP.node().addShape(shape, TransformState.makePosHpr(Vec3(0, 0, -1 / 2 * self.length), Vec3(0, 0, 0))) # Fuel self.fuelRadius = 0.9 * self.radius shape = BulletCylinderShape(self.fuelRadius, 0.01 * self.length, ZUp) self.fuelNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Cone')) self.fuelNP.node().setMass(self.fuelMass_full * self.fuelMass_init) self.fuelNP.node().addShape(shape) self.fuelNP.setPos(0, 0, self.rocketNP.getPos().getZ() - self.length * 0.5 * (1 - self.fuelMass_init)) self.fuelNP.setCollideMask(BitMask32.allOn()) self.fuelNP.node().setCollisionResponse(0) self.world.attachRigidBody(self.fuelNP.node()) frameA = TransformState.makePosHpr(Point3(0, 0, 0), Vec3(0, 0, 90)) frameB = TransformState.makePosHpr(Point3(0, 0, 0), Vec3(0, 0, 90)) self.fuelSlider = BulletSliderConstraint(self.rocketNP.node(), self.fuelNP.node(), frameA, frameB, 1) self.fuelSlider.setTargetLinearMotorVelocity(0) self.fuelSlider.setDebugDrawSize(2.0) self.fuelSlider.set_lower_linear_limit(0) self.fuelSlider.set_upper_linear_limit(0) self.world.attachConstraint(self.fuelSlider) self.npThrustForce = LineNodePath(self.rocketNP, 'Thrust', thickness=4, colorVec=Vec4(1, 0.5, 0, 1)) self.npDragForce = LineNodePath(self.rocketNP, 'Drag', thickness=4, colorVec=Vec4(1, 0, 0, 1)) self.npLiftForce = LineNodePath(self.rocketNP, 'Lift', thickness=4, colorVec=Vec4(0, 0, 1, 1)) self.npFuelState = LineNodePath(self.fuelNP, 'Fuel', thickness=20, colorVec=Vec4(0, 1, 0, 1)) self.rocketCSLon = self.radius ** 2 * math.pi self.rocketCSLat = self.length * 2 * self.radius if self.VISUALIZE is True: self.terrain = loader.loadModel("../LZGrid2.egg") self.terrain.setScale(10) self.terrain.reparentTo(self.render) self.terrain.setColor(Vec4(0.1, 0.2, 0.1, 1)) self.toggleTexture() #self.fuelNP.setPos(0, 0, self.rocketNP.getPos().getZ() - self.length * 0.4 * (1 - self.fuelMass_init)) for i in range(5): self.world.doPhysics(self.dt, 5, 1.0 / 180.0) self.fuelSlider.set_lower_linear_limit(-self.length * 0.5 * (1 - self.fuelMass_init)) self.fuelSlider.set_upper_linear_limit(self.length * 0.5 * (1 - self.fuelMass_init)) for i in range(100): self.world.doPhysics(self.dt, 5, 1.0 / 180.0) self.rocketNP.node().applyForce(Vec3(0,0,300000), Vec3(0, 0, 0))
def createGuiObjects(self): self.dayButton = DirectButton(parent=self.dayButtonLocator, image=self.selectedFrame, relief=None, command=self.__clickedOnDay, pressEffect=1, rolloverSound=None, clickSound=None) self.numberWidget = DirectLabel(parent=self.numberLocator, relief=None, text=str(self.myDate.day), text_scale=0.04, text_align=TextNode.ACenter, text_font=ToontownGlobals.getInterfaceFont(), text_fg=Vec4(110 / 255.0, 126 / 255.0, 255 / 255.0, 1)) self.attachMarker(self.numberLocator) self.listXorigin = 0 self.listFrameSizeX = self.scrollBottomRightLocator.getX() - self.scrollLocator.getX() self.scrollHeight = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ() self.listZorigin = self.scrollBottomRightLocator.getZ() self.listFrameSizeZ = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ() self.arrowButtonXScale = 1 self.arrowButtonZScale = 1 self.itemFrameXorigin = 0 self.itemFrameZorigin = 0 self.buttonXstart = self.itemFrameXorigin + 0.21 self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui') buttonOffSet = -0.01 incButtonPos = (0.0, 0, 0) decButtonPos = (0.0, 0, 0) itemFrameMinZ = self.listZorigin itemFrameMaxZ = self.listZorigin + self.listFrameSizeZ arrowUp = self.find('**/downScroll_up') arrowDown = self.find('**/downScroll_down') arrowHover = self.find('**/downScroll_hover') self.scrollList = DirectScrolledList(parent=self.scrollLocator, relief=None, pos=(0, 0, 0), incButton_image=(arrowUp, arrowDown, arrowHover, arrowUp), incButton_relief=None, incButton_scale=(self.arrowButtonXScale, 1, self.arrowButtonZScale), incButton_pos=incButtonPos, incButton_image3_color=Vec4(1, 1, 1, 0.2), decButton_image=(arrowUp, arrowDown, arrowHover, arrowUp), decButton_relief=None, decButton_scale=(self.arrowButtonXScale, 1, -self.arrowButtonZScale), decButton_pos=decButtonPos, decButton_image3_color=Vec4(1, 1, 1, 0.2), itemFrame_pos=(self.itemFrameXorigin, 0, -0.03), numItemsVisible=4, incButtonCallback=self.scrollButtonPressed, decButtonCallback=self.scrollButtonPressed) itemFrameParent = self.scrollList.itemFrame.getParent() self.scrollList.incButton.reparentTo(self.scrollDownLocator) self.scrollList.decButton.reparentTo(self.scrollUpLocator) arrowUp.removeNode() arrowDown.removeNode() arrowHover.removeNode() clipper = PlaneNode('clipper') clipper.setPlane(Plane(Vec3(-1, 0, 0), Point3(0.23, 0, 0))) clipNP = self.scrollList.component('itemFrame').attachNewNode(clipper) self.scrollList.component('itemFrame').setClipPlane(clipNP) return
class LaffMeter(DirectFrame): deathColor = Vec4(0.58039216, 0.80392157, 0.34117647, 1.0) def __init__(self, avdna, hp, maxHp): DirectFrame.__init__(self, relief=None, sortOrder=50) self.initialiseoptions(LaffMeter) self.container = DirectFrame(parent=self, relief=None) self.style = avdna self.av = None self.hp = hp self.maxHp = maxHp self.__obscured = 0 if self.style.type == 't': self.isToon = 1 else: self.isToon = 0 self.load() return def obscure(self, obscured): self.__obscured = obscured if self.__obscured: self.hide() def isObscured(self): return self.__obscured def load(self): gui = loader.loadModel('phase_3/models/gui/laff_o_meter') if self.isToon: hType = self.style.getType() if hType == 'dog': headModel = gui.find('**/doghead') elif hType == 'cat': headModel = gui.find('**/cathead') elif hType == 'mouse': headModel = gui.find('**/mousehead') elif hType == 'horse': headModel = gui.find('**/horsehead') elif hType == 'rabbit': headModel = gui.find('**/bunnyhead') elif hType == 'duck': headModel = gui.find('**/duckhead') elif hType == 'chicken': headModel = gui.find('**/duckhead') elif hType == 'monkey': headModel = gui.find('**/monkeyhead') elif hType == 'bear': headModel = gui.find('**/bearhead') elif hType == 'pig': headModel = gui.find('**/pighead') else: raise StandardError('unknown toon species: ', hType) self.color = self.style.getHeadColor() self.container['image'] = headModel self.container['image_color'] = self.color self.resetFrameSize() self.setScale(0.1) self.frown = DirectFrame(parent=self.container, relief=None, image=gui.find('**/frown')) self.smile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/smile')) self.eyes = DirectFrame(parent=self.container, relief=None, image=gui.find('**/eyes')) self.openSmile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/open_smile')) self.tooth1 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_1')) self.tooth2 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_2')) self.tooth3 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_3')) self.tooth4 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_4')) self.tooth5 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_5')) self.tooth6 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_6')) self.maxLabel = DirectLabel(parent=self.eyes, relief=None, pos=(0.442, 0, 0.051), text='120', text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont()) self.hpLabel = DirectLabel(parent=self.eyes, relief=None, pos=(-0.398, 0, 0.051), text='120', text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont()) self.teeth = [self.tooth6, self.tooth5, self.tooth4, self.tooth3, self.tooth2, self.tooth1] self.fractions = [0.0, 0.166666, 0.333333, 0.5, 0.666666, 0.833333] gui.removeNode() return def destroy(self): if self.av: ToontownIntervals.cleanup(self.av.uniqueName('laffMeterBoing') + '-' + str(self.this)) ToontownIntervals.cleanup(self.av.uniqueName('laffMeterBoing') + '-' + str(self.this) + '-play') self.ignore(self.av.uniqueName('hpChange')) del self.style del self.av del self.hp del self.maxHp if self.isToon: del self.frown del self.smile del self.openSmile del self.tooth1 del self.tooth2 del self.tooth3 del self.tooth4 del self.tooth5 del self.tooth6 del self.teeth del self.fractions del self.maxLabel del self.hpLabel DirectFrame.destroy(self) def adjustTeeth(self): if self.isToon: for i in xrange(len(self.teeth)): if self.hp > self.maxHp * self.fractions[i]: self.teeth[i].show() else: self.teeth[i].hide() def adjustText(self): if self.isToon: if self.maxLabel['text'] != str(self.maxHp) or self.hpLabel['text'] != str(self.hp): self.maxLabel['text'] = str(self.maxHp) self.hpLabel['text'] = str(self.hp) def animatedEffect(self, delta): if delta == 0 or self.av == None: return name = self.av.uniqueName('laffMeterBoing') + '-' + str(self.this) ToontownIntervals.cleanup(name) if delta > 0: ToontownIntervals.start(ToontownIntervals.getPulseLargerIval(self.container, name)) else: ToontownIntervals.start(ToontownIntervals.getPulseSmallerIval(self.container, name)) return def adjustFace(self, hp, maxHp, quietly = 0): if self.isToon and self.hp != None: self.frown.hide() self.smile.hide() self.openSmile.hide() self.eyes.hide() for tooth in self.teeth: tooth.hide() delta = hp - self.hp self.hp = hp self.maxHp = maxHp if self.hp < 1: self.frown.show() self.container['image_color'] = self.deathColor elif self.hp >= self.maxHp: self.smile.show() self.eyes.show() self.container['image_color'] = self.color else: self.openSmile.show() self.eyes.show() self.maxLabel.show() self.hpLabel.show() self.container['image_color'] = self.color self.adjustTeeth() self.adjustText() if not quietly: self.animatedEffect(delta) return def start(self): if self.av: self.hp = self.av.hp self.maxHp = self.av.maxHp if self.isToon: if not self.__obscured: self.show() self.adjustFace(self.hp, self.maxHp, 1) if self.av: self.accept(self.av.uniqueName('hpChange'), self.adjustFace) def stop(self): if self.isToon: self.hide() if self.av: self.ignore(self.av.uniqueName('hpChange')) def setAvatar(self, av): if self.av: self.ignore(self.av.uniqueName('hpChange')) self.av = av
from panda3d.core import Vec3, Vec4, BitMask32 from direct.showbase.DirectObject import DirectObject from panda3d.core import BitMask32, CollisionTraverser, CollisionNode, CollisionHandlerQueue, CollisionSphere from direct.gui.DirectGui import DirectWaitBar VALID_HIGHLIGHT_COLOR = Vec4(36.0 / 255, 225.0 / 255, 213.0 / 255, 1) INVALID_HIGHLIGHT_COLOR = Vec4(1, 0, 0, 1) RIGHT = 0 DOWN = 1 LEFT = 2 UP = 3 DIRECTION_TO_VECTOR = { RIGHT: Vec3(1, 0, 0), DOWN: Vec3(0, -1, 0), LEFT: Vec3(-1, 0, 0), UP: Vec3(0, 1, 0) } SLOW_COLOR = Vec4(0, 0, 1, 0.2) STUN_COLOR = Vec4(0, 0.5, 0.5, 0.2) # Parent Class for environment blocks class Block(DirectObject): def __init__(self, model, parent, x, y, z=0.5): self.index = -1 self.tower = 0 # Whether a tower is on top of this block # Load and position 3D Model self.model = loader.loadModel('models/' + model)
def update(self, task): if not self.shouldRender(): self.removeCurrentGrid() return task.cont zoom = self.calcZoom() step = GridSettings.DefaultStep low = GridSettings.Low high = GridSettings.High actualDist = step * zoom if GridSettings.HideSmallerToggle: while actualDist < GridSettings.HideSmallerThan: step *= GridSettings.HideFactor actualDist *= GridSettings.HideFactor if step == self.lastStep and self.gridNp: return task.cont self.removeCurrentGrid() self.lastStep = step if step in self.gridsByStep: self.gridNp = self.gridsByStep[step].copyTo(self.viewport.gridRoot) return task.cont segs = LineSegs() i = low while i <= high: color = GridSettings.GridLines if i == 0: # On zero lines, give each axis an appropriate color. axes = self.viewport.getGridAxes() color = Vec4(0, 0, 0, 1) color[axes[0]] = 1 color2 = Vec4(0, 0, 0, 1) color2[axes[1]] = 1 #elif (i % GridSettings.Highlight2Unit) == 0 and GridSettings.Highlight2Toggle: # color = GridSettings.Highlight2 elif (i % (step * GridSettings.Highlight1Line) == 0) and GridSettings.Highlight1Toggle: color = GridSettings.Highlight1 segs.setColor(color) segs.moveTo(self.viewport.expand(Point3(low, 0, i))) segs.drawTo(self.viewport.expand(Point3(high, 0, i))) if i == 0: segs.setColor(color2) segs.moveTo(self.viewport.expand(Point3(i, 0, low))) segs.drawTo(self.viewport.expand(Point3(i, 0, high))) i += step #segs.setColor(GridSettings.BoundaryLines) # top #segs.moveTo(self.viewport.expand(Point3(low, 0, high))) #segs.drawTo(self.viewport.expand(Point3(high, 0, high))) # left #segs.moveTo(self.viewport.expand(Point3(low, 0, low))) #segs.drawTo(self.viewport.expand(Point3(low, 0, high))) # right #segs.moveTo(self.viewport.expand(Point3(high, 0, low))) #segs.drawTo(self.viewport.expand(Point3(high, 0, high))) # bottom #segs.moveTo(self.viewport.expand(Point3(low, 0, low))) #segs.drawTo(self.viewport.expand(Point3(high, 0, low))) np = NodePath(segs.create()) #np.setAntialias(AntialiasAttrib.MLine) #loader.loadModel("models/smiley.egg.pz").reparentTo(np) self.gridsByStep[step] = np self.gridNp = np.copyTo(self.viewport.gridRoot) return task.cont
def load(self): Hood.Hood.load(self) self.whiteFogColor = Vec4(0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 1) self.underwaterFogColor = Vec4(0.0, 0.0, 0.59999999999999998, 1.0)
def _updateShadowSources(self): """ Updates the PSSM Frustum and all PSSM Splits """ mixVector = lambda p1, p2, a: ((p2*a) + (p1*(1.0-a))) pstats_PSSM.start() # Fetch camera data camPos = self.pssmTargetCam.getPos() # Compute frustum points nearPoint = Point3() farPoint = Point3() self.pssmTargetLens.extrude(Point2(0.0), nearPoint, farPoint) nearPoint = Globals.base.render.getRelativePoint(self.pssmTargetCam, nearPoint) farPoint = Globals.base.render.getRelativePoint(self.pssmTargetCam, farPoint) trNearPoint = Point3() trFarPoint = Point3() self.pssmTargetLens.extrude(Point2(1.0), trNearPoint, trFarPoint) trNearPoint = Globals.base.render.getRelativePoint(self.pssmTargetCam, trNearPoint) trFarPoint = Globals.base.render.getRelativePoint(self.pssmTargetCam, trFarPoint) # Position the splits # This is the PSSM split function, currently cubic splitFunc = lambda x: math.pow(float(x+0.5)/(self.splitCount+0.5), self.pssmSplitPow) relativeSplitSize = self.pssmFarPlane / self.pssmTargetLens.getFar() self.updateIndex += 1 self.updateIndex = self.updateIndex % 2 direction = Vec3(self.position) direction.normalize() # Process each cascade for i in xrange(self.splitCount): source = self.shadowSources[i] # Find frustum section for this cascade splitParamStart = splitFunc(i) * relativeSplitSize splitParamEnd = splitFunc(i+1) * relativeSplitSize midPos = mixVector(nearPoint, farPoint, (splitParamStart + splitParamEnd) / 2.0 ) topPlanePos = mixVector(trNearPoint, trFarPoint, splitParamEnd ) filmSize = (topPlanePos - midPos).length() * 2.0 midPos += camPos destPos = midPos + direction * 1.0 # Set source position + rotation source.setPos(destPos) source.lookAt(midPos) source.setFilmSize(filmSize, filmSize) # Stable CSM Snapping # This snaps the source to its texel grids, so that there is no flickering # visible when the source moves. This works by projecting the # Point (0,0,0) to light space, compute the texcoord differences and # offset the light world space position by that. mvp = Mat4(source.computeMVP()) basePoint = mvp.xform(Point4(0,0,0,1)) texelSize = 1.0 / float(source.resolution) basePoint *= 0.5 basePoint += Vec4(0.5) offsetX = basePoint.x % texelSize offsetY = basePoint.y % texelSize mvp.invertInPlace() newBase = mvp.xform(Point4( (basePoint.x - offsetX) * 2.0 - 1.0, (basePoint.y - offsetY) * 2.0 - 1.0, (basePoint.z) * 2.0 - 1.0, 1)) destPos -= Vec3(newBase.x, newBase.y, newBase.z) self.shadowSources[i].setPos(destPos) # Invalidate the source after changing the position self.shadowSources[i].invalidate() pstats_PSSM.stop()
import direct.directbase.DirectStart from panda3d.core import CollisionTraverser, CollisionNode from panda3d.core import CollisionHandlerQueue, CollisionRay from panda3d.core import AmbientLight, DirectionalLight, LightAttrib from panda3d.core import TextNode from panda3d.core import Point3, Vec3, Vec4, BitMask32 from direct.gui.OnscreenText import OnscreenText from direct.showbase.DirectObject import DirectObject from direct.task.Task import Task from direct.actor.Actor import Actor import sys import random from direct.gui.DirectGui import * #First we define some contants for the colors BLACK = Vec4(0.5, 0.1, 0.1, 1) WHITE = Vec4(1, 1, 1, 1) HIGHLIGHT = Vec4(0, 1, 1, 1) #Now we define some helper functions that we will need later #This function, given a line (vector plus origin point) and a desired z value, #will give us the point on the line where the desired z value is what we want. #This is how we know where to position an object in 3D space based on a 2D mouse #position. It also assumes that we are dragging in the XY plane. # #This is derived from the mathmatical of a plane, solved for a given point def PointAtZ(z, point, vec): return point + vec * ((z - point.getZ()) / vec.getZ())
def __init__(self): GameObject.__init__(self, Vec3(0, 0, 0), None, None, 100, 15, "player", 1, MASK_INTO_PLAYER) Walker.__init__(self) ArmedObject.__init__(self) self.weaponNP = self.actor light = PointLight("basic light") light.setColor(Vec4(1, 1, 1, 1)) light.setAttenuation((1, 0.01, 0.005)) self.lightNP = self.root.attachNewNode(light) self.lightNP.setZ(1) render.setLight(self.lightNP) self.collider.node().setFromCollideMask(MASK_WALLS | MASK_FROM_PLAYER) self.actor.setZ(self.height) base.camera.reparentTo(self.actor) base.camera.setPos(0, 0, 0) base.camera.setHpr(0, 0, 0) lens = base.camLens ratio = lens.getAspectRatio() lens.setFov(80 * ratio) lens.setNear(0.03) self.lastMousePos = Vec2(0, 0) self.mouseSpeedHori = 50.0 self.mouseSpeedVert = 30.0 self.mouseSensitivity = 1.0 self.healthLeft = -0.9 self.healthRight = 0.9 self.healthWidth = self.healthRight - self.healthLeft self.uiRoot = base.a2dBottomCenter.attachNewNode( PandaNode("player UI")) self.healthBar = loader.loadModel("UI/healthBar") self.healthBar.reparentTo(self.uiRoot) self.healthBar.setZ(0.05) self.healthBar.setX(self.healthLeft) self.healthBar.getChild(0).setScale(self.healthWidth / 6.0) self.weaponUIRoot = self.uiRoot.attachNewNode( PandaNode("player weapon UI")) self.weaponUIRoot.setPos(0, 0, 0.1) self.addWeapon(RapidShotgunWeapon(self.weaponUIRoot)) self.addWeapon(BlasterWeapon(self.weaponUIRoot)) self.weapons[0].setAvailable(True) self.setCurrentWeapon(0) self.updateHealthUI() self.inventory = [] self.updatingEffects = [] self.interactionSegment = CollisionSegment(0, 0, 0, 0, 1.5, 0) rayNode = CollisionNode("player interaction ray") rayNode.addSolid(self.interactionSegment) rayNode.setFromCollideMask(MASK_WALLS | MASK_FLOORS | MASK_INTO_ENEMY) rayNode.setIntoCollideMask(0) self.interactionSegmentNodePath = self.actor.attachNewNode(rayNode) #self.interactionSegmentNodePath.show() self.interactionSegmentQueue = CollisionHandlerQueue() self.interactionSegmentTraverser = CollisionTraverser() self.interactionSegmentTraverser.addCollider( self.interactionSegmentNodePath, self.interactionSegmentQueue)
def __init__(self): self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0} base.win.setClearColor(Vec4(0, 0, 0, 1)) # number of collectibles self.numObjects = 10 # print the number of objects printNumObj(self.numObjects) # Post the instructions self.title = addTitle("Roaming Ralph (Edited by Adam Gressen)") self.inst1 = addInstructions(0.95, "[ESC]: Quit") self.inst2 = addInstructions(0.90, "[A]: Rotate Ralph Left") self.inst3 = addInstructions(0.85, "[D]: Rotate Ralph Right") self.inst4 = addInstructions(0.80, "[W]: Run Ralph Forward") self.inst5 = addInstructions(0.75, "[S]: Run Ralph Backward") self.inst6 = addInstructions(0.70, "[Space]: Run, Ralph, Run") # Set up the environment # # This environment model contains collision meshes. If you look # in the egg file, you will see the following: # # <Collide> { Polyset keep descend } # # This tag causes the following mesh to be converted to a collision # mesh -- a mesh which is optimized for collision, not rendering. # It also keeps the original mesh, so there are now two copies --- # one optimized for rendering, one for collisions. self.environ = loader.loadModel("models/world") self.environ.reparentTo(render) self.environ.setPos(0, 0, 0) # Timer to increment in the move task self.time = 0 # Get bounds of environment min, max = self.environ.getTightBounds() self.mapSize = max - min # Create the main character, Ralph self.ralphStartPos = self.environ.find("**/start_point").getPos() self.ralph = Actor("models/ralph", { "run": "models/ralph-run", "walk": "models/ralph-walk" }) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.ralph.setPos(self.ralphStartPos) # ralph's health self.health = 100 # ralph's stamina self.stamina = 100 # Create a floater object. We use the "floater" as a temporary # variable in a variety of calculations. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) # these don't work well in combination with the space bar self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_right", self.setKey, ["right", 1]) self.accept("arrow_up", self.setKey, ["forward", 1]) self.accept("arrow_down", self.setKey, ["backward", 1]) self.accept("arrow_left-up", self.setKey, ["left", 0]) self.accept("arrow_right-up", self.setKey, ["right", 0]) self.accept("arrow_up-up", self.setKey, ["forward", 0]) self.accept("arrow_down-up", self.setKey, ["backward", 0]) self.accept("space", self.runRalph, [True]) self.accept("space-up", self.runRalph, [False]) self.accept("a", self.setKey, ["left", 1]) self.accept("d", self.setKey, ["right", 1]) self.accept("w", self.setKey, ["forward", 1]) self.accept("s", self.setKey, ["backward", 1]) self.accept("a-up", self.setKey, ["left", 0]) self.accept("d-up", self.setKey, ["right", 0]) self.accept("w-up", self.setKey, ["forward", 0]) self.accept("s-up", self.setKey, ["backward", 0]) # Game state variables self.isMoving = False self.isRunning = False # Set up the camera base.disableMouse() #base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2) base.camera.setPos(0, 0, 0) base.camera.reparentTo(self.ralph) base.camera.setPos(0, 40, 2) base.camera.lookAt(self.ralph) # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above ralph's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. base.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 300) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() base.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) # camera ground collision handler self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 300) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(BitMask32.bit(0)) self.camGroundCol.setIntoCollideMask(BitMask32.allOff()) self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() base.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Place the health items self.placeHealthItems() # Place the collectibles self.placeCollectibles() # Uncomment this line to show a visual representation of the # collisions occuring #base.cTrav.showCollisions(render) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-5, -5, -5)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) taskMgr.add(self.move, "moveTask") taskMgr.doMethodLater(0.5, self.healthDec, "healthTask")
def set_clear_color(self, *args): """ Sets the clear color """ self._internal_buffer.set_clear_color_active(True) self._internal_buffer.set_clear_color(Vec4(*args))
MinniesMelodyland: 2, GoofySpeedway: 2, TheBrrrgh: 2, DaisyGardens: 2, FunnyFarm: 2, DonaldsDreamland: 2, OutdoorZone: 2, BossbotHQ: 2, SellbotHQ: 43, CashbotHQ: 2, LawbotHQ: 2, GolfZone: 2, PartyHood: 2 } TrophyStarLevels = (10, 20, 30, 50, 75, 100) TrophyStarColors = (Vec4(0.9, 0.6, 0.2, 1), Vec4(0.9, 0.6, 0.2, 1), Vec4(0.8, 0.8, 0.8, 1), Vec4(0.8, 0.8, 0.8, 1), Vec4(1, 1, 0, 1), Vec4(1, 1, 0, 1)) MickeySpeed = 5.0 VampireMickeySpeed = 1.15 MinnieSpeed = 3.2 WitchMinnieSpeed = 1.8 DonaldSpeed = 3.68 FrankenDonaldSpeed = 0.9 DaisySpeed = 2.3 GoofySpeed = 5.2 SuperGoofySpeed = 1.6 PlutoSpeed = 5.5 WesternPlutoSpeed = 3.2 ChipSpeed = 3 DaleSpeed = 3.5
def makeObject(self, point_cloud): self.set_node_p3d( custom_geometry.create_colored_polygon2d_GeomNode_from_point_cloud( point_cloud, color_vec4=Vec4(1., 1., 1., 1.))) self.set_p3d_nodepath(self.getParent_p3d().attachNewNode_p3d( self.p3d_node))
def update(self): """ Updates the commonly used resources, mostly the shader inputs """ update = self._input_ubo.update_input # Get the current transform matrix of the camera view_mat = Globals.render.get_transform(self._showbase.cam).get_mat() # Compute the view matrix, but with a z-up coordinate system zup_conversion = Mat4.convert_mat(CS_zup_right, CS_yup_right) update("view_mat_z_up", view_mat * zup_conversion) # Compute the view matrix without the camera rotation view_mat_billboard = Mat4(view_mat) view_mat_billboard.set_row(0, Vec3(1, 0, 0)) view_mat_billboard.set_row(1, Vec3(0, 1, 0)) view_mat_billboard.set_row(2, Vec3(0, 0, 1)) update("view_mat_billboard", view_mat_billboard) update("camera_pos", self._showbase.camera.get_pos(Globals.render)) # Compute last view projection mat curr_vp = self._input_ubo.get_input("view_proj_mat_no_jitter") update("last_view_proj_mat_no_jitter", curr_vp) curr_vp = Mat4(curr_vp) curr_vp.invert_in_place() curr_inv_vp = curr_vp update("last_inv_view_proj_mat_no_jitter", curr_inv_vp) proj_mat = Mat4(self._showbase.camLens.get_projection_mat()) # Set the projection matrix as an input, but convert it to the correct # coordinate system before. proj_mat_zup = Mat4.convert_mat(CS_yup_right, CS_zup_right) * proj_mat update("proj_mat", proj_mat_zup) # Set the inverse projection matrix update("inv_proj_mat", invert(proj_mat_zup)) # Remove jitter and set the new view projection mat proj_mat.set_cell(1, 0, 0.0) proj_mat.set_cell(1, 1, 0.0) update("view_proj_mat_no_jitter", view_mat * proj_mat) # Store the frame delta update("frame_delta", Globals.clock.get_dt()) update("smooth_frame_delta", 1.0 / max(1e-5, Globals.clock.get_average_frame_rate())) update("frame_time", Globals.clock.get_frame_time()) # Store the current film offset, we use this to compute the pixel-perfect # velocity, which is otherwise not possible. Usually this is always 0 # except when SMAA and reprojection is enabled update("current_film_offset", self._showbase.camLens.get_film_offset()) update("frame_index", Globals.clock.get_frame_count()) # Compute frustum corners in the order BL, BR, TL, TR ws_frustum_directions = Mat4() vs_frustum_directions = Mat4() inv_proj_mat = Globals.base.camLens.get_projection_mat_inv() view_mat_inv = Mat4(view_mat) view_mat_inv.invert_in_place() for i, point in enumerate(((-1, -1), (1, -1), (-1, 1), (1, 1))): result = inv_proj_mat.xform(Vec4(point[0], point[1], 1.0, 1.0)) vs_dir = (zup_conversion.xform(result)).xyz.normalized() vs_frustum_directions.set_row(i, Vec4(vs_dir, 1)) ws_dir = view_mat_inv.xform(Vec4(result.xyz, 0)) ws_frustum_directions.set_row(i, ws_dir) update("vs_frustum_directions", vs_frustum_directions) update("ws_frustum_directions", ws_frustum_directions) update("screen_size", Globals.resolution) update("native_screen_size", Globals.native_resolution) update("lc_tile_count", self._pipeline.light_mgr.num_tiles)
def start(self): base.transitions.fadeOut(t=0) self.setColorScale(Vec4(1, 1, 1, 1)) if self.fadeTrack is not None: self.fadeTrack.finish() self.fadeTrack = None self.fadeTrack = base.transitions.getFadeInIval(t=2) self.fadeTrack.start() if self.logoScaleTrack is not None: self.logoScaleTrack.finish() self.logoScaleTrack = None self.logoScaleTrack = Sequence( LerpScaleInterval(self.logo, 2, Vec3(1.1, 1, 0.55), Vec3(1, 1, 0.5), blendType='easeInOut'), LerpScaleInterval(self.logo, 2, Vec3(1, 1, 0.5), Vec3(1.1, 1, 0.55), blendType='easeInOut')) if self.logoPosTrack is not None: self.logoPosTrack.finish() self.logoPosTrack = None self.logoPosTrack = Sequence( LerpPosInterval(self.logo, 2, Point3(0, 0, -0.85), Point3(0, 0, -0.7), blendType='easeOut'), Func(self.logoScaleTrack.loop)) self.logoPosTrack.start() if self.labelColorScaleTrack is not None: self.labelColorScaleTrack.finish() self.labelColorScaleTrack = None self.labelColorScaleTrack = Sequence( LerpColorScaleInterval(self.label, 1, Vec4(1, 1, 1, 0.6), Vec4(1, 1, 1, 1)), LerpColorScaleInterval(self.label, 1, Vec4(1, 1, 1, 1), Vec4(1, 1, 1, 0.6))) if self.labelPosTrack is not None: self.labelPosTrack.finish() self.labelPosTrack = None self.labelPosTrack = Sequence( LerpPosInterval(self.label, 2, Point3(0, 0, 0.35), Point3(0, 0, 0.15), blendType='easeOut'), Func(self.labelColorScaleTrack.loop)) self.labelPosTrack.start() self.acceptOnce('mouse1', self.begin)
boxBody.setPosition(boxNP.getPos(render)) boxBody.setQuaternion(boxNP.getQuat(render)) # Create a BoxGeom boxGeom = OdeBoxGeom(space, 1, 1, 1) boxGeom.setCollideBits(BitMask32(0x00000002)) boxGeom.setCategoryBits(BitMask32(0x00000001)) boxGeom.setBody(boxBody) boxes.append((boxNP, boxBody)) # Add a plane to collide with cm = CardMaker("ground") cm.setFrame(-20, 20, -20, 20) ground = render.attachNewNode(cm.generate()) ground.setPos(0, 0, 0) ground.lookAt(0, 0, -1) groundGeom = OdePlaneGeom(space, Vec4(0, 0, 1, 0)) # groundGeom.setCollideBits(BitMask32(0x00000001)) # groundGeom.setCategoryBits(BitMask32(0x00000002)) # Set the camera position base.disableMouse() base.camera.setPos(40, 40, 20) base.camera.lookAt(0, 0, 0) # The task for our simulation def simulationTask(task): space.autoCollide() # Setup the contact joints # Step the simulation and set the new positions world.quickStep(globalClock.getDt()) for np, body in boxes:
def __init__(self, name='glow', amount=0, red=100, green=100, blue=100): print "Glow enabled!" ## Glow by Adam Bell ([email protected]) ## with some original code from Kwasi Mensah ([email protected]) ## for PandaCamp (code.google.com/p/pandacamp/) #The shader is important (but yet a variable). ## The next part I'll replace with a single file as soon ## as I can work with variables in the *.SHA files. redd = red / 100 greend = green / 100 blued = blue / 100 if amount == 0: print "glowShader set to it's default value of 1." amount = 1 ## Custom number for a positive non-integer or above 4. if amount > 0: ### NOTE: the line below is an RGB render.setShaderInput('amnt', amount * redd, amount * greend, amount * blued, amount) print "glowShader set as " + str(amount) + "!" if amount < 0: raise TypeError('Only positive numbers work for the glowShader!') # except that only the glowing materials should show up nonblack. base.disableMouse() glowBuffer = base.win.makeTextureBuffer("Glow scene", 512, 512) glowBuffer.setSort(-3) glowBuffer.setClearColor(Vec4(0, 0, 0, 1)) glowCamera = base.makeCamera(glowBuffer, lens=base.cam.node().getLens()) # Tell the glow camera to use the glow shader tempnode = NodePath(PandaNode("temp node")) tempnode.setShader( loader.loadShader('/c/panda/pandacamp/src/shaders/glowShader.sha')) ## Was 'Shader.load' glowCamera.node().setInitialState(tempnode.getState()) # X and Y shaders to make the earlier "glowShader.sha" work (or effective). blurXBuffer = makeFilterBuffer( glowBuffer, "Blur X", -2, "/c/panda/pandacamp/src/shaders/XBlurShader.sha") blurYBuffer = makeFilterBuffer( blurXBuffer, "Blur Y", -1, "/c/panda/pandacamp/src/shaders/YBlurShader.sha") self.finalcard = blurYBuffer.getTextureCard() self.finalcard.reparentTo(render2d) self.finalcard.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd)) # Panda contains a built-in viewer that lets you view the results of # your render-to-texture operations. This code configures the viewer. base.bufferViewer.setPosition("llcorner") base.bufferViewer.setLayout("hline") base.bufferViewer.setCardSize(0.652, 0)
def __init__(self): ShowBase.__init__(self) #renaming properties properties = WindowProperties() #set windows size property properties.setSize(1000, 750) #activate the property to the current window self.win.requestProperties(properties) #Calling one of Panda's lighting functions and naming it ambientLight = AmbientLight("ambient light") #setting the colour ambientLight.setColor(Vec4(1, 1, 1, 1)) #creating a lighting node and adding it to the render list (doesn't do anything yet) self.ambientLightNodePath = self.render.attachNewNode(ambientLight) #We need to also use the setLight function to actually light the scene self.render.setLight(self.ambientLightNodePath) #choose shader self.render.setShaderAuto() #gather main camera generated by showbase self.first_person_camera_node = self.cam self.mouseLook = FirstPersonCamera(self, self.first_person_camera_node, self.render) lens = OrthographicLens() lens.setFilmSize(2, 2) # Or whatever is appropriate for your scene self.spot_camera = Camera("Spot Camera") self.spot_camera.setLens(lens) self.spot_camera_node = self.render.attachNewNode(self.spot_camera) self.spot_camera_node.node().setLens(lens) self.spot_camera_node.setName("Spot Camera") self.spot_camera_node.setPos(2, 0, 0) self.spot_camera_node.lookAt(0, 0, 0) dr = base.camNode.getDisplayRegion(0) dr.setActive(0) window = dr.getWindow() dr1 = window.makeDisplayRegion(0, 0.8, 0, 1) dr1.setSort(dr.getSort()) dr2 = window.makeDisplayRegion(0.8, 0.9, 0.2, 0.4) dr2.setSort(dr.getSort()) dr1.setCamera(self.first_person_camera_node) dr2.setCamera(self.spot_camera_node) axes = self.createAxes(2) axes.reparentTo(self.render) self.Line = self.render.attachNewNode(LineSegs().create()) self.taskMgr.add(self.update, "Update")
def setup(self): #self.targetAlt = r.randrange(100,300) self.Valves = np.array([0.15, 0.2, 0.15]) self.EngObs = self.vulcain.predict_data_point( np.array(self.Valves).reshape(1, -1)) if self.VISUALIZE is True: self.worldNP = self.render.attachNewNode('World') else: self.root = NodePath(PandaNode("world root")) self.worldNP = self.root.attachNewNode('World') self.world = BulletWorld() self.world.setGravity(Vec3(0, 0, -9.80665)) # World self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug')) self.debugNP.node().showWireframe(True) self.debugNP.node().showConstraints(True) self.debugNP.node().showBoundingBoxes(False) self.debugNP.node().showNormals(True) self.debugNP.show() self.world.setDebugNode(self.debugNP.node()) # self.debugNP.showTightBounds() # self.debugNP.showBounds() # Ground (static) shape = BulletPlaneShape(Vec3(0, 0, 1), 1) self.groundNP = self.worldNP.attachNewNode( BulletRigidBodyNode('Ground')) self.groundNP.node().addShape(shape) self.groundNP.setPos(0, 0, 0) self.groundNP.setCollideMask(BitMask32.allOn()) self.world.attachRigidBody(self.groundNP.node()) # Rocket shape = BulletCylinderShape(self.radius, self.length, ZUp) self.rocketNP = self.worldNP.attachNewNode( BulletRigidBodyNode('Cylinder')) self.rocketNP.node().setMass(self.drymass + self.fuelAmount_LH2 + self.fuelAmount_LOX) self.rocketNP.node().addShape(shape) #self.rocketNP.setPos(20,20,250) self.rocketNP.setPos(r.randrange(-200, 200), 20, 350) #r.randrange(300, 500)) #self.rocketNP.setPos(r.randrange(-self.lateralError, self.lateralError, 1), r.randrange(-self.lateralError, self.lateralError, 1), self.height) # self.rocketNP.setPos(0, 0, self.length*10) self.rocketNP.setCollideMask(BitMask32.allOn()) # self.rocketNP.node().setCollisionResponse(0) self.rocketNP.node().notifyCollisions(True) self.world.attachRigidBody(self.rocketNP.node()) for i in range(4): leg = BulletCylinderShape(0.1 * self.radius, 0.5 * self.length, XUp) self.rocketNP.node().addShape( leg, TransformState.makePosHpr( Vec3(6 * self.radius * math.cos(i * math.pi / 2), 6 * self.radius * math.sin(i * math.pi / 2), -0.6 * self.length), Vec3(i * 90, 0, 30))) shape = BulletConeShape(0.75 * self.radius, 0.5 * self.radius, ZUp) self.rocketNP.node().addShape( shape, TransformState.makePosHpr(Vec3(0, 0, -1 / 2 * self.length), Vec3(0, 0, 0))) self.npThrustForce = LineNodePath(self.rocketNP, 'Thrust', thickness=4, colorVec=Vec4(1, 0.5, 0, 1)) self.npDragForce = LineNodePath(self.rocketNP, 'Drag', thickness=4, colorVec=Vec4(1, 0, 0, 1)) self.npLiftForce = LineNodePath(self.rocketNP, 'Lift', thickness=4, colorVec=Vec4(0, 0, 1, 1)) self.rocketCSLon = self.radius**2 * math.pi self.rocketCSLat = self.length * 2 * self.radius if self.VISUALIZE is True: self.terrain = loader.loadModel("../LZGrid2.egg") self.terrain.setScale(10) self.terrain.reparentTo(self.render) self.terrain.setColor(Vec4(0.1, 0.2, 0.1, 1)) self.toggleTexture()
def __setattr__(self, name, value): if name == 'enabled': try: # try calling on_enable() on classes inheriting from Entity if value == True: self.on_enable() else: self.on_disable() except: pass if value == True: if not self.is_singleton(): self.unstash() else: if not self.is_singleton(): self.stash() if name == 'eternal': for c in self.children: c.eternal = value if name == 'world_parent': self.reparent_to(value) if name == 'model': if value is None: if hasattr(self, 'model') and self.model: self.model.removeNode() # print('removed model') object.__setattr__(self, name, value) return None if isinstance(value, NodePath): # pass procedural model if self.model is not None and value != self.model: self.model.removeNode() object.__setattr__(self, name, value) elif isinstance(value, str): # pass model asset name m = load_model(value, application.asset_folder) if not m: m = load_model( value, application.internal_models_compressed_folder) if m: if self.model is not None: self.model.removeNode() object.__setattr__(self, name, m) if isinstance(m, Mesh): m.recipe = value # print('loaded model successively') else: print('missing model:', value) return if self.model: self.model.reparentTo(self) self.model.setTransparency(TransparencyAttrib.M_dual) self.color = self.color # reapply color after changing model self.texture = self.texture # reapply texture after changing model self._vert_cache = None if isinstance(value, Mesh): if hasattr(value, 'on_assign'): value.on_assign(assigned_to=self) return if name == 'color' and value is not None: if not isinstance(value, Vec4): value = Vec4(value[0], value[1], value[2], value[3]) if self.model: self.model.setColorScaleOff( ) # prevent inheriting color from parent self.model.setColorScale(value) object.__setattr__(self, name, value) if name == 'texture_scale': if self.model and self.texture: self.model.setTexScale(TextureStage.getDefault(), value[0], value[1]) if name == 'texture_offset': if self.model and self.texture: self.model.setTexOffset(TextureStage.getDefault(), value[0], value[1]) self.texture = self.texture if name == 'collision' and hasattr(self, 'collider') and self.collider: if value: self.collider.node_path.unstash() else: self.collider.node_path.stash() object.__setattr__(self, name, value) return if name == 'render_queue': if self.model: self.model.setBin('fixed', value) if name == 'double_sided': self.setTwoSided(value) if name == 'always_on_top' and value: self.set_bin("fixed", 0) self.set_depth_write(False) self.set_depth_test(False) try: super().__setattr__(name, value) except: pass
def __init__(self): ShowBase.__init__(self) self.disableMouse() properties = WindowProperties() properties.setSize(1000, 750) self.win.requestProperties(properties) mainLight = DirectionalLight("main light") self.mainLightNodePath = render.attachNewNode(mainLight) self.mainLightNodePath.setHpr(45, -45, 0) render.setLight(self.mainLightNodePath) ambientLight = AmbientLight("ambient light") ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) self.ambientLightNodePath = render.attachNewNode(ambientLight) render.setLight(self.ambientLightNodePath) render.setShaderAuto() self.environment = loader.loadModel("Models/Misc/environment") self.environment.reparentTo(render) self.camera.setPos(0, 0, 32) self.camera.setP(-90) self.keyMap = { "up": False, "down": False, "left": False, "right": False, "shoot": False } self.accept("w", self.updateKeyMap, ["up", True]) self.accept("w-up", self.updateKeyMap, ["up", False]) self.accept("s", self.updateKeyMap, ["down", True]) self.accept("s-up", self.updateKeyMap, ["down", False]) self.accept("a", self.updateKeyMap, ["left", True]) self.accept("a-up", self.updateKeyMap, ["left", False]) self.accept("d", self.updateKeyMap, ["right", True]) self.accept("d-up", self.updateKeyMap, ["right", False]) self.accept("mouse1", self.updateKeyMap, ["shoot", True]) self.accept("mouse1-up", self.updateKeyMap, ["shoot", False]) self.pusher = CollisionHandlerPusher() self.cTrav = CollisionTraverser() self.pusher.setHorizontal(True) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(8.0) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(-8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(-8.0) self.updateTask = taskMgr.add(self.update, "update") self.player = Player() self.tempEnemy = WalkingEnemy(Vec3(5, 0, 0))
def rgbPanel(nodePath, callback=None, style='mini'): def onRelease(r, g, b, a, nodePath=nodePath): messenger.send('RGBPanel_setColor', [nodePath, r, g, b, a]) def popupColorPicker(): # Can pass in current color with: color = (255, 0, 0) color = askcolor( parent=vgp.interior(), # Initialize it to current color initialcolor=tuple(vgp.get()[:3]))[0] if color: vgp.set((color[0], color[1], color[2], vgp.getAt(3))) def printToLog(): c = nodePath.getColor() print("Vec4(%.3f, %.3f, %.3f, %.3f)" % (c[0], c[1], c[2], c[3])) # Check init color if nodePath.hasColor(): initColor = nodePath.getColor() * 255.0 else: initColor = Vec4(255) # Create entry scale group vgp = ValuatorGroupPanel( title='RGBA Panel: ' + nodePath.getName(), dim=4, labels=['R', 'G', 'B', 'A'], value=[ int(initColor[0]), int(initColor[1]), int(initColor[2]), int(initColor[3]) ], type='slider', valuator_style=style, valuator_min=0, valuator_max=255, valuator_resolution=1, # Destroy not withdraw panel on dismiss fDestroy=1) # Update menu button vgp.component('menubar').component('Valuator Group-button')['text'] = ( 'RGBA Panel') # Set callback vgp['postCallback'] = onRelease # Add a print button which will also serve as a color tile pButton = Button(vgp.interior(), text='Print to Log', bg=getTkColorString(initColor), command=printToLog) pButton.pack(expand=1, fill=BOTH) # Update menu menubar = vgp.component('menubar') menubar.deletemenuitems('Valuator Group', 1, 1) # Some helper functions # Clear color menubar.addmenuitem('Valuator Group', 'command', label='Clear Color', command=lambda: nodePath.clearColor()) # Set Clear Transparency menubar.addmenuitem('Valuator Group', 'command', label='Set Transparency', command=lambda: nodePath.setTransparency(1)) menubar.addmenuitem('Valuator Group', 'command', label='Clear Transparency', command=lambda: nodePath.clearTransparency()) # System color picker menubar.addmenuitem('Valuator Group', 'command', label='Popup Color Picker', command=popupColorPicker) menubar.addmenuitem('Valuator Group', 'command', label='Print to log', command=printToLog) menubar.addmenuitem('Valuator Group', 'command', 'Dismiss Valuator Group panel', label='Dismiss', command=vgp.destroy) def setNodePathColor(color): nodePath.setColor(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0, color[3] / 255.0) # Update color chip button pButton['bg'] = getTkColorString(color) # Execute callback to pass along color info if callback: callback(color) vgp['command'] = setNodePathColor return vgp