helloworld.py

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 pandac.PandaModules import *
from pandac.PandaModules import OdeWorld, OdeSimpleSpace
from pandac.PandaModules import OdeBody, OdeMass, OdeBoxGeom, OdePlaneGeom
from pandac.PandaModules import Quat, BitMask32, CardMaker, Vec4


class MyApp(ShowBase):
    def __init__(self):
        ShowBase.__init__(self)

        self.world = OdeWorld()
        self.world.setGravity(0, 0, -9.81)


        self.world.initSurfaceTable(1)
        self.world.setSurfaceEntry(0, 0, 150, 0.0, 9.1, 0.9, 0.00001, 0.0, 0.002)

        self.space = OdeSimpleSpace()
        self.space.setAutoCollideWorld(self.world)
        self.contactGroup = OdeJointGroup()
        self.space.setAutoCollideJointGroup(self.contactGroup)

        self.timeAccumu = 0.0
        self.stepSize = 1.0 / 60.0

        self.keyMap = {'forward': 0, 'backward': 0, 'leftward': 0, 'rightward': 0}
        self.moving = False

        # Disable camera trackball controls
        self.disableMouse()

        self.forward = False
        self.backward = False
        self.leftward = False
        self.rightward = False

        self.accept('w', self.setKey, ['forward', 1])
        self.accept('s', self.setKey, ['backward', 1])
        self.accept('a', self.setKey, ['leftward', 1])
        self.accept('d', self.setKey, ['rightward', 1])
        self.accept('w-up', self.setKey, ['forward', 0])
        self.accept('s-up', self.setKey, ['backward', 0])
        self.accept('a-up', self.setKey, ['leftward', 0])
        self.accept('d-up', self.setKey, ['rightward', 0])

        # Add the spinCameraTask
        #self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
        self.taskMgr.add(self.movePandaTask, "movePandaTask")

        self.camera.setPos(100, 10, 20)

        # Load environment model
        self.environ = self.loader.loadModel("/Developer/Panda3D/models/environment")
        # Reparent the model to render
        #self.environ.reparentTo(self.render)
        # Apply scale and position transforms on the model
        self.environ.setScale(0.25, 0.25, 0.25)
        self.environ.setPos(0, 0, 0)

        # Load and transform the panda actor
        self.panda = Actor("/Developer/Panda3D/models/panda-model", {"walk4": "/Developer/Panda3D/models/panda-walk4"})
        self.panda.setScale(0.015, 0.015, 0.015)
        #self.panda.reparentTo(self.render)

        # Loop animation
        #self.pandaActor.loop("walk4")

        self.panda2 = Actor("panda", {"walk": "panda-walk"})
        self.panda2.setScale(1, 1, 1)
        self.panda2.setPos(0, 0, 100)
        self.panda2.reparentTo(self.render)

        self.pandaBody = OdeBody(self.world)
        self.pandaMass = OdeMass()
        self.pandaMass.setCapsule(50, 1, 1, 1)
        self.pandaBody.setMass(self.pandaMass)
        self.pandaBody.setPosition(self.panda2.getPos(self.render))
        self.pandaBody.setQuaternion(self.panda2.getQuat(self.render))

        self.pandaCapsuleGeom = OdeCappedCylinderGeom(self.space, 1, 1)
        self.pandaCapsuleGeom.setCollideBits(BitMask32(0x00000001))
        self.pandaCapsuleGeom.setCategoryBits(BitMask32(0x00000002))
        self.pandaCapsuleGeom.setBody(self.pandaBody)

        self.cm = CardMaker("ground")
        self.cm.setFrame(-20, 20, -20, 20)
        self.ground = self.render.attachNewNode(self.cm.generate())
        self.ground.setPos(0, 0, 0)
        self.ground.lookAt(0, 0, -1)
        self.groundGeom = OdePlaneGeom(self.space, Vec4(0, 0, 1, 0))
        self.groundGeom.setCollideBits(BitMask32(0x00000001))
        self.groundGeom.setCategoryBits(BitMask32(0x00000002))


        # Lighting
        alight = AmbientLight('alight')
        alight.setColor(VBase4(1, 1, 1, 1))
        alnp = render.attachNewNode(alight)

        dlight = DirectionalLight('my dlight')
        #dlight.setColor(VBase4(0.8, 0.8, 0.5, 1))
        dlnp = self.render.attachNewNode(dlight)
        dlnp.setHpr(50, -60, 0)

        slight = Spotlight('my slight')
        slight.setColor(VBase4(1, 1, 1, 1))
        lens = PerspectiveLens()
        slight.setLens(lens)
        slnp = self.render.attachNewNode(slight)
        slnp.setPos(0, 500, 500)
        slnp.lookAt(self.panda2)

        # turn on shadow
        slight.setShadowCaster(True, 512, 512)
        dlight.setShadowCaster(True, 512, 512)
        self.render.setShaderAuto()

        # turn on lighting effect for the world
        self.render.setLight(slnp)
        self.render.setLight(dlnp)
        self.render.setLight(alnp)

    def spinCameraTask(self, task):
        angleDegrees = task.time * 20.0
        angleRadians = angleDegrees * (pi / 180.0)
        self.camera.setPos(50 * sin(angleRadians), -50.0 * cos(angleRadians), 3)
        self.camera.setHpr(angleDegrees, 0, 0)
        return Task.cont

    def movePandaTask(self, task):

        if self.keyMap['forward']:
            self.panda2.setY(self.panda2, -10 * globalClock.getDt())
            self.pandaBody.setPosition(self.panda2.getPos(self.render))
            self.pandaBody.setQuaternion(self.panda2.getQuat())
            #self.panda2.setPos(self.panda2.getPos() - self.panda2.getQuat().getForward() * globalClock.getDt() * 20)

        if self.keyMap['backward']:
            #self.panda2.setPos(self.panda2.getPos() + self.panda2.getQuat().getForward() * globalClock.getDt() * 20) 
            self.panda2.setY(self.panda2, 10 * globalClock.getDt())
            self.pandaBody.setPosition(self.panda2.getPos(self.render))
            self.pandaBody.setQuaternion(self.panda2.getQuat())

        if self.keyMap['leftward']:
            self.panda2.setH(self.panda2.getH() + 100 * globalClock.getDt())
            #self.panda2.setHpr(self.panda2.getHpr().getX() + 10, 0, 0)
            self.pandaBody.setPosition(self.panda2.getPos(self.render))
            self.pandaBody.setQuaternion(self.panda2.getQuat())

        if self.keyMap['rightward']:
            self.panda2.setH(self.panda2.getH() - 100 * globalClock.getDt())
            #self.panda2.setHpr(self.panda2.getHpr().getX() - 10, 0, 0)
            self.pandaBody.setPosition(self.panda2.getPos(self.render))
            self.pandaBody.setQuaternion(self.panda2.getQuat())

        if self.keyMap['forward'] or self.keyMap['backward'] or self.keyMap['leftward'] or self.keyMap['rightward']:
            if not self.moving:
                self.panda2.loop('walk')
                self.moving = True
        else:
            if self.moving:
                self.panda2.stop()
                self.panda2.pose('walk', 9)
                self.moving = False

        base.camera.lookAt(self.panda2)


        self.space.autoCollide()
        self.world.quickStep(globalClock.getDt())

        #self.timeAccumu += globalClock.getDt()
        #while self.timeAccumu > self.stepSize:
            #self.timeAccumu -= self.stepSize

            #self.space.autoCollide()
            #self.world.quickStep(self.stepSize)

        self.panda2.setPosQuat(self.render, self.pandaBody.getPosition(), Quat(self.pandaBody.getQuaternion()))

        self.contactGroup.empty()
        return Task.cont

    def setKey(self, key, value):
        self.keyMap[key] = value


app = MyApp()
app.run()