Example #1
0
    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()
Example #3
0
    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")
Example #4
0
    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()
Example #6
0
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)
Example #7
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)
Example #8
0
    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()
Example #9
0
    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()
Example #10
0
	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")
Example #12
0
    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)
Example #14
0
    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)
Example #15
0
    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)
Example #16
0
    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()
Example #19
0
 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)
Example #20
0
    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 = {}
Example #21
0
    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)
Example #22
0
    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)
Example #23
0
    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))
Example #24
0
    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()
Example #25
0
    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)
Example #26
0
    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))
Example #27
0
	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()
Example #28
0
    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)
Example #29
0
    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
Example #30
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
Example #31
0
    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()
Example #32
0
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)
Example #33
0
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)
Example #34
0
    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)
Example #35
0
    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)
Example #36
0
    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
Example #37
0
    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)
Example #38
0
    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)
Example #39
0
    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))
Example #40
0
    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()
Example #41
0
 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))
Example #42
0
 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))
Example #43
0
 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 ) )
Example #45
0
 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))
Example #46
0
	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])
Example #48
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))
Example #49
0
 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))
Example #50
0
 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))
Example #51
0
    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))
Example #52
0
    def __create_ambient_light(self,
                               lightId,
                               lightColor):

        ambientLight = AmbientLight(lightId)
        ambientLight.setColor(lightColor)

        ambientLightNP = NodePath(ambientLight)

        return ambientLightNP
Example #53
0
	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 ) )
Example #54
0
 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)
Example #55
0
    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))
Example #57
0
    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))