def __init__(self, base, USE_RP): self.base = base """ direct.showbase.ShowBase """ if not USE_RP: alight = AmbientLight('alight') alnp = self.base.render.attachNewNode(alight) alight.setColor((0.2, 0.2, 0.2, 1)) self.base.render.setLight(alnp) # Put lighting on the main scene dlight = DirectionalLight('dlight') dlnp = self.base.render.attachNewNode(dlight) dlnp.setPos(0, 5, 5) dlight.setColor((0.8, 0.8, 0.5, 1)) dlnp.setHpr(0, 60, 0) self.base.render.setLight(dlnp) plight = PointLight('plight') plnp = self.base.render.attachNewNode(plight) plnp.setPos(0, -50, 50) plnp.setHpr(0, 60, 0) self.base.render.setLight(plnp) self.sounds = {}
def setupLights(self): base.setBackgroundColor(0.0, 0.0, 0.0, 1) base.setFrameRateMeter(True) # Add a light to the scene. self.lightpivot = render.attachNewNode("lightpivot") self.lightpivot.setPos(0, 0, 5) self.lightpivot.hprInterval(10, Point3(360, 0, 0)).loop() plight = PointLight('plight') plight.setColor(Vec4(1, 0, 0, 1)) plight.setAttenuation(Vec3(0.37, 0.025, 0)) plnp = self.lightpivot.attachNewNode(plight) plnp.setPos(45, 0, 0) plnp.lookAt(*Vec3(0, 0, 0, )) # Light alight = AmbientLight('ambientLight') alight.setColor(Vec4(0.2, 0.2, 0.2, 1)) alightNP = render.attachNewNode(alight) # dlight = DirectionalLight('directionalLight') # dlight.setDirection(Vec3(1, 1, -1)) # dlight.setColor(Vec4(0.7, 0.7, 0.7, 1)) # dlightNP = render.attachNewNode(dlight) render.clearLight() render.setLight(alightNP) # render.setLight(dlightNP) render.setLight(plnp) # create a sphere to denote the light sphere = loader.loadModel("models/sphere") sphere.reparentTo(plnp) render.setShaderAuto()
def __init__(self): super().__init__() self.set_background_color(0, 0, 0, 1) self.cam.setPos(0, -20, 5) self.plane = self.loader.loadModel('my-models/planeTB') self.plane.setPos(-5, 5, 0) self.plane.reparentTo(self.render) self.sphere = self.loader.loadModel("my-models/icosphere") self.sphere.reparentTo(self.render) alight = AmbientLight('alight') alight.setColor((0.2, 0.2, 0.2, 1)) alnp = self.render.attachNewNode(alight) self.plane.setLight(alnp) plight = PointLight('plight') plight.setColor((1, 1, 1, 1)) plnp = self.sphere.attachNewNode(plight) self.plane.setLight(plnp) self.render.setShaderAuto() self.taskMgr.add(self.move_light, "move-light")
def __init__(self): ShowBase.__init__(self) # Override defaults self.disableMouse() self.setBackgroundColor(0.7, 0.7, 0.7) self.setFrameRateMeter(True) # Lights dlight = DirectionalLight("dlight") dlnp = self.render.attachNewNode(dlight) dlnp.setHpr(180.0, -70.0, 0) self.render.setLight(dlnp) alight = AmbientLight("alight") alnp = self.render.attachNewNode(alight) alight.setColor(VBase4(0.4, 0.4, 0.4, 1)) self.render.setLight(alnp) # Collisions self.cTrav = CollisionTraverser("collisionTraverser") self.cTrav.showCollisions(self.render) # Camera controls self.cameraController = CameraController(self, 200, math.pi / 4.0, math.pi / 4.0) #self.cameraController = CameraController(self, 200, -math.pi, math.pi / 4.0) # Load the track self.track = self.loader.loadModel("models/trackMotegi") self.track.reparentTo(self.render) # Load the car self.car = KeyboardController(self)
def __init__(self): ShowBase.__init__(self) base.set_background_color(0.1, 0.1, 0.8, 1) base.set_frame_rate_meter(True) base.cam.set_pos(0, -40, 10) base.cam.look_at(0, 0, 0) # Light alight = AmbientLight('ambientLight') alight.set_color(LVector4(0.5, 0.5, 0.5, 1)) alightNP = render.attach_new_node(alight) dlight = DirectionalLight('directionalLight') dlight.set_direction(LVector3(5, 0, -2)) dlight.set_color(LVector4(0.7, 0.7, 0.7, 1)) dlightNP = render.attach_new_node(dlight) render.clear_light() render.set_light(alightNP) render.set_light(dlightNP) # Input self.accept('escape', self.do_exit) self.accept('r', self.do_reset) self.accept('f1', base.toggle_wireframe) self.accept('f2', base.toggle_texture) self.accept('f3', self.toggle_debug) self.accept('f5', self.do_screenshot) # Task taskMgr.add(self.update, 'updateWorld') # Physics self.setup()
class PbLightNode(): """Pybullet-compatible light node wrapper """ def __init__(self, render: NodePath): self._alight = AmbientLight('pb_alight') self._dlight = DirectionalLight('pb_dlight') self._anode = render.attach_new_node(self._alight) self._dnode = render.attach_new_node(self._dlight) self._render = render self._is_active = False self.set_active(True) def set_active(self, active: bool): if active and not self._is_active: self._render.set_light(self._anode) self._render.set_light(self._dnode) elif not active and self._is_active: self._render.clear_light(self._anode) self._render.clear_light(self._dnode) self._is_active = active def is_active(self): return self._is_active def update(self, pb_light): self._alight.set_color(Vec3(*pb_light.ambient_color)) self._dlight.set_color(Vec3(*pb_light.diffuse_color)) self._dlight.set_specular_color(Vec3(*pb_light.specular_color)) self._dlight.set_shadow_caster(pb_light.shadow_caster) self._dnode.set_pos(Vec3(*pb_light.position)) self._dnode.look_at(0, 0, 0)
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.tempActor = Actor("Models/PandaChan/act_p3d_chan", {"walk": "Models/PandaChan/a_p3d_chan_run"}) self.tempActor.getChild(0).setH(180) self.tempActor.reparentTo(render) self.tempActor.loop("walk") self.camera.setPos(0, 0, 32) self.camera.setP(-90)
def __init__(self): # Base base.set_background_color(0.2, 0.2, 0.2, 1) base.set_frame_rate_meter(True) base.cam.set_pos(0, -20, 4) base.cam.look_at(0, 0, 0) # Light 1 light1 = AmbientLight('ambientLight') light1.set_color(Vec4(0.5, 0.5, 0.5, 1.0)) light1_node_path = render.attach_new_node(light1) # Light 2 light2 = DirectionalLight('directionalLight') light2.set_direction(Vec3(1, 1, -1)) light2.set_color(Vec4(0.7, 0.7, 0.7, 1)) light2_node_path = render.attach_new_node(light2) # Clear light render.clear_light() render.set_light(light1_node_path) render.set_light(light2_node_path) # Input self.accept('escape', self.exit_lab()) # Input state inputState.watchWithModifiers('forward', 'w') # Task taskMgr.add(self._update, 'updateWorld') # Physics self.setup()
def __init__(self): base.setBackgroundColor(0.1, 0.1, 0.8, 1) base.setFrameRateMeter(True) base.cam.setPos(0, -40, 10) base.cam.lookAt(0, 0, 0) # Light alight = AmbientLight('ambientLight') alight.setColor(Vec4(0.5, 0.5, 0.5, 1)) alightNP = render.attachNewNode(alight) dlight = DirectionalLight('directionalLight') dlight.setDirection(Vec3(5, 0, -2)) dlight.setColor(Vec4(0.7, 0.7, 0.7, 1)) dlightNP = render.attachNewNode(dlight) render.clearLight() render.setLight(alightNP) render.setLight(dlightNP) # Input self.accept('escape', self.doExit) self.accept('r', self.doReset) self.accept('f1', self.toggleWireframe) self.accept('f2', self.toggleTexture) self.accept('f3', self.toggleDebug) self.accept('f5', self.doScreenshot) # Task taskMgr.add(self.update, 'updateWorld') # Physics self.setup()
def __init__(self): # call superclass init (no implicit chaining) ShowBase.__init__(self) self.pnode = loader.loadModel("models/queen") self.pnode.reparentTo(render) self.pnode.setPos(0, 5, -1) self.pnode.setH(-60) self.pnode2 = loader.loadModel("models/pawn") self.pnode2.reparentTo(self.pnode) self.pnode2.setScale(0.5) self.ground = 1.2 self.pnode2.setPos(1, 0, self.ground) self.vz = 0 self.vx = 0 self.vy = 0 ############ lighting ############# alight = AmbientLight('alight') alight.setColor((.7, .3, .3, 1)) self.alnp = render.attachNewNode(alight) render.setLight(self.alnp) slight = DirectionalLight('slight') slight.setColor((1, .5, .5, 1)) slight.setDirection(LVector3(-0.8, 0, 0)) self.slnp = render.attachNewNode(slight) render.setLight(self.slnp) taskMgr.add(self.update, "update")
def __init__(self): super().__init__() self.set_background_color(0, 0, 0, 1) self.cam.setPos(0, -12, 0) self.tree = self.loader.loadModel('my-models/christmas_tree') self.tree.setPos(0, 0, -2.5) self.tree.reparentTo(self.render) self.light_model = self.loader.loadModel('models/misc/sphere') self.light_model.setScale(0.2, 0.2, 0.2) self.light_model.setPos(4, 0, 0) self.light_model.reparentTo(self.render) plight = PointLight("plight") plight.setColor((1,1,1,1)) self.plnp = self.light_model.attachNewNode(plight) # plight.setAttenuation((0, 0, 1)) self.tree.setLight(self.plnp) alight = AmbientLight("alight") alight.setColor((0.04, 0.04, 0.04, 1)) alnp = self.render.attachNewNode(alight) self.tree.setLight(alnp) self.taskMgr.add(self.move_light, "move-light")
def setupLights(self): # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.3, .3, .3, 1)) directionalLight1 = DirectionalLight("directionalLight") directionalLight1.setDirection(Vec3(5, 5, -5)) directionalLight1.setColor(Vec4(1, 1, 1, 1)) directionalLight1.setSpecularColor(Vec4(1, 1, 1, 1)) directionalLight2 = DirectionalLight("directionalLight") directionalLight2.setDirection(Vec3(5, -5, -5)) directionalLight2.setColor(Vec4(1, 1, 1, 1)) directionalLight2.setSpecularColor(Vec4(1, 1, 1, 1)) directionalLight3 = DirectionalLight("directionalLight") directionalLight3.setDirection(Vec3(-5, -5, -5)) directionalLight3.setColor(Vec4(1, 1, 1, 1)) directionalLight3.setSpecularColor(Vec4(1, 1, 1, 1)) directionalLight4 = DirectionalLight("directionalLight") directionalLight4.setDirection(Vec3(-5, 5, -5)) directionalLight4.setColor(Vec4(1, 1, 1, 1)) directionalLight4.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight1)) render.setLight(render.attachNewNode(directionalLight2)) render.setLight(render.attachNewNode(directionalLight3)) render.setLight(render.attachNewNode(directionalLight4))
def world_setup(env, render, mydir): env.disableMouse() # Load the environment model. env.scene = env.loader.loadModel(mydir + "/models/city.egg") env.scene.reparentTo(env.render) env.scene.setScale(1, 1, 1) env.scene.setPos(0, 0, 0) # Load the skybox # env.skybox = env.loader.loadModel(mydir + "/models/skybox.egg") # env.skybox.setScale(100,100,100) # env.skybox.setPos(0,0,-500) # env.skybox.reparentTo(env.render) # Also add an ambient light and set sky color. skycol = panda3d.core.VBase3(135 / 255.0, 206 / 255.0, 235 / 255.0) env.set_background_color(skycol) alight = AmbientLight("sky") alight.set_color(panda3d.core.VBase4(skycol * 0.04, 1)) alight_path = render.attachNewNode(alight) render.set_light(alight_path) # 4 perpendicular lights (flood light) dlight1 = DirectionalLight('directionalLight') dlight1.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3)) dlight1NP = render.attachNewNode(dlight1) dlight1NP.setHpr(0,0,0) dlight2 = DirectionalLight('directionalLight') dlight2.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3)) dlight2NP = render.attachNewNode(dlight2) dlight2NP.setHpr(-90,0,0) dlight3 = DirectionalLight('directionalLight') dlight3.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3)) dlight3NP = render.attachNewNode(dlight3) dlight3NP.setHpr(-180,0,0) dlight4 = DirectionalLight('directionalLight') dlight4.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3)) dlight4NP = render.attachNewNode(dlight4) dlight4NP.setHpr(-270,0,0) render.setLight(dlight1NP) render.setLight(dlight2NP) render.setLight(dlight3NP) render.setLight(dlight4NP) # 1 directional light (Sun) dlight = DirectionalLight('directionalLight') dlight.setColor(panda3d.core.Vec4(1, 1, 1, 1)) # directional light is dim green dlight.getLens().setFilmSize(panda3d.core.Vec2(50, 50)) dlight.getLens().setNearFar(-100, 100) dlight.setShadowCaster(True, 1028*2, 1028*2) # dlight.show_frustum() dlightNP = render.attachNewNode(dlight) dlightNP.setHpr(0,-65,0) #Turning shader and lights on render.setShaderAuto() render.setLight(dlightNP)
def _init_lights(self): """Initialize scene lighting. Creates three light sources: - ambient, - directional from top (pitch=-90), - directional from bottom (pitch=90). """ # Ambient ambient_light = AmbientLight("ambient_light") ambient_light.setColor((0.3, 0.3, 0.3, 1)) self._ambient_light_np = self.render.attachNewNode(ambient_light) self.render.setLight(self._ambient_light_np) # Directional from top dir_light_top = DirectionalLight("dir_light_top") dir_light_top.setColor((1, 1, 1, 1)) self._dir_light_top_np = self.render.attachNewNode(dir_light_top) self._dir_light_top_np.setHpr(0, -90, 0) self.render.setLight(self._dir_light_top_np) # Directional from top dir_light_bot = DirectionalLight("dir_light_bot") dir_light_bot.setColor((1, 1, 1, 1)) self._dir_light_bot_np = self.render.attachNewNode(dir_light_bot) self._dir_light_bot_np.setHpr(0, 90, 0) self.render.setLight(self._dir_light_bot_np)
def __init__(self): self.hotelModel = loader.loadModel("menuBG/menuback") self.hotelModel.reparentTo(render) self.hotelModel.stash() # setup some lights plight = PointLight("mapgen_plight") plight.setColor(VBase4(0.45, 0.35, 0.35, 1)) self.plnp = self.hotelModel.attachNewNode(plight) self.plnp.setPos(-3, 3, 5) base.render.setLight(self.plnp) # setup a default ambient light alight = AmbientLight("mapgen_alight") alight.setColor(VBase4(0.20, 0.20, 0.28, 1)) self.alnp = self.hotelModel.attachNewNode(alight) base.render.setLight(self.alnp) sun = DirectionalLight('sun') sun.setColor(VBase4(0.8, 0.8, 0.8, 1)) lens = PerspectiveLens() lens.setFar(50) lens.setFov(80, 80) sun.setLens(lens) ms = 1024 #graphicMgr.shadowMapSize sun.setShadowCaster(True, ms, ms) self.sunnp = self.hotelModel.attachNewNode(sun) self.sunnp.setHpr(85, -50, 0) self.sunnp.setPos(12, 0, 10) base.render.setLight(self.sunnp)
def SetupLights(self): # Create Ambient Light ambientLight = AmbientLight('ambientLight') ambientLight.setColor((0.2, 0.2, 0.2, 1)) self.ambLight = self.render.attachNewNode(ambientLight) self.render.setLight(self.ambLight) # Directional light 01 directionalLight1 = DirectionalLight('directionalLight') directionalLight1.setColor((1, 1, 1, 1)) self.dirLight1 = self.render.attachNewNode(directionalLight1) # This light is facing backwards, towards the camera. self.dirLight1.setHpr(40, -40, 0) self.render.setLight(self.dirLight1) directionalLight2 = DirectionalLight('directionalLight') directionalLight2.setColor((0.9, 0.9, 0.9, 1)) self.dirLight2 = self.render.attachNewNode(directionalLight2) # This light is facing backwards, towards the camera. self.dirLight2.setHpr(180+40, 30, 0) self.render.setLight(self.dirLight2) self.render.setAntialias(AntialiasAttrib.MLine) self.render.setAttrib(TransparencyAttrib.make(TransparencyAttrib.M_dual))
def __init__(self): ShowBase.__init__(self) self.cap = cv2.VideoCapture(0) self.classifier = cv2.CascadeClassifier(self.haar) self.scene = self.loader.loadModel('models/abstractroom') self.scene.reparentTo(self.render) self.scene.setPos(-10, 100, 0) self.shaderenable = 1 self.scene.setShaderAuto() # Add ambient light alight = AmbientLight('alight') alight.setColor((0.1, 0.11, 0.11, 1)) alnp = self.render.attachNewNode(alight) self.scene.setLight(alnp) # Add point light. plight = PointLight('plight') plight.setColor((1, 1, 1, 1)) plight.setAttenuation(LVector3(0.1, 0.02, 0)) plnp = self.render.attachNewNode(plight) plnp.setPos(-27, 100, 0) self.scene.setLight(plnp) # Create a sphere to denote the light sphere = self.loader.loadModel("models/icosphere") sphere.reparentTo(plnp) self.taskMgr.add(self.display, 'Display') print("%.1f, %.1f, %.1f" % (self.x, self.y, self.z))
def __init__(self): base.setBackgroundColor(0.1, 0.1, 0.8, 1) base.setFrameRateMeter(True) base.cam.setPos(0, -60, 20) base.cam.lookAt(0, 0, 0) # Light alight = AmbientLight('ambientLight') alight.setColor(Vec4(0.5, 0.5, 0.5, 1)) alightNP = render.attachNewNode(alight) dlight = DirectionalLight('directionalLight') dlight.setDirection(Vec3(1, 1, -1)) dlight.setColor(Vec4(0.7, 0.7, 0.7, 1)) dlightNP = render.attachNewNode(dlight) render.clearLight() render.setLight(alightNP) render.setLight(dlightNP) # Input self.accept('escape', self.doExit) self.accept('r', self.doReset) self.accept('f1', self.toggleWireframe) self.accept('f2', self.toggleTexture) self.accept('f3', self.toggleDebug) self.accept('f5', self.doScreenshot) # Task taskMgr.add(self.update, 'updateWorld') # Physics self.setup()
def __init__(self, render, loader, location, sizeX, sizeY): self.water = loader.loadModel( 'assets/environment/arctic/nature/water.bam') self.water.setPos(location) self.water.setSx(sizeX) self.water.setSy(sizeY) self.newTS = TextureStage('ts') self.normal_TS = TextureStage('normal') self.normal_TS.setMode(TextureStage.MNormal) self.water.setTexture( self.newTS, loader.loadTexture( 'assets/environment/arctic/nature/textures/water_colormap.jpg') ) self.water.setTexScale(self.newTS, 80) self.water.setTexture( self.normal_TS, loader.loadTexture( 'assets/environment/arctic/nature/textures/water_normalmap.jpg' )) self.water.setTexScale(self.normal_TS, 80) self.water.setShaderAuto() ambiet = AmbientLight('ambient') ambiet.setColor((0.2, 0.2, 0.2, 1)) alight = self.water.attachNewNode(ambiet) self.water.setLight(alight) self.water.reparentTo(render) self.skybox = loader.loadModel( "assets/environment/arctic/nature/skybox.bam") self.skybox.setPos(location) self.skybox.setScale(2000)
def setup_world_lightning(self): """ Sets up the ambient and specular lighting of the world :return: """ ambientLight = AmbientLight("ambientLight") ambientLight.setColor((2, 2, 2, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setShadowCaster(True) directionalLight.setDirection(LVector3(-1, -1, -1)) directionalLight.setColor((.5, .5, .5, 1)) dir_light_node = self.render.attachNewNode(directionalLight) # dir_light_node.setPos(10, 2, 7) # dir_light_node.lookAt(2, 2, 0) self.render.setLight(dir_light_node) self.render.setLight(self.render.attachNewNode(ambientLight)) spot = Spotlight("Spot") spot.setColorTemperature(9000) spot.setColor(LVector3(1, 1, 1)) light = self.render.attachNewNode(spot) light.node().setScene(self.render) light.node().setShadowCaster(True) # light.node().showFrustum() light.node().getLens().setFov(40) light.node().getLens().setNearFar(2, 100) # light.setPos(10, 2, 7) light.setPos(10, 20, 20) light.lookAt(2, 2, 0) self.render.setLight(light)
def initialize_lighting(self): ambientLight_color = Vec4(0.5, 0.5, 0.5, 1) sunLight_color = Vec4(0.5, 0.5, 0.5, 1) backLight_color = Vec4(0.22, 0.44, 0.44, 1) if self.timeOfDay == "morning": ambientLight_color = Vec4(0.56, 0.52, 0.62, 1) sunLight_color = Vec4(0.86, 0.75, 0.63, 1) # Create Ambient Light ambientLight = AmbientLight('ambientLight') ambientLight.setColor(ambientLight_color) ambientLightNP = render.attachNewNode(ambientLight) render.setLight(ambientLightNP) #Create Directional Light sunLight = DirectionalLight('sunLight') sunLight.setColor(sunLight_color) sunLightNP = render.attachNewNode(sunLight) sunLightNP.setHpr(180, -20, 0) render.setLight(sunLightNP) #Create Directional Light backLight = DirectionalLight('backLight') backLight.setColor(backLight_color) backLightNP = render.attachNewNode(backLight) backLightNP.setHpr(-180, 160, 0) render.setLight(backLightNP)
def __init__(self): self.setAI() self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0} base.win.setClearColor(Vec4(0, 0, 0, 1)) # the menu self.loadAudio() self.showMenu() # keyboard and mouse events self.accept("escape", sys.exit) self.accept("w", self.setKey, ["forward", 1]) self.accept("a", self.setKey, ["left", 1]) self.accept("s", self.setKey, ["backward", 1]) self.accept("d", self.setKey, ["right", 1]) self.accept("w-up", self.setKey, ["forward", 0]) self.accept("a-up", self.setKey, ["left", 0]) self.accept("s-up", self.setKey, ["backward", 0]) self.accept("d-up", self.setKey, ["right", 0]) self.accept("arrow_left", self.setKey, ["cam-left", 1]) self.accept("arrow_left-up", self.setKey, ["cam-left", 0]) self.accept("arrow_right", self.setKey, ["cam-right", 1]) self.accept("arrow_right-up", self.setKey, ["cam-right", 0]) # create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(0.3, 0.3, 0.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))
def addLight(self): self.render.clearLight() self.lightCenter = self.render.attachNewNode(PandaNode("center")) #self.lightCenter.setCompass() # ambient light self.ambientLight = AmbientLight('ambientLight') self.ambientLight.setColor(Vec4(0.5, 0.5, 0.5, 1)) self.alight = self.lightCenter.attachNewNode(self.ambientLight) self.render.setLight(self.alight) # point light self.pointlight = PointLight("pLight") self.light = self.lightCenter.attachNewNode(self.pointlight) self.pointlight.setColor(Vec4(0.8, 0.8, 0.8, 1)) self.light.setPos(0, 0, 2) self.render.setLight(self.light) # directional light self.dirlight = DirectionalLight("dLight") self.dlight = self.lightCenter.attachNewNode(self.dirlight) self.dirlight.setColor(Vec4(0.8, 0.8, 0.8, 1)) self.dirlight.setShadowCaster(True) self.dlight.setPos(0, 0, 5) self.dlight.lookAt(5, 10, 0) self.render.setLight(self.dlight) self.render.setShaderAuto()
def load_scene(self): self.scene_model = self.loader.loadModel("models/scene.egg") self.scene_model.reparentTo(self.render) self.alight = AmbientLight('alight') self.alight.setColor(VBase4(0.1, 0.1, 0.1, 1)) self.alnp = self.render.attachNewNode(self.alight) self.render.setLight(self.alnp) self.dlight = DirectionalLight('dlight') self.dlight.setColor(VBase4(0.5, 0.5, 0.5, 0.5)) self.dlnp = self.render.attachNewNode(self.dlight) self.dlnp.setHpr(0, -60, 0) self.render.setLight(self.dlnp) self.plights = [] for position in [ [0, 0, 20], # [10, 10, 20], # [-10, 10, 20], # [-10, -10, 20], [10, -10, 20], ]: plight = PointLight('plight_{}'.format(position)) plight.setColor(VBase4(0.4, 0.4, 0.4, 1)) plnp = self.render.attachNewNode(plight) plnp.setPos(*position) self.render.setLight(plnp) self.plights.append(plight) # self.camera.setPos(0, -20, 3) self.trackball.node().setPos(0, 20, -3)
def initLights(self): torches = self.level.findAllMatches("**/TorchTop*") self.lights = [] for torch in torches: tLight = PointLight(torch.getName()) tLight.setColor((.4, .2, .0, 1)) tlnp = render.attachNewNode(tLight) tlnp.setPos(torch.getPos(render)) render.setLight(tlnp) self.lights.append(tlnp) windows = self.level.findAllMatches("**/Window*") plates = self.level.findAllMatches("**/Plate*") spikes = self.level.findAllMatches("**/Spikes*") for window in windows: wLight = Spotlight(window.getName()) lens = PerspectiveLens() wLight.setLens(lens) wLight.setColor((0.5, 0.4, 0.5, 1)) wlnp = render.attachNewNode(wLight) wlnp.setPos(window.getPos(render)) wlnp.lookAt((0, window.getY(), 0)) for plate in plates: plate.setLight(wlnp) self.lights.append(wlnp) ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.1, .1, .025, 1)) render.setLight(render.attachNewNode(ambientLight))
def begin(self): base.setBackgroundColor( self.environment['colourBackground'] ) alight = AmbientLight('AmbientLight') alight.setColor(self.environment['colourAmbient'] ) alnp = self.sceneNode.attachNewNode(alight) self.sceneNode.setLight(alnp) if self.environment['fog']: fog = Fog( 'sceneName' ) fog.setColor( self.environment['fog']['color'] ) if self.environment['fog']['mode'] == "linear": fog.setLinearRange(self.environment['fog']['linearStart']*1000,self.environment['fog']['linearEnd']*1000) else: fog.setExpDensity( self.environment['fog']['expDensity'] ) self.sceneNode.setFog(fog) [self.createNode(props) for props in self.nodes] [self.createLight(props) for props in self.lights] [self.createCamera(props) for props in self.cameras] [self.createEntity(props) for props in self.entities] # [self.createStaticGeoms(props) for props in self.staticGeoms] self.sceneNode.clearModelNodes() self.sceneNode.flattenStrong() self.sceneNode.setShaderAuto()
def initialize_lighting(self): ambientLight_color = Vec4(0.5,0.5,0.5,1) sunLight_color = Vec4(0.5,0.5,0.5,1) backLight_color = Vec4(0.22,0.44,0.44,1) if self.timeOfDay == "morning": ambientLight_color = Vec4(0.56,0.52,0.62,1) sunLight_color = Vec4(0.86,0.75,0.63,1) # Create Ambient Light ambientLight = AmbientLight('ambientLight') ambientLight.setColor(ambientLight_color) ambientLightNP = render.attachNewNode(ambientLight) render.setLight(ambientLightNP) #Create Directional Light sunLight = DirectionalLight('sunLight') sunLight.setColor(sunLight_color) sunLightNP = render.attachNewNode(sunLight) sunLightNP.setHpr(180,-20,0) render.setLight(sunLightNP) #Create Directional Light backLight = DirectionalLight('backLight') backLight.setColor(backLight_color) backLightNP = render.attachNewNode(backLight) backLightNP.setHpr(-180,160,0) render.setLight(backLightNP)
def __init__(self): ShowBase.__init__(self) props = WindowProperties( ) props.setTitle( 'Differentiable Physics Engine' ) self.win.requestProperties( props ) self.t = 0 self.starttime = time.time() #self.setFrameRateMeter(True) cour = self.loader.loadFont('cmtt12.egg') self.textObject = OnscreenText(font= cour, text = 'abcdefghijklmnopqrstuvwxyz', pos=(0, -0.045), parent = self.a2dTopCenter, bg=(0,0,0,1), fg =(1,1,1,1), scale = 0.07, mayChange=True) cm = CardMaker("ground") cm.setFrame(-2000, 2000, -2000, 2000) cm.setUvRange(Point2(-2000/5,-2000/5),Point2(2000/5,2000/5)) tmp = self.render.attachNewNode(cm.generate()) tmp.reparentTo(self.render) tmp.setPos(0, 0, 0) tmp.lookAt((0, 0, -2)) tmp.setColor(1.0,1.0,1.0,1) tmp.setTexScale(TextureStage.getDefault(), 1, 1) tex = self.loader.loadTexture('textures/grid2.png') tex.setWrapU(Texture.WMRepeat) tex.setWrapV(Texture.WMRepeat) tmp.setTexture(tex,1) self.setBackgroundColor(0.0, 191.0/255.0, 1.0, 1.0) #color of the sky ambientLight = AmbientLight('ambientLight') ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) ambientLightNP = self.render.attachNewNode(ambientLight) self.render.setLight(ambientLightNP) # Directional light 01 directionalLight = DirectionalLight('directionalLight') directionalLight.setColor(Vec4(0.8, 0.8, 0.8, 1)) directionalLightNP = self.render.attachNewNode(directionalLight) # This light is facing backwards, towards the camera. directionalLightNP.setHpr(-60, -50, 0) directionalLightNP.node().setScene(self.render) directionalLightNP.node().setShadowCaster(True) directionalLightNP.node().getLens().setFov(40) directionalLightNP.node().getLens().setNearFar(10, 100) self.render.setLight(directionalLightNP) # Add the spinCameraTask procedure to the task manager. self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") # Load the environment model. self.objects = dict() self.names = [] data = pickle.load(open("../PhysXVids/state-dump-exp15.pkl","rb")) self.json = json.loads(data["json"]) # json.loads(data["json"]) self.states = data["states"] self.load_robot_model() self.dt = self.json["integration_parameters"]["time_step"] self.setupKeys() self.robot_id = 0
def set_lights(self): """Set up the lights.""" light_nodes = [None] * 9 for i, dirs in zip(range(9), [0] + Object.values(directions) * 2): dlight = DirectionalLight(f"directional light {i}") if i <= 4: dlight.setColor((0.5, 0.5, 0.5, 0.8)) else: dlight.setColor((2, 2, 2, 2)) light_nodes[i] = self.base.render.attachNewNode(dlight) if i == 0: light_nodes[i].setPos(0, 0, 1) else: light_nodes[i].setPos(*dirs, 0) light_nodes[i].lookAt(0, 0, 0) if i <= 4: self.base.render.setLight(light_nodes[i]) self.terrain.terrain_node.clearLight(light_nodes[i]) else: # self.terrain.terrain_node.setLight(light_nodes[i]) pass alight = AmbientLight('ambient light') alight.setColor((0.3, 0.3, 0.3, 1)) ambient_light_node = self.base.render.attachNewNode(alight) self.base.render.setLight(ambient_light_node) return light_nodes, ambient_light_node
def __init__(self): super().__init__() self.controller = inputs.devices.gamepads[0] self.cur_track_segment = 0 track_f = open("track.json") track_data = json.load(track_f) track_f.close() self.track = track.Track(track_data, world) self.car = car.Car(base, world, self.track) dlight = DirectionalLight('dlight') dlnp = render.attachNewNode(dlight) dlnp.setHpr(0, -80, 0) render.setLight(dlnp) alight = AmbientLight('alight') alight.setColor(Vec4(0.2, 0.2, 0.2, 1)) alnp = render.attachNewNode(alight) render.setLight(alnp) myFog = Fog("Fog") myFog.setColor(0.2, 0.2, 0.2) myFog.setExpDensity(0.005) render.setFog(myFog) taskMgr.add(self.update, 'update') self.controller_t = threading.Thread(target=self.controller_tf, daemon=True) self.controller_t.start()
def attachLights(render): dl = DirectionalLight('dirLight') dl.setColor(ColorToVec4('666060')) dlNP = render.attachNewNode(dl) dlNP.setHpr(0, -45, 0) render.setLight(dlNP) dl = DirectionalLight('dirLight') dl.setColor(ColorToVec4('606666')) dlNP = render.attachNewNode(dl) dlNP.setHpr(180, 45, 0) render.setLight(dlNP) dl = DirectionalLight('dirLight') dl.setColor(ColorToVec4('606060')) dlNP = render.attachNewNode(dl) dlNP.setHpr(90, -45, 0) render.setLight(dlNP) dl = DirectionalLight('dirLight') dl.setColor(ColorToVec4('626262')) dlNP = render.attachNewNode(dl) dlNP.setHpr(-90, 45, 0) render.setLight(dlNP) ambientLight = AmbientLight('ambientLight') ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) ambientLightNP = render.attachNewNode(ambientLight) render.setLight(ambientLightNP)
def __init__(self): ShowBase.__init__(self) ambLight = AmbientLight("ambient") ambLight.setColor(Vec4(0.1,0.11,0.12,1.0)) ambNode = render.attachNewNode(ambLight) render.setLight(ambNode) dirLight = DirectionalLight("directional") dirLight.setColor(Vec4(0.7,0.7,0.68,1.0)) dirNode = render.attachNewNode(dirLight) dirNode.setHpr(60,-40,90) render.setLight(dirNode) sptLight = Spotlight("spot") sptLens = PerspectiveLens() sptLight.setLens(sptLens) sptLight.setColor(Vec4(0.6,0.6,0.6,1.0)) sptLight.setShadowCaster(True) sptNode = render.attachNewNode(sptLight) sptNode.setPos(0,0,20) sptNode.lookAt(0,0,0) render.setLight(sptNode) render.setShaderAuto() base.camLens.setFov(70) base.camLens.setNear(0.1) base.camLens.setFar(50) self.cam.setPos(-1,-4,4) self.cam.lookAt(0,-1,1)
def __init__(self): ShowBase.__init__(self) ### vv Disable the camera trackball controls. ### vv Load the environment model. self.scene = self.loader.loadModel("models/environment") ### vv Reparent the model to render. self.scene.reparentTo(self.render) ### vv Apply scale and position transforms on the model. self.scene.setScale(0.25, 0.25, 0.25) self.scene.setPos(-8, 42, -5) self.katushka = KatushkaLovushkeraUWUControl(self) self.alight = AmbientLight('alight') self.alight.setColor(VBase4(0.2, 0.2, 0.2, 1)) self.alnp = self.render.attachNewNode(self.alight) self.render.setLight(self.alnp) ### vv Create an object responsible for all camera moves camera_controls = CameraControls(self) self.a_text = TextNode('my node') self.a_text.setText( "Every day I'm honestly trying to get better in some way.") self.a_text_node_path = self.render.attachNewNode(self.a_text)
def _set_general_lights(self, train_np): """Set initial Sun lights. Args: train_np (panda3d.core.NodePath): Train node. Returns: panda3d.core.AmbientLight: Sun ambient light. panda3d.core.DirectionalLight: Sun directional light. panda3d.core.NodePath: NodePath of the Sun. """ amb_light = AmbientLight("sun_amb") amb_light.setColor(self._color["amb"]) render.setLight(render.attachNewNode(amb_light)) # noqa: F821 lens = PerspectiveLens() lens.setNearFar(1, 100) lens.setFov(20, 20) sun_light = Spotlight("sun_dir") sun_light.setColor(self._color["dir"]) sun_light.setShadowCaster(True, 8192, 8192, sort=-2000) sun_light.setLens(lens) sun_light.setExponent(0.5) sun_light.setCameraMask(0b0001) sun_np = train_np.attachNewNode(sun_light) render.setLight(sun_np) # noqa: F821 return amb_light, sun_light, sun_np
def __init__(self, left_barrel, right_barrel, world): self.scene = world.scene self.physics = world.physics self.world = world self.left_plasma = load_model('plasma_sight.egg') self.right_plasma = load_model('plasma_sight.egg') self.left_plasma.reparent_to(left_barrel) self.right_plasma.reparent_to(right_barrel) self.left_plasma.set_r(180) self.left_plasma.find("**/sight").setColor(*SIGHTS_FRIENDLY_COLOR) self.right_plasma.find("**/sight").setColor(*SIGHTS_FRIENDLY_COLOR) # inverted colors based on colors behind sights self.left_plasma.setTransparency(TransparencyAttrib.MAlpha) self.left_plasma.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MInvSubtract, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)) self.right_plasma.setTransparency(TransparencyAttrib.MAlpha) self.right_plasma.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MInvSubtract, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)) # ambient light source for lighting sight shapes sight_light = AmbientLight('sight_light') sight_light.set_color(VBase4(1,1,1,1)) sight_lightnp = self.scene.attach_new_node(sight_light) # the following excludes the sights from z-culling (always visible) self.left_plasma.set_bin("fixed", 40) self.left_plasma.set_depth_test(False) self.left_plasma.set_depth_write(False) self.left_plasma.set_light(sight_lightnp) self.right_plasma.set_bin("fixed", 40) self.right_plasma.set_depth_test(False) self.right_plasma.set_depth_write(False) self.right_plasma.set_light(sight_lightnp)
def setupLights(self): """Setup extrnal lights""" # ambient light alight = AmbientLight('alight') alight.setColor((0.2, 0.2, 0.2, 1)) alnp = self.render.attachNewNode(alight) self.render.setLight(alnp) # directional light dlight = DirectionalLight('dlight') dlight.setColor((0.8, 0.8, 0.5, 1)) lens = PerspectiveLens() lens.setNearFar(1, 5) dlight.setLens(lens) dlight.setShadowCaster(True, args.shadow_resolution, args.shadow_resolution) dlnp = self.render.attachNewNode(dlight) dlnp.setPos(2, -2, 3) dlnp.lookAt(0, 0, 0) self.render.setLight(dlnp) # spotlight slight = Spotlight('slight') slight.setColor((0.7, 0.7, 1.0, 1)) lens = PerspectiveLens() lens.setNearFar(1, 5) slight.setLens(lens) slight.setShadowCaster(True, args.shadow_resolution, args.shadow_resolution) slnp = self.render.attachNewNode(slight) slnp.setPos(1, 1, 2) slnp.lookAt(0, 0, 0) self.render.setLight(slnp)
def createEnvironment(self): # Fog to hide a performance tweak: colour = (0.0, 0.0, 0.0) expfog = Fog("scene-wide-fog") expfog.setColor(*colour) expfog.setExpDensity(0.001) # original : 0.004 render.setFog(expfog) base.setBackgroundColor(*colour) # Our sky skydome = loader.loadModel('sky.egg') skydome.setEffect(CompassEffect.make(self.render)) skydome.setScale(self.maxdistance / 2) # bit less than "far" skydome.setZ(-65) # sink it # NOT render - you'll fly through the sky!: skydome.reparentTo(self.camera) # Our lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.6, .6, .6, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(0, -10, -10)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight))
def __init__(self): base.setBackgroundColor(0.1, 0.1, 0.8, 1) base.setFrameRateMeter(True) base.cam.setPos(0, -20, 4) base.cam.lookAt(0, 0, 0) # Light alight = AmbientLight('ambientLight') alight.setColor(Vec4(0.5, 0.5, 0.5, 1)) alightNP = render.attachNewNode(alight) dlight = DirectionalLight('directionalLight') dlight.setDirection(Vec3(1, 1, -1)) dlight.setColor(Vec4(0.7, 0.7, 0.7, 1)) dlightNP = render.attachNewNode(dlight) render.clearLight() render.setLight(alightNP) render.setLight(dlightNP) # Input self.accept('escape', self.doExit) self.accept('r', self.doReset) self.accept('f1', self.toggleWireframe) self.accept('f2', self.toggleTexture) self.accept('f3', self.toggleDebug) self.accept('f5', self.doScreenshot) self.accept('1', self.doSelect, [ 0, ]) self.accept('2', self.doSelect, [ 1, ]) self.accept('3', self.doSelect, [ 2, ]) self.accept('4', self.doSelect, [ 3, ]) self.accept('5', self.doSelect, [ 4, ]) self.accept('6', self.doSelect, [ 5, ]) inputState.watchWithModifiers('forward', 'w') inputState.watchWithModifiers('left', 'a') inputState.watchWithModifiers('reverse', 's') inputState.watchWithModifiers('right', 'd') inputState.watchWithModifiers('turnLeft', 'q') inputState.watchWithModifiers('turnRight', 'e') # Task taskMgr.add(self.update, 'updateWorld') # Physics self.setup()
def setupLights(self): ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.8, .8, .75, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(LVector3(0, 0, -2.5)) directionalLight.setColor((0.9, 0.8, 0.9, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight))
def setupLights(self): #This function sets up some default lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.8, .8, .8, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(0, 45, -45)) directionalLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(ambientLight))
def setupLight(self): ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.8, .8, .8, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(LVector3(0, 45, -45)) directionalLight.setColor((0.2, 0.2, 0.2, 1)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(ambientLight))
def loadSimpleLighting(self): ambientLight = AmbientLight( "ambientLight" ) ambientLight.setColor( Vec4(.8, .8, .8, 1) ) directionalLight = DirectionalLight( "directionalLight" ) directionalLight.setDirection( Vec3( 0, 45, -45 ) ) directionalLight.setColor( Vec4( 0.2, 0.2, 0.2, 0.6 ) ) render.setLight(render.attachNewNode( directionalLight ) ) render.setLight(render.attachNewNode( ambientLight ) )
def setupLights(self): # Sets up some default lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.4, .4, .35, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(LVector3(0, 8, -2.5)) directionalLight.setColor((0.9, 0.8, 0.9, 1)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(ambientLight))
def initLights(self): # Create some lighting #self.environ.ls() #print(self.environ.findAllMatches("**/Spot")) ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(0.8, 0.8, 0.8, 0.65)) """ directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-10, -10, 5)) directionalLight.showFrustum() directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) dirnp = render.attachNewNode(directionalLight) dirnp.setPos(10, 0, 6) """ plight1 = PointLight('plight1') plight1.setColor(VBase4(1, 1, 1, 1)) plight1.showFrustum() #plight1.setShadowCaster(True) plnp1 = render.attachNewNode(plight1) plnp1.setPos(26.71, -33.2, 26) plight2 = PointLight('plight2') plight2.setColor(VBase4(1, 1, 1, 1)) plight2.showFrustum() plnp2 = render.attachNewNode(plight2) plnp2.setPos(-25, 25, 25) slight = Spotlight('slight') slight.setColor(VBase4(1, 1, 1, 1)) lens = PerspectiveLens() lens.setFilmSize(1, 1) # Or whatever is appropriate for your scene slight.setLens(lens) slight.setShadowCaster(True, 512, 512) slight.showFrustum() slnp = render.attachNewNode(slight) slnp.setPos(0, 0, 100) slnp.lookAt(Vec3(0,0,0)) render.setLight(slnp) render.setLight(plnp1) render.setLight(plnp2) #render.setLight(render.attachNewNode(ambientLight)) #render.setLight(dirnp) render.setShaderAuto() #render.setLight(render.attachNewNode(directionalLight)) """
def __init__(self): base.disableMouse() base.cam.node().getLens().setNear(10.0) base.cam.node().getLens().setFar(9999999) camera.setPos(0, -50, 0) # Check video card capabilities. if (base.win.getGsg().getSupportsBasicShaders() == 0): addTitle("Toon Shader: Video driver reports that shaders are not supported.") return # Enable a 'light ramp' - this discretizes the lighting, # which is half of what makes a model look like a cartoon. # Light ramps only work if shader generation is enabled, # so we call 'setShaderAuto'. tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.4)) tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) # Use class 'CommonFilters' to enable a cartoon inking filter. # This can fail if the video card is not powerful enough, if so, # display an error and exit. self.separation = 1 # Pixels self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setCartoonInk(separation=self.separation) if (filterok == False): addTitle("Toon Shader: Video card not powerful enough to do image postprocessing") return # Create a non-attenuating point light and an ambient light. plightnode = PointLight("point light") plightnode.setAttenuation(Vec3(1,0,0)) plight = render.attachNewNode(plightnode) plight.setPos(30,-50,0) alightnode = AmbientLight("ambient light") alightnode.setColor(Vec4(0.8,0.8,0.8,1)) alight = render.attachNewNode(alightnode) render.setLight(alight) render.setLight(plight) # Panda contains a built-in viewer that lets you view the # results of all render-to-texture operations. This lets you # see what class CommonFilters is doing behind the scenes. self.accept("v", base.bufferViewer.toggleEnable) self.accept("V", base.bufferViewer.toggleEnable) base.bufferViewer.setPosition("llcorner") self.accept("s", self.filters.manager.resizeBuffers) # These allow you to change cartooning parameters in realtime self.accept("escape", sys.exit, [0])
def setup_lights(self): ambientLight = AmbientLight('ambient') ambientLight.setColor( Vec4( .5, .5, .5, 1 ) ) render.setLight(render.attachNewNode(ambientLight)) directionalLight = DirectionalLight('directional') directionalLight.setDirection( Vec3( -10, 10, -25 ) ) directionalLight.setColor( Vec4( .1, .1, .1, 1 ) ) render.setLight(render.attachNewNode(directionalLight))
def setupLights(self): ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.4, .4, .35, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3( 0, 8, -2.5 ) ) directionalLight.setColor(Vec4( 0.9, 0.8, 0.9, 1 ) ) #Set lighting on teapot so spark doesn't get affected self.t.setLight(self.t.attachNewNode(directionalLight)) self.t.setLight(self.t.attachNewNode(ambientLight))
def light(self): 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))
def __init__(self): __builtin__.main = self self.taskMgr = taskMgr self.base = base # Connect to the server self.cManager = ConnectionManager() self.startConnection() self.characters = dict() self.cpList = dict() base.win.setClearColor(Vec4(0,0,0,1)) self.environ = loader.loadModel("models/world") self.environ.reparentTo(render) self.environ.setPos(0,0,0) self.ralphStartPos = self.environ.find("**/start_point").getPos() # 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) self.accept("escape", sys.exit) # Login as 'CPHandler' # Temporary workaround, can add a seperate request/response for client/NPC client logins later self.name = "CPHandler" factionId = 0 self.cManager.sendRequest(Constants.CMSG_AUTH, [self.name, factionId]) # Create two control points cp1 = ControlPoint(1, -107.575, 0.6066, 0.490075, 10, RED) cp2 = ControlPoint(2, -100.575, -35.6066, 0.090075, 10, BLUE) self.cpList[1] = cp1 self.cpList[2] = cp2 taskMgr.doMethodLater(0.1, self.refresh, "heartbeat") taskMgr.doMethodLater(1, self.CPHandler, 'CPHandler') # Set up the camera base.disableMouse() #base.camera.setPos(self.character.actor.getX(),self.character.actor.getY()+10,2) # 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))
def __create_ambient_light(self, lightId, lightColor): ambientLight = AmbientLight(lightId) ambientLight.setColor(lightColor) ambientLightNP = NodePath(ambientLight) return ambientLightNP
def setupLights(self): #This is one area I know hardly anything about. I really don't know how to get this to behave nicely. #The black pieces are hardly distinguishable. ambientLight = AmbientLight( "ambientLight" ) ambientLight.setColor( Vec4(.8, .8, .8, 1) ) directionalLight = DirectionalLight( "directionalLight" ) directionalLight.setDirection( Vec3( 0, 45, -45 ) ) directionalLight.setColor( Vec4( 0.2, 0.2, 0.2, 1 ) ) render.setLight(render.attachNewNode( directionalLight ) ) render.setLight(render.attachNewNode( ambientLight ) )
def makeLights(self): alight = AmbientLight('alight') alight.setColor(VBase4(0.2,0.2,0.2,1)) alnp = render.attachNewNode(alight) render.setLight(alnp) for pl in self.settings.pointlights: lamp = PointLight('player_light') lampnp = render.attachNewNode(lamp) lampnp.setPos(*pl) render.setLight(lampnp)
def setupLights(self): ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(0.4, 0.4, 0.35, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(0, 8, -2.5)) directionalLight.setColor(Vec4(0.9, 0.8, 0.9, 1)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(directionalLight)) self.env.setLightOff()
def __init__(self, aCol, dDir, dCol): render.setAttrib(LightRampAttrib.makeHdr1()) ambientLight = AmbientLight("ambientLight") ambientLight.setColor(aCol) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(dDir) directionalLight.setColor(dCol) directionalLight.setSpecularColor(Vec4(2.0, 2.0, 2.0, 0)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight))
def createLighting(self): #creates lighting for the scene aLightVal = 0.3 dLightVal1 = -5 dLightVal2 = 5 #set up the ambient light ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1)) ambientLight1 = AmbientLight("ambientLight1") ambientLight1.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1)) ambientLight2 = AmbientLight("ambientLight2") ambientLight2.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1)) #sets a directional light directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(dLightVal1, dLightVal1, dLightVal1)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(0, 0, 0, 1)) #sets a directional light directionalLight1 = DirectionalLight("directionalLight2") directionalLight1.setDirection(Vec3(dLightVal2, dLightVal1, dLightVal1)) directionalLight1.setColor(Vec4(1, 1, 1, 1)) directionalLight1.setSpecularColor(Vec4(1, 1, 1, 1)) #attaches lights to scene render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(ambientLight1)) render.setLight(render.attachNewNode(ambientLight1)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(directionalLight1))