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 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 __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, _base):
self.game = _base
# Player object
self.playerObject = self.game.meotech.engine.GameObjects["player"]
# Attach the flashlight cone to the player (self, _height, _radius, _pos, _hpr)
self.flashlightConeBody = self.game.meotech.engine.factory.basePhysics.buildConeShape(10.0, 1.5,
self.playerObject.bulletBody.getPos(), self.playerObject.bulletBody.getHpr())
# Attach the flashlight model to the player
self.flashlight = loader.loadModel("game/models/flashlight")
self.flashlight.setScale(0.2)
self.flashlight.reparentTo(self.flashlightConeBody)
# Attach the light to the flashlight model
slight = Spotlight('slight')
slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
lens.setFar(25)
lens.setFov(40, 40)
slight.setLens(lens)
slight.setShadowCaster(True, 512, 512)
self.flashlightLight = render.attachNewNode(slight)
self.flashlightLight.reparentTo(self.flashlight.find("LightPos"))
render.setLight(self.flashlightLight)
self.flashlightConeBody.reparentTo(self.playerObject.bulletBody)
self.flashlightConeBody.setPos(base.cam.getPos())
def __init__(self):
loadPrcFile('config.prc')
ShowBase.__init__(self)
base.disableMouse()
self.render.setShaderAuto()
self.accept("escape", sys.exit)
# Model
model = self.loader.loadModel("twisted")
model.reparent_to(self.render)
self.model = model # For reference in the rotation task
# Light
light = Spotlight('light')
light_np = self.render.attachNewNode(light)
light_np.set_pos(25, 25, 25)
light_np.look_at(0, 0, 0)
# Model-light interaction
light.setShadowCaster(True)
light.getLens().setNearFar(1, 50)
self.render.setLight(light_np)
# Camera
self.camera.set_pos(0, -60, 30)
self.camera.look_at(0, 0, 0)
# Rotating the object
self.taskMgr.add(self.rotate_object, 'rotate object')
self.render.setAntialias(AntialiasAttrib.MMultisample)
def __create_spot_light(self,
lightId,
lightColor,
lightPos,
targetId,
shadow = True):
spotLight = Spotlight(lightId)
spotLight.setColor(lightColor)
spotLight.setLens(PerspectiveLens())
spotLight.setShadowCaster(shadow)
spotLightNP = NodePath(spotLight)
spotLightNP.setPos(lightPos)
if isinstance(targetId, list) is True:
spotLightNP.lookAt(self.__sceneMgr.get_res(targetId[0]))
else:
spotLightNP.lookAt(self.__sceneMgr.get_res(targetId))
if self.__targetMap.has_key(lightId) is False:
self.__targetMap[lightId] = []
self.__targetMap[lightId].append(targetId)
return spotLightNP
def makeSpotlight(name, color, pos, hpr):
spot = Spotlight(name + "-spotlight")
spot.setColor(color)
if metadata.USE_REAL_SHADOWS:
spot.setShadowCaster(True, 512, 512)
snp = render.attachNewNode(spot)
snp.setHpr(hpr)
snp.setPos(pos)
return snp
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 __setSpotlight(self,props): light = Spotlight(props['name']) light.setShadowCaster(props['castShadows'],2048,2048) light.setAttenuation(props['attenuation']) lens = PerspectiveLens() fov = math.degrees( props['range'].x ) lens.setFov(fov) lens.setFilmSize(5096); light.setLens(lens) return self.__createLight(light,props)
def __setSpotlight(self, props):
light = Spotlight(props['name'])
light.setShadowCaster(props['castShadows'], 2048, 2048)
light.setAttenuation(props['attenuation'])
lens = PerspectiveLens()
fov = math.degrees(props['range'].x)
lens.setFov(fov)
lens.setFilmSize(5096)
light.setLens(lens)
return self.__createLight(light, props)
def buildSubType(self):
"""Build the light with the given subType"""
if self.subType == "pointType":
# make a point light
c = self.color
pointLight = PointLight(self.name)
pointLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
pointLight.setShadowCaster(True, 512, 512)
plnp = self.renderObjectsLight.attachNewNode(pointLight)
plnp.setPos(self.position)
self.lightNP = plnp
self.setLightSwitch(True)
if self.subType == "directType":
# make a directional light
c = self.color
directLight = DirectionalLight(self.name)
directLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
directLight.setShadowCaster(True, 512, 512)
dlnp = self.renderObjectsLight.attachNewNode(directLight)
#dlnp.setHpr(0, -60, 0) # no idea why its like that.. but it works
self.lightNP = dlnp
self.setLightSwitch(True)
if self.subType == "ambientType":
# make a ambient light
c = self.color
ambientLight = AmbientLight(self.name)
ambientLight.setColor(VBase4(c[0], c[1],c[2], c[3]))
alnp = self.renderObjectsLight.attachNewNode(ambientLight)
self.lightNP = alnp
self.setLightSwitch(True)
if self.subType == "spotType":
# make a spot light
# lookAtObj = _object.getTag("lookAt") get rid of this.
c = self.color
spotLight = Spotlight(self.name)
spotLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
spotLight.setShadowCaster(True, 512, 512)
lens = PerspectiveLens()
spotLight.setLens(lens)
slnp = self.renderObjectsLight.attachNewNode(spotLight)
slnp.setPos(self.position)
slnp.setHpr(self.hpr)
# Find out if this is really the only option
# because setHpr doesnt seem to have any effect.
# lookAt would be okay but that means adding anothe type
#slnp.lookAt(self.main.GameObjects["player"].collisionBody)
self.lightNP = slnp
self.setLightSwitch(True)
def __init__(self):
"""initialise and start the Game"""
ShowBase.__init__(self)
self.accept("escape", exit)
render.setShaderAuto(True)
#
# SIMPLE LEVEL SETUP
#
self.ralph = Actor("Ralph", {
"idle": "Ralph-Idle",
"walk": "Ralph-Walk",
"run": "Ralph-Run"
})
self.ralph.loop("idle")
self.ralph.reparentTo(render)
self.ralph.setPos(0, 3, -2)
#self.ralph.setScale(10)
self.ralphIval = self.ralph.hprInterval(5.0, Vec3(-360, 0, 0))
self.ralphIval.loop()
#self.ralph.setH(-20)
self.environment = loader.loadModel("environment")
self.environment.reparentTo(render)
self.environment.setScale(0.08)
self.environment.setPos(-0.5, 15, -2)
base.trackball.node().setHpr(0, 22, 0)
#
# Lights
#
alight = AmbientLight("Ambient")
alight.setColor(VBase4(0.3, 0.3, 0.3, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
slight = Spotlight("slight")
slight.setColor(VBase4(1, 1, 1, 1))
# Use a 512x512 resolution shadow map
slight.setShadowCaster(True, 2048, 2048)
lens = PerspectiveLens()
lens.setFov(45)
slight.setLens(lens)
slnp = render.attachNewNode(slight)
slnp.setPos(5, -10, 5)
slnp.lookAt(0, 3, -2)
render.setLight(slnp)
def __init__(self):
"""initialise and start the Game"""
ShowBase.__init__(self)
self.accept("escape", exit)
render.setShaderAuto(True)
#
# SIMPLE LEVEL SETUP
#
self.ralph = Actor("Ralph",
{"idle": "Ralph-Idle",
"walk": "Ralph-Walk",
"run": "Ralph-Run"})
self.ralph.loop("idle")
self.ralph.reparentTo(render)
self.ralph.setPos(0, 3, -2)
#self.ralph.setScale(10)
self.ralphIval = self.ralph.hprInterval(5.0, Vec3(-360, 0, 0))
self.ralphIval.loop()
#self.ralph.setH(-20)
self.environment = loader.loadModel("environment")
self.environment.reparentTo(render)
self.environment.setScale(0.08)
self.environment.setPos(-0.5, 15, -2)
base.trackball.node().setHpr(0, 22, 0)
#
# Lights
#
alight = AmbientLight("Ambient")
alight.setColor(VBase4(0.3, 0.3, 0.3, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
slight = Spotlight("slight")
slight.setColor(VBase4(1, 1, 1, 1))
# Use a 512x512 resolution shadow map
slight.setShadowCaster(True, 2048, 2048)
lens = PerspectiveLens()
lens.setFov(45)
slight.setLens(lens)
slnp = render.attachNewNode(slight)
slnp.setPos(5, -10, 5)
slnp.lookAt(0, 3, -2)
render.setLight(slnp)
def __init__(self):
# Basics
ShowBase.__init__(self)
base.disableMouse()
self.render.setShaderAuto()
self.accept("escape", sys.exit)
# Model
model = self.loader.loadModel("twisted")
model.reparent_to(self.render)
self.model = model # For reference in the rotation task
# Light
light = Spotlight('light')
light_np = self.render.attachNewNode(light)
light_np.set_pos(50, 50, 50)
light_np.look_at(0, 0, 0)
# Model-light interaction
light.setShadowCaster(True)
light.getLens().setNearFar(1, 100)
self.render.setLight(light_np)
# Camera
self.camera.set_pos(0, -60, 30)
self.camera.look_at(0, 0, 0)
# Rotating the object
self.taskMgr.add(self.rotate_object, 'rotate object')
def generate(self, helperInfo):
color = self.mapObject.getPropertyValue("_light",
default=Vec4(
255, 255, 255, 255))
color = LEGlobals.colorFromRGBScalar255(color)
color = LEGlobals.vec3GammaToLinear(color)
intensity = self.mapObject.getPropertyValue("_intensity", default=1.0)
innerRadius = self.mapObject.getPropertyValue("_inner_radius",
default=1.0)
outerRadius = self.mapObject.getPropertyValue("_outer_radius",
default=2.0)
color[0] = color[0] * intensity
color[1] = color[1] * intensity
color[2] = color[2] * intensity
constant = self.mapObject.getPropertyValue("_constant_attn",
default=0.0)
linear = self.mapObject.getPropertyValue("_linear_attn", default=0.0)
quadratic = self.mapObject.getPropertyValue("_quadratic_attn",
default=1.0)
innerConeDeg = self.mapObject.getPropertyValue("_inner_cone")
innerConeRad = deg2Rad(innerConeDeg)
outerConeDeg = self.mapObject.getPropertyValue("_cone")
outerConeRad = deg2Rad(outerConeDeg)
depthBias = self.mapObject.getPropertyValue("_depth_bias")
shadowSize = self.mapObject.getPropertyValue("_shadow_map_size")
shadowCaster = self.mapObject.getPropertyValue("_shadow_caster")
softnessFactor = self.mapObject.getPropertyValue("_softness_factor")
normalOffsetScale = self.mapObject.getPropertyValue(
"_normal_offset_scale")
normalOffsetUvSpace = self.mapObject.getPropertyValue(
"_normal_offset_uv_space")
pl = Spotlight("lightHelper-light_spot")
pl.setColor(Vec4(color[0], color[1], color[2], 1.0))
pl.setFalloff(quadratic)
pl.setInnerRadius(innerRadius)
pl.setOuterRadius(outerRadius)
pl.setExponent(self.mapObject.getPropertyValue("_exponent"))
pl.setInnerCone(innerConeDeg)
pl.setOuterCone(outerConeDeg)
if shadowCaster:
pl.setCameraMask(DirectRender.ShadowCameraBitmask)
pl.setShadowCaster(True, shadowSize, shadowSize)
pl.setDepthBias(depthBias)
pl.setSoftnessFactor(softnessFactor)
pl.setNormalOffsetScale(normalOffsetScale)
pl.setNormalOffsetUvSpace(normalOffsetUvSpace)
self.light = self.mapObject.helperRoot.attachNewNode(pl)
if True: #self.mapObject.doc.numlights < 64:
self.mapObject.doc.render.setLight(self.light)
self.mapObject.doc.numlights += 1
self.hasLight = True
self.spotlightMdl = base.loader.loadModel(
"models/misc/spotlight-editor.bam")
#self.spotlightMdl.setState("materials/spotlight-editor.mat")
#state = self.spotlightMdl.getState()
#params = state.getAttrib(ShaderParamAttrib)
#params = params.setParam("selfillumtint", CKeyValues.toString(color.getXyz()))
#print(params)
#self.spotlightMdl.setState(state.setAttrib(params))
self.spotlightMdl.reparentTo(self.light)
self.spotlightMdl.setScale(0.5)
self.spotlightMdl.setH(180)
self.spotlightMdl.setLightOff(1)
self.spotlightMdl.setRenderModeWireframe(1)
self.spotlightMdl.setTextureOff(1)
self.spotlightMdl.setColor(Vec4(0, 0, 0, 1))
#self.spotlightMdl.setLightOff(self.light, 1)
#self.spotlightMdl.ls()
innerCone = getUnitCone().copyTo(self.light)
innerCone.setSy(innerRadius)
innerCone.setSx((innerConeRad / 2) * innerRadius)
innerCone.setSz((innerConeRad / 2) * innerRadius)
innerCone.setColorScale(InnerColor)
self.innerCone = innerCone
outerCone = getUnitCone().copyTo(self.light)
outerCone.setSy(outerRadius)
outerCone.setSx((outerConeRad / 2) * outerRadius)
outerCone.setSz((outerConeRad / 2) * outerRadius)
outerCone.setColorScale(OuterColor)
self.outerCone = outerCone
if not self.mapObject.selected:
innerCone.stash()
outerCone.stash()
