I receive a syntax error for self. and at the same time, the Powershell shows nothing. On line 45 the self.directionalLight.setHpr(0, 0, 0) is where the error starts. This is for an assignment. I have tried redoing the indents, and spaces. I just don’t see it any where.
Thank You for any help
main.py file
from math import pi, sin, cos
from direct.showbase.ShowBase import ShowBase
from direct.task import Task
from panda3d.core import Point3
from panda3d.core import KeyboardButton
from direct.showbase.DirectObject import DirectObject
from panda_module import Panda
from panda3d.core import LVector3
from panda3d.core import NodePath
import sys
import colorsys
from panda3d.core import AmbientLight, DirectionalLight
from panda3d.core import PointLight, Spotlight
from panda3d.core import TextNode
from direct.gui.DirectSlider import DirectSlider
from direct.gui.DirectButton import DirectButton
from direct.gui.OnscreenText import OnscreenText
from panda3d.core import PerspectiveLens
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#Load the enviroment model
self.disco = loader.loadModel("models/disco_hall")
self.disco.reparentTo(self.render)
self.disco.setPosHpr(0, 50, -4, 90, 0, 0)
self.disco.setScale(1.0, 1.0, 1.0)
self.disco.setPos(0, 32, 0)
class Lights(DirectObject):
def __init__(self):
self.render = render
# Ambient Lights
self.ambientLight = render.attachNewNode(AmbientLight("ambientLight"))
self.ambientLight.node().setColor((.2, .2, .2, 1))
# Directional Light
self.directionalLight = render.attachNewNode(DirectionalLight("directionalLight"))
self.directionalLight.node().setColor((.35, .35, .35, 1))
self.directionalLight.node().setDirection((LVector3(1, 32, -30))
self.directionalLight.setHpr(0, 0, 0)
self.directionalLight.setZ(6)
dlens = self.directionalLight.node().getLens()
dlens.setFilmSize(41, 21)
dlens.setNearFar(50, 75)
# self.directionalLight.node().showFrustum()
# Now we create a spotlight. Spotlights light objects in a given cone
# They are good for simulating things like flashlights
self.spotlight = camera.attachNewNode(Spotlight("spotlight"))
self.spotlight.node().setColor((.45, .45, .45, 1))
self.spotlight.node().setSpecularColor((0, 0, 0, 1))
# The cone of a spotlight is controlled by it's lens. This creates the
# lens
self.spotlight.node().setLens(PerspectiveLens())
# This sets the Field of View (fov) of the lens, in degrees for width
# and height. The lower the numbers, the tighter the spotlight.
self.spotlight.node().getLens().setFov(16, 16)
# Attenuation controls how the light fades with distance. The three
# values represent the three attenuation constants (constant, linear,
# and quadratic) in the internal lighting equation. The higher the
# numbers the shorter the light goes.
self.spotlight.node().setAttenuation(LVector3(1, 0.0, 0.0))
# This exponent value sets how soft the edge of the spotlight is.
# 0 means a hard edge. 128 means a very soft edge.
self.spotlight.node().setExponent(128.0)
self.perPixelEnable = False
self.shadowsEnabled = False
# Point Light Colors RGB
self.redHelper = loader.loadModel('models/sphere')
self.redHelper.setColor((1, 0, 0, 1))
self.redHelper.setPos(-6.5, -3.75, 0)
self.redHelper.setScale(.25)
self.redPointLight = self.redHelper.attachNewNode(PointLight("redPointLight"))
self.redPointLight.node().setColor((.35, 0, 0, 1))
self.redPointLight.node().setAttenuation(LVector3(.1, 0.04, 0.0))
# The green point light and helper
self.greenHelper = loader.loadModel('models/sphere')
self.greenHelper.setColor((0, 1, 0, 1))
self.greenHelper.setPos(0, 7.5, 0)
self.greenHelper.setScale(.25)
self.greenPointLight = self.greenHelper.attachNewNode(PointLight("greenPointLight"))
self.greenPointLight.node().setAttenuation(LVector3(.1, .04, .0))
self.greenPointLight.node().setColor((0, .35, 0, 1))
# The blue point light and helper
self.blueHelper = loader.loadModel('models/sphere')
self.blueHelper.setColor((0, 0, 1, 1))
self.blueHelper.setPos(6.5, -3.75, 0)
self.blueHelper.setScale(.25)
self.bluePointLight = self.blueHelper.attachNewNode(PointLight("bluePointLight"))
self.bluePointLight.node().setAttenuation(LVector3(.1, 0.04, 0.0))
self.bluePointLight.node().setColor((0, 0, .35, 1))
self.bluePointLight.node().setSpecularColor((1, 1, 1, 1))
# Create a dummy node so the lights can be spun with one command
self.pointLightHelper = render.attachNewNode("pointLightHelper")
self.pointLightHelper.setPos(0, 50, 11)
self.redHelper.reparentTo(self.pointLightHelper)
self.greenHelper.reparentTo(self.pointLightHelper)
self.blueHelper.reparentTo(self.pointLightHelper)
# Store lights to scene
render.setLight(self.ambientLight)
render.setLight(self.redPointLight)
render.setLight(self.greenPointLight)
render.setLight(self.bluePointLight)
render.setLight(self.directionalLight)
# Interval to spin lights
self.pointLightsSpin = self.pointLightHelper.hprInterval(6, LVector3(360, 0, 0))
self.pointLightsSpin.loop()
self.arePointLightsSpinning = True
def adjustSpotLightExponent(self, spotlight, amount):
e = clam(self.spotlight.node().getExponent() + amount, 0, 128
spotlight.node().setExponent(e)
def addBrightness(self, light, amount):
color = light.node().getColor()
h, s, b = colorsys.rgb_to_hsv(color[0], color[1], color[2])
brightness = clamp(b + amount, 0, 1)
r, g, b = colorsys.hsv_to_rgb(h, s, brightness)
light.node().setColor((r, g, b, 1))
def togglePerPixelLighting(self):
if self.perPixelEnabled:
self.perPixelEnabled = False
render.clearShader()
else:
self.perPixelEnabled = True
render.setShaderAuto()
def toggleShadows(self):
if self.shadowsEnabled:
self.shadowsEnabled = False
self.directioanlLight.node().setShadowCaster(False)
else:
if not self.perPixelEnabled:
self.togglePerPixelLighting()
self.shadowsEnabled = True
self.directionalLight.node().setShadowCaster(True, 1024, 1024)
#UI
class UserInterface(DirectObject):
def __ini__(self):
self.lights = lights
#text Label
self.spotSliderText = OnscreenText("Spotlight Size", pos = (-.9, -.8), scale = .06, fg = (1,1,1,1), shadow = (0,0,0,1))
self.brightSliderText = OnscreenText("Directional Brightness", pos = (-.9, -.6), scale = .06, fg = (1,1,1,1), shadow = (0,0,0,1))
self.spotSlider = DirectSlider(pos = (-.9, 0, -.85), scale = .3, value = .5, command = self.setSpotFov)
self.brightSlider = DirectSlider(pos = (-.9, 0, -.65), scale = .3, value = 0, ranger = (-1, 1), pageSize = .2, command = self.setAddBrightness)
def setSpotFov(self):
self.newFov = (self.spotSlider.guiItem.getValue()*20)
self.lights.spotlight.node().getLens().setFov(self.newFov)
def setAddBrightness(self):
self.newBrightness = (self.brightSlider.guiItem.getValue()/10)
self.lights.addBrightness(self.lights.directionalLight, self.newBrightness)
#self.panda = Panda()
app = MyApp()
lights = Lights()
panda = Panda(lights)
lights.pointLightsSpin
app.run()
panda_module.py file
from math import pi, sin, cos
from direct.showbase.ShowBase import ShowBase
from direct.task import Task
from direct.actor.Actor import Actor
from direct.interval.IntervalGlobal import Sequence
from panda3d.core import Point3
from panda3d.core import KeyboardButton
from direct.showbase.DirectObject import DirectObject
from panda3d.core import CollisionTraverser, CollisionHandlerEvent, CollisionHandlerQueue
from panda3d.core import CollisionNode, CollisionSphere
from panda3d.core import NodePath
from panda3d.core import TextNode
from direct.gui.DirectSlider import DirectSlider
from direct.gui.DirectButton import DirectButton
from direct.gui.OnscreenText import OnscreenText
from panda3d.core import PerspectiveLens
class Panda(DirectObject):
def __init__(self, lights):
#variables
self.render = render
self.taskMgr = taskMgr
self.camera = camera
self.pandaForward = True
self.taskMgr.add(self.manageCameraTasks, "manageCameraTasks")
self.lights = lights
# Load and transform the panda actor.
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.reparentTo(self.render)
self.pandaActor.setPos(0, 10, 0)
# Loop its animation.
self.pandaActor.loop("walk")
#self.pandaActor.stop()
self.boxSwitch = loader.loadModel("models/box")
self.boxSwitch.reparentTo(self.render)
self.boxSwitch.setPos(-.5, 0, 0)
self.boxSwitch.setScale(1, 1, 1)
# Create the four lerp intervals needed for the panda to
# walk back and forth.
self.posInterval1 = self.pandaActor.posInterval(13,
Point3(0, -10, 0),
startPos=Point3(0, 10, 0))
self.posInterval2 = self.pandaActor.posInterval(13,
Point3(0, 10, 0),
startPos=Point3(0, -10, 0))
self.hprInterval1 = self.pandaActor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(0, 0, 0))
self.hprInterval2 = self.pandaActor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.pandaPace = Sequence(self.posInterval1, self.hprInterval1,
self.posInterval2, self.hprInterval2,
name="pandaPace")
self.pandaPace.loop()
self.keyMap = {"w": False, "s": False}
self.accept("w", self.setKey, ["w", True])
self.accept("w-up", self.setKey, ["w", False])
self.accept("s", self.setKey, ["s", True])
self.accept("s-up", self.setKey, ["s", False])
self.pandaFrame = self.pandaActor.getCurrentFrame("walk")
# Collision Node
self.pandaCN = CollisionNode("pandaCN")
self.pandaCS1 = CollisionSphere(0, -100, 250, 500)
self.pandaCN.addSolid(self.pandaCS1)
self.pandaNP = self.pandaActor.attachNewNode(self.pandaCN)
self.boxSwitchCN = CollisionNode("boxSwitchCN")
self.boxSwitchCS1 = CollisionSphere(.5, .5, .5, .75)
self.boxSwitchCN.addSolid(self.boxSwitchCS1)
self.boxSwitchNP = self.boxSwitch.attachNewNode(self.boxSwitchCN)
self.CTrav = CollisionTraverser()
#self.CHan = CollisionHandlerQueue()
self.CHan = CollisionHandlerEvent()
self.CHan.addInPattern('into-%fn')
self.CHan.addOutPattern('outof-%fn')
self.accept('into-pandaCN', self.lightSwitchOff)
self.accept('outof-pandaCN', self.lightSwitchOn)
self.CTrav.addCollider(self.pandaNP, self.CHan)
taskMgr.add(self.setupCollide, "setup collide")
## taskMgr.add(self.setupCollide, "setupCollide"
def setKey(self, key, value):
self.keyMap[key] = value
self.manageKeys()
def manageKeys(self):
if (self.keyMap["w"] == True):
self.moveForward()
elif (self.keyMap["s"] == True):
self.moveStop()
def moveForward(self):
if self.pandaForward == True:
self.pandaPace = Sequence(self.posInterval1, self.hprInterval1,
self.posInterval2, self.hprInterval2,
name="pandaPace")
if self.pandaFrame == 0:
self.pandaActor.loop("walk")
self.pandaPace.loop()
if self.pandaFrame > 0:
self.pandaForward == True
self.pandaActor.loop("walk", restart = 0)
elif self.pandaForward == False:
self.pandaActor.loop("walk", restart = 0)
self.pandaPace.resume()
self.pandaForward == True
def moveStop(self):
self.pandaForward = False
if (self.pandaPace[0]):
print("Interval-1 is", self.pandaPace[0].getT())
elif (self.pandaPace[1]):
print("Interval-2 is", self.pandaPace[1].getT())
self.pandaPace.pause()
self.pandaActor.stop()
# Define the move camera function
def manageCameraTasks(self, task):
self.spinCameraTask = base.mouseWatcherNode.isButtonDown(KeyboardButton.asciiKey('1'))
self.followCameraTask = base.mouseWatcherNode.isButtonDown(KeyboardButton.asciiKey('2'))
if self.spinCameraTask:
angleDegrees = task.time * 6.0
angleRadians = angleDegrees * (pi/180.0)
self.camera.setPos(20 * sin(angleRadians), -20 * cos(angleRadians), 3)
self.camera.setHpr(angleDegrees, 0, 0)
return Task.cont
elif self.followCameraTask:
self.camera.setPos(self.pandaActor.getPos() + (0, -20, 5))
return Task.cont
else:
self.camera.setPos(0,-10,5)
return Task.cont
def setupCollide(self, task):
self.CTrav.traverse(self.render)
#print(self.CHan.getNumEntries())
return Task.again
def lightSwitchOff(self, entry):
self.CTrav.traverse(self.render)
print('lightSwitchOff + ', entry)
self.lights.pointLightsSpin.pause()
def lightSwitchOn(self, entry):
self.CTrav.traverse(self.render)
print('lightSwitchOn + ', entry)
self.lights.pointLightsSpin.loop()
I always miss the little things like that. 
