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):
super().__init__()
self.set_background_color(0, 0, 0, 1)
self.cam.setPos(0, -12, 0)
self.trees = NodePath("trees")
self.tree1 = self.loader.loadModel('my-models/christmas_tree')
self.tree1.setPos(0, 0, -2.5)
self.tree1.reparentTo(self.trees)
self.tree2 = self.loader.loadModel('my-models/christmas_tree')
self.tree2.setPos(4, 5, -2.5)
self.tree2.reparentTo(self.trees)
self.tree3 = self.loader.loadModel('my-models/christmas_tree')
self.tree3.setPos(-4, 7, -2.5)
self.tree3.reparentTo(self.trees)
self.trees.reparentTo(self.render)
self.floor = self.loader.loadModel('my-models/floor')
self.floor.setPos(0, 0, -2.5)
self.floor.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, -4, 0)
self.light_model.reparentTo(self.render)
plight = PointLight("plight")
plight.setShadowCaster(True, 1024, 1024)
self.render.setShaderAuto()
plnp = self.light_model.attachNewNode(plight)
# plight.setAttenuation((1, 0, 0)) # constant, linear, and quadratic.
self.trees.setLight(plnp)
alight = AmbientLight("alight")
alight.setColor((0.04, 0.04, 0.04, 1))
alnp = self.render.attachNewNode(alight)
self.trees.setLight(alnp)
self.floor.setLight(plnp)
self.floor.setLight(alnp)
filters = CommonFilters(self.win, self.cam)
filters.setBloom(size="large")
self.taskMgr.add(self.move_light, "move-light")
def __create_point_light(self,
lightId,
lightColor,
lightPos,
shadow = True):
pointLight = PointLight(lightId)
pointLight.setColor(lightColor)
pointLight.setShadowCaster(shadow)
pointLightNP = NodePath(pointLight)
pointLightNP.setPos(lightPos)
return pointLightNP
def _addDefaultLighting(self):
alight = AmbientLight('alight')
alight.setColor(VBase4(0.2, 0.2, 0.2, 1))
alnp = self.render.attachNewNode(alight)
self.render.setLight(alnp)
# NOTE: Point light following the camera
plight = PointLight('plight')
plight.setColor(VBase4(0.9, 0.9, 0.9, 1))
plnp = self.cam.attachNewNode(plight)
self.render.setLight(plnp)
if self.shadowing:
# Use a 512x512 resolution shadow map
plight.setShadowCaster(True, 512, 512)
# Enable the shader generator for the receiving nodes
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
def _addDefaultLighting(self):
alight = AmbientLight('alight')
alight.setColor(VBase4(0.2, 0.2, 0.2, 1))
alnp = self.scene.scene.attachNewNode(alight)
self.scene.scene.setLight(alnp)
for camera in self.cameras:
#NOTE: Point light following the camera
plight = PointLight('plight')
plight.setColor(VBase4(1.0, 1.0, 1.0, 1))
plnp = camera.attachNewNode(plight)
self.scene.scene.setLight(plnp)
if self.shadowing:
# Use a 512x512 resolution shadow map
plight.setShadowCaster(True, 512, 512)
# Enable the shader generator for the receiving nodes
self.scene.scene.setShaderAuto()
self.scene.scene.setAntialias(AntialiasAttrib.MAuto)
if self.modelLightsInfo is not None:
# Add model-related lights (e.g. lamps)
for model in self.scene.scene.findAllMatches('**/+ModelNode'):
modelId = model.getNetTag('model-id')
for lightNp in self.modelLightsInfo.getLightsForModel(modelId):
if self.shadowing:
# Use a 512x512 resolution shadow map
lightNp.node().setShadowCaster(True, 512, 512)
lightNp.reparentTo(model)
self.scene.scene.setLight(lightNp)
class VisualTest(ShowBase):
def __init__(self):
super().__init__(self)
self.var1 = 0
self.scene = loader.loadModel("models/world")
playerTexture = loader.loadTexture("models/starfoxShip.jpg")
self.player = self.scene.find("player")
self.player.setTexture(playerTexture)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
enemyTexture = loader.loadTexture("models/enemyShip.jpg")
self.enemy = self.scene.find("enemy1")
self.enemy.setTexture(enemyTexture)
self.basePlane = self.scene.find("basePlane")
self.scene.reparentTo(self.render)
self.player.setPos(50, 50, 3)
self.enemy.setPos(50, 55, 0)
self.ambient = AmbientLight("ambient")
self.ambient.color = (0.1, 0.1, 0.1, 1)
self.ambientPath = self.render.attachNewNode(self.ambient)
render.setLight(self.ambientPath)
self.dirLight = DirectionalLight("dir light")
self.dirLight.color = (1, 1, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(0, -90, 0)
self.dirLight.setShadowCaster(True, 512, 512)
render.setLight(self.dirLightPath)
self.pointLight = PointLight("point light")
self.pointLight.color = (1, 1, 1, 1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(50, 52.5, 4)
self.pointLight.attenuation = (.5, 0, 0)
self.pointLight.setShadowCaster(True, 1024, 1024)
self.render.setLight(self.pointLightPath)
self.fog = Fog("fog")
self.fog.setColor(0.1, 0.1, 0.1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(150, 300)
self.fog.setLinearFallback(45, 160, 320)
self.render.setFog(self.fog)
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
filters = CommonFilters(base.win, base.cam)
filters.setBloom(size="large")
filters.setAmbientOcclusion(strength=0.6, falloff=0.0005, radius=0.1)
filters.setCartoonInk(separation=2, color=(0, 0, 0, 1))
self.taskMgr.add(self.update, "update")
def update(self, evt):
self.var1 = self.var1 + 0.1
#self.dirLight.color = (self.var1,0,1,1)
#self.dirLightPath.setHpr(self.var1,-self.var1,0)
self.camera.setPos(60 + self.var1, 60 + self.var1, 20)
#self.pointLightPath.setPos(30+self.var1 ,52.5,4)
self.camera.lookAt(self.player)
return Task.cont
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)
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 = PointLight("lightHelper-light")
pl.setColor(Vec4(color[0], color[1], color[2], 1.0))
pl.setFalloff(quadratic)
pl.setInnerRadius(innerRadius)
pl.setOuterRadius(outerRadius)
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 < 128:
self.mapObject.doc.render.setLight(self.light)
self.mapObject.doc.numlights += 1
self.hasLight = True
innerSphere = getUnitCircle().copyTo(self.light)
innerSphere.setScale(innerRadius)
innerSphere.setColorScale(InnerColor)
outerSphere = getUnitCircle().copyTo(self.light)
outerSphere.setScale(outerRadius)
outerSphere.setColorScale(OuterColor)
self.innerSphere = innerSphere
self.outerSphere = outerSphere
if not self.mapObject.selected:
innerSphere.stash()
outerSphere.stash()
class VisualTest(ShowBase):
def __init__(self):
super().__init__(self)
self.scene = loader.loadModel("models/world")
self.player = self.scene.find("player")
self.basePlane = self.scene.find("basePlane")
self.player.reparentTo(self.render)
self.basePlane.reparentTo(self.render)
self.scene.remove_node()
self.taskMgr.add(self.update, "update")
self.camera.setPos(self.render, 0, -100, 70)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
self.dirLight = DirectionalLight("dir light")
self.dirLight.setShadowCaster(True, 512, 512)
self.dirLight.color = (1, 0, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(45, -60, 0)
render.setLight(self.dirLightPath)
self.angleTime = 0.0
self.totalAngleTime = 10.0
self.hAngle = 0
self.ambientLight = AmbientLight("ambient")
self.ambientLight.color = (0.1, 0.1, 0.1, 1)
self.ambLightPath = self.render.attachNewNode(self.ambientLight)
render.setLight(self.ambLightPath)
self.pointLight = PointLight("point")
self.pointLight.color = (1, 1, 1, 1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(0, 5, 5)
self.pointLight.setShadowCaster(True, 512, 512)
self.render.setLight(self.pointLightPath)
self.fog = Fog("fog")
self.fog.setColor(.1, .1, .1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(150, 200)
self.fog.setLinearFallback(45, 160, 320)
render.setFog(self.fog)
self.render.setShaderAuto()
self.p = self.render.attachNewNode("particles")
base.enableParticles()
p = ParticleEffect()
p.loadConfig('./mysmoke.ptf')
p.start(parent=self.p, renderParent=render)
self.p.setPos(self.player, 0, 0, 2)
self.font = loader.loadFont('./fonts/Magenta.ttf')
self.sceneName = DirectLabel(text="Starfox visual test",
parent=self.aspect2d,
scale=0.07,
pos=(-1.2, 0, 0.85),
text_font=self.font,
relief=None,
text_fg=(1, 1, 1, 1),
textMayChange=True,
text_align=TextNode.ALeft)
self.foxy = OnscreenImage(image='./UI/fox-icon-png-8.png',
pos=(1.2, 9, 0.85),
scale=0.1)
self.foxy.setTransparency(True)
self.controlsPanel = DirectDialog(frameSize=(-1.1, 1.1, -0.9, -0.7),
relief=DGG.FLAT)
btn = DirectButton(text="Rotate",
command=self.doRotate,
image='./UI/fox-icon-png-8.png',
pos=(-0.9, 0, -0.8),
parent=self.controlsPanel,
scale=0.07,
relief=None)
btn2 = DirectButton(text="Anin Light",
command=self.doLight,
image='./UI/fox-icon-png-8.png',
pos=(-0.7, 0, -0.8),
parent=self.controlsPanel,
scale=0.07,
relief=None)
self.camera.lookAt(self.player)
self.makeRotation = False
self.rotateAngles = 0
self.animLight = False
filter = CommonFilters(base.win, base.cam)
filter.setBloom(size="large", intensity=2)
#filter.setAmbientOcclusion(strength = 5, radius = 3)
filter.setCartoonInk(separation=4)
def doRotate(self):
self.makeRotation = True
return 0
def doLight(self):
self.animLight = True
return 0
def update(self, evt):
ang = (self.angleTime / self.totalAngleTime)
#self.camera.setPos(self.player, ang*100,ang*100,ang*100)
self.player.setPos(self.render, 0, 0, 1)
#self.camera.lookAt( Vec3(0,300,0) )
#self.p.setPos(self.player, 0,0,0,)
# self.dirLightPath.setHpr(ang*360.0 ,-60,0)
if (self.makeRotation):
self.makeRotation = False
self.rotateAngles = (self.rotateAngles + 90) % 360
self.player.setHpr(self.rotateAngles, 0, 0)
self.sceneName[
"text"] = f"Starfox visual test ({self.rotateAngles})"
self.camera.setPos(self.render, 10, 10, 10)
self.camera.lookAt(self.player)
if (ang >= 1):
self.angleTime = 0
self.angleTime = self.angleTime + globalClock.getDt()
self.dirLight.color = (ang, 0, 1, 1)
if self.animLight:
self.pointLightPath.setPos(ang * 10 - 5, ang * 10 - 5, ang * 5)
return Task.cont
def __init__(self):
ShowBase.__init__(self)
gltf.patch_loader(self.loader)
properties = WindowProperties()
properties.setSize(1000, 750)
self.disableMouse()
self.environment = loader.loadModel("environment/island.gltf")
self.environment.reparentTo(render)
self.environment.setPos(0,0,-3)
self.environment.setHpr(0,-90,0)
""" I put this becase I think there is a default light that I cant reach and manupulate.
thets why I setLightsOff first. Otherwise Ican't create or cast shadows etc. """
self.environment.setLightOff()
mats = self.environment .findAllMaterials()
mats[0].clearBaseColor()
mats[1].clearBaseColor()
mats[0].setShininess(200)
mats[1].setShininess(100)
""" In this block I create a textureBuffer and create camera
on that buffer that its display region is upper right corner of the window
I use that region to create saveScreenShot xxxx or create a numpy array out of it
(numpy_image_data)
second try is to make a screenshot directly from the buffer which is not so important
Both works though """
self.useTrackball()
# ambientLight = AmbientLight("ambient light")
# ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
# self.ambientLightNodePath = render.attachNewNode(ambientLight)
# render.setLight(self.ambientLightNodePath)
# In the body of your code
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees
mainLight.setShadowCaster(True,1000,1000)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
""" I put it here again"""
self.environment.setLight(self.mainLightNodePath)
pointLight = PointLight("point light")
pointLight.setShadowCaster(True,1000,1000)
self.pointLightNodePath = render.attachNewNode(pointLight)
self.pointLightNodePath.setPos(0,0,10)
render.setLight(self.pointLightNodePath)
""" and again """
self.environment.setLight(self.pointLightNodePath)
render.setShaderAuto()
self.tempActor2 = Actor("models/cube.bam")
self.tempActor2.reparentTo(render)
self.tempActor2.setPos(-2, 2, -1)
self.tempActor2.setScale(.2)
self.monkey = Actor("models/monkey")
self.monkey.set_scale(.25)
self.monkey.reparentTo(render)
self.monkey.set_pos(-7,-7,2)
self.monkey.lookAt(self.tempActor2)
self.monkey2 = Actor("models/monkey")
self.monkey2.set_scale(.25)
self.monkey2.reparentTo(render)
self.monkey2.set_pos(0,3,1)
self.monkey2.lookAt(self.tempActor2)
tex=Texture()
self.mybuffer = self.win.makeTextureBuffer("My Buffer", 512, 512,tex,to_ram=True)
self.mybuffer.setSort(-100)
mycamera = self.makeCamera(self.mybuffer,displayRegion=(.5,1,.5,1))
mycamera.reparentTo(self.monkey)
tex2=Texture()
mybuffer2 = self.win.makeTextureBuffer("My Buffer2", 512, 512,tex,to_ram=True)
mybuffer2.setSort(-500)
mycamera2 = self.makeCamera(mybuffer2,displayRegion=(0,.5,0,.5))
mycamera2.reparentTo(self.monkey2)
self.graphicsEngine.renderFrame()
print(self.mybuffer.getActiveDisplayRegions())
"""shadows for cameras missing here in screenshot"""
save_it=self.mybuffer.getActiveDisplayRegion(0).saveScreenshotDefault('1111')
my_output=self.mybuffer.getActiveDisplayRegion(0).getScreenshot()
numpy_image_data=np.array(my_output.getRamImageAs("RGB"), np.float32)
"""shadows for cameras missing here in screenshot"""
save_it2=mybuffer2.getActiveDisplayRegion(0).saveScreenshotDefault('2222')
my_output2=mybuffer2.getActiveDisplayRegion(0).getScreenshot()
numpy_image_data2=np.array(my_output2.getRamImageAs("RGB"), np.float32)
print(numpy_image_data)
file_name=Filename.fromOsSpecific("save_gameDat_001.png")
self.mybuffer.saveScreenshot(file_name)
print('Cameras')
print(self.camList)
print('Number Of Display Regions')
print(self.win.getNumDisplayRegions())
print('Active Display Regions')
print(self.win.getActiveDisplayRegions())
print(self.win.getDisplayRegions())
print('Number Of Display Regions')
print(self.win.getNumDisplayRegions())
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.updateTask = taskMgr.add(self.update, "update")
