Immersive Environments

SAIC VR projects @ Indianapolis InterMedia Festival

Ben Chang — Sat, 24 Apr 2010 14:18:43 +0000

VR Environments by:

Mark Baldridge, Ben Chang, Margaret Dolinsky, Kegan McGurk, Paul Schuette, Roger Wakeman

at the Intermedia Festival of Telematic Arts, Indianapolis, Saturday April 24th

Live Cam:

http://vrt-cam-1.avl.iupui.edu/view/index.shtml

(login: user=guest, pw=guest)

Joe LaViola on 3D interaction techniques

Ben Chang — Fri, 23 Apr 2010 21:46:45 +0000

VR researcher Joe LaViola talks about different paradigms for 3D interaction and how these interfaces, developed for the CAVE and other VR systems, can be applied to the new generation of 6DOF controllers

http://www.gamasutra.com/view/feature/4331/from_research_to_games_.php

VRPN + Panda

Ben Chang — Fri, 16 Apr 2010 21:52:43 +0000

import direct.directbase.DirectStart
from pandac.PandaModulesimport*
from direct.taskimport Task
from direct.showbaseimport*
importrandom
importsys
importmath
# vrpn_server -millisleep 1 -f vrpn_flock.cfg
class World(DirectObject.DirectObject):

  def __init__(self):

        # Accept the Esc key to quit the game.

    self.accept("escape", sys.exit)
    self.vrpnclient = VrpnClient ('localhost')

    self.tracker0 = TrackerNode(self.vrpnclient,"Tracker0")

    taskMgr.add (self.update,"update")
    self.wand=loader.loadModel("zup-axis")

    self.wand.reparentTo(render)

        # this is a node in the scenegraph.  you can attach stuff to it which will be visible.

    self.myTrackedNode = render.attachNewNode('myTrackedNode')  

        # this is the data node that gets the tracker info

        # it is NOT in the scenegraph, but in the mysterious data graph

    base.dataRoot.node().addChild(self.tracker0)

    t2n = Transform2SG('t2n')

    self.tracker0.addChild(t2n)

    t2n.setNode(self.myTrackedNode.node())
        # i think this should work:

        # cube=loader.loadModel("cube")

        # cube.reparentTo(self.myTrackedNode)

    base.disableMouse()

    camera.setPos(0,-100,30)

    camera.lookAt(0,0,0)
  def update (self,t):

    self.vrpnclient.poll()

    #camera.setPos(self.myTrackedNode.getPos())

    #camera.setHpr (self.myTrackedNode.getHpr())
    #print self.myTrackedNode.getPos()*1000, self.myTrackedNode.getHpr()

    p=self.myTrackedNode.getPos()

    p2 = int(p.getX()*100), int (p.getY() * 100), int(p.getZ() * 100)

    print p2    
    self.wand.setPos(p*15)

    #self.wand.setHpr(self.myTrackedNode.getHpr())
    #print self.wand.getPos()

    return Task.cont
 
w=World()

run()

Click and Drag

Ben Chang — Thu, 15 Apr 2010 20:56:37 +0000

Drag.tar

This example uses an updated MousePickingManager.py, so use the one in this archive. You can drag objects up and down, left and right.

# Click and Drag
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random

from MousePickingManager import *
import sys
class World (DirectObject.DirectObject):

    def __init__(self):

        self.loadmodels()

        self.mousemanager = MousePickingManager(self)

        self.accept ('escape',self.quit)

    def loadmodels(self):

        light1Node=PointLight("light1")

        light1=camera.attachNewNode(light1Node)

        render.setLight(light1)

        camera.setPos(0,-10,3)

        camera.lookAt(0,0,0)

        self.redpawn = Pawn("red pawn",self)

        self.redpawn.obj.setColor(1,0,0,1)

        self.bluepawn = Pawn("blue pawn",self)

        self.bluepawn.obj.setColor(0,0,1,1)

        self.bluepawn.obj.setPos(2,3,0)

        taskMgr.add(self.update,"update")
        camera.setH(0)

    def update(self,task):
        return task.cont
    def quit (self):

        print "bye bye"

        sys.exit()
class Pawn (DirectObject.DirectObject):

    def __init__(self,name,world):

        self.name=name

        self.world=world
        p=loader.loadModel("pawn")

        p.setName(name)

        p.reparentTo(render)       
        p.setTag("mouseInteraction","1")

        p.setPythonTag("pythonObject",self)

        self.obj=p

        self.dragging=False
        self.accept("mouseDown"+self.name,self.onClick)

        self.accept("mouseUp"+self.name,self.onRelease)

        self.accept("mouseUpOutside"+self.name,self.onRelease)

        taskMgr.add(self.update,"update")
    def onClick(self):

        self.dragging=True

        self.dragOffset=self.obj.getPos() - self.world.mousemanager.getLastPickPoint()

        print self.dragOffset

        # store distance 
    def onRelease(self):

        self.dragging=False
    def update(self,task):

        if self.dragging:

            p=self.world.mousemanager.getMousePositionOnXZPlane()

            self.obj.setPos(p+self.dragOffset)

        return task.cont
w=World()
run()

Ben Chang — Thu, 15 Apr 2010 18:17:05 +0000

Examples of using mouse events to interact with objects.
ClickOnObject.tar

# 1: Create a class to load a model, and prepare it for use with the MousePickingManager
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random

from MousePickingManager import *

import sys
class World (DirectObject.DirectObject):

    def __init__(self):

        self.loadmodels()

        self.mousemanager = MousePickingManager(self)

        self.accept ('escape',self.quit)

    def loadmodels(self):

        light1Node=PointLight("light1")

        light1=camera.attachNewNode(light1Node)

        render.setLight(light1)

        camera.setPos(0,-10,0)

        self.redpawn = Pawn("red pawn")

        self.redpawn.obj.setColor(1,0,0,1)

    def quit (self):

        print "bye bye"

        sys.exit()
class Pawn (DirectObject.DirectObject):

    def __init__(self,name):

        self.name=name

        p=loader.loadModel("pawn")

        p.setName(name)

        p.reparentTo(render)       

        self.obj=p

w=World()
run()

# 1: Create a class to load a model, and prepare it for use with the MousePickingManager
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random

from MousePickingManager import *

import sys
class World (DirectObject.DirectObject):

    def __init__(self):

        self.loadmodels()

        self.mousemanager = MousePickingManager(self)

        self.accept ('escape',self.quit)

    def loadmodels(self):

        light1Node=PointLight("light1")

        light1=camera.attachNewNode(light1Node)

        render.setLight(light1)

        camera.setPos(0,-10,0)

        self.redpawn = Pawn("red pawn")

        self.redpawn.obj.setColor(1,0,0,1)

    def quit (self):

        print "bye bye"

        sys.exit()
class Pawn (DirectObject.DirectObject):

    def __init__(self,name):

        self.name=name

        p=loader.loadModel("pawn")

        p.setName(name)

        p.reparentTo(render)       

        # setTag() lets you add extra properties to a node.  "mouseInteraction" is a flag for the MousePickingManager,

        # telling it that this object can have mouse interactions applied to it.

        p.setTag("mouseInteraction","1")
        # setPythonTag is like setTag, but it lets you connect a node to a python object.

        # here we connect the model to the Python object that uses it.  

        # this is because the mouse interaction code can only tell what object you've clicked on, and needs this 

        # information to connect to the event handlers.

        p.setPythonTag("pythonObject",self)

        # the mouse manager generates events with the name of the object appended, so this form of accept() will catch them correctly

        self.accept("mouseEnter"+self.name, self.onMouseEnter)

        self.obj=p

    def onMouseEnter(self):

        print "Mouse Enter", self.name
w=World()
run()

# 3: all mouse events
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random

from MousePickingManager import *

import sys
class World (DirectObject.DirectObject):

    def __init__(self):

        self.loadmodels()

        self.mousemanager = MousePickingManager(self)

        self.accept ('escape',self.quit)

    def loadmodels(self):

        light1Node=PointLight("light1")

        light1=camera.attachNewNode(light1Node)

        render.setLight(light1)

        camera.setPos(0,-10,0)

        self.redpawn = Pawn("red pawn")

        self.redpawn.obj.setColor(1,0,0,1)

    def quit (self):

        print "bye bye"

        sys.exit()
class Pawn (DirectObject.DirectObject):

    def __init__(self,name):

        self.name=name

        p=loader.loadModel("pawn")

        p.setName(name)

        p.reparentTo(render)       

        p.setTag("mouseInteraction","1")

        p.setPythonTag("pythonObject",self)

        self.accept("mouseEnter"+self.name, self.onMouseEnter)

        self.accept("mouseLeave"+self.name, self.onMouseLeave)

        self.accept("mouseDown"+self.name, self.onMouseDown)

        self.accept("mouseUp"+self.name,self.onMouseUp)

        self.accept("mouseUpOutside"+self.name,self.onMouseUpOutside)

        self.obj=p

    def onMouseEnter(self):

        print "Mouse Enter", self.name

    def onMouseLeave(self):

        print "Mouse Leave", self.name

    def onMouseDown(self):

        print "Mouse Down", self.name

    def onMouseUp(self):

        print "Mouse Up", self.name        

    def onMouseUpOutside(self):

        print "Mouse Up Outside", self.name        

w=World()
run()

# 4: use the mouse events to change something about the object
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random

from MousePickingManager import *

import sys
class World (DirectObject.DirectObject):

    def __init__(self):

        self.loadmodels()

        self.mousemanager = MousePickingManager(self)

        self.accept ('escape',self.quit)

    def loadmodels(self):

        light1Node=PointLight("light1")

        light1=camera.attachNewNode(light1Node)

        render.setLight(light1)

        camera.setPos(0,-10,0)

        self.redpawn = Pawn("red pawn")

        self.redpawn.obj.setColor(1,0,0,1)

    def quit (self):

        print "bye bye"

        sys.exit()
class Pawn (DirectObject.DirectObject):

    def __init__(self,name):

        self.name=name

        p=loader.loadModel("pawn")

        p.setName(name)

        p.reparentTo(render)       

        p.setTag("mouseInteraction","1")

        p.setPythonTag("pythonObject",self)

        self.accept("mouseEnter"+self.name, self.onMouseEnter)

        self.accept("mouseLeave"+self.name, self.onMouseLeave)

        self.accept("mouseDown"+self.name, self.onMouseDown)

        self.accept("mouseUp"+self.name,self.onMouseUp)

        self.accept("mouseUpOutside"+self.name,self.onMouseUpOutside)

        self.obj=p

    def onMouseEnter(self):

        self.obj.setScale(1.1)

    def onMouseLeave(self):

        self.obj.setScale(1)

    def onMouseDown(self):

        self.obj.setScale(1.5)

    def onMouseUp(self):

        self.obj.setScale(1.1)       

    def onMouseUpOutside(self):

        self.obj.setScale(1)

w=World()
run()

# 5: changing color
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random

from MousePickingManager import *

import sys
class World (DirectObject.DirectObject):

    def __init__(self):

        self.loadmodels()

        self.mousemanager = MousePickingManager(self)

        self.accept ('escape',self.quit)

    def loadmodels(self):

        light1Node=PointLight("light1")

        light1=camera.attachNewNode(light1Node)

        render.setLight(light1)

        camera.setPos(0,-10,0)

        self.redpawn = Pawn("red pawn")

        # add properties for base color, rollover color, and click color

        # these will be part of Pawn, not part of Pawn.obj

        self.redpawn.setBaseColor (.5,.4,.4)

        self.redpawn.setHighlightColor (1,0,0)

        self.redpawn.setSelectColor (1,.5,.5)

    def quit (self):

        print "bye bye"

        sys.exit()
class Pawn (DirectObject.DirectObject):

    def __init__(self,name):

        self.name=name

        p=loader.loadModel("pawn")

        p.setName(name)

        p.reparentTo(render)       

        p.setTag("mouseInteraction","1")

        p.setPythonTag("pythonObject",self)

        self.accept("mouseEnter"+self.name, self.onMouseEnter)

        self.accept("mouseLeave"+self.name, self.onMouseLeave)

        self.accept("mouseDown"+self.name, self.onMouseDown)

        self.accept("mouseUp"+self.name,self.onMouseUp)

        self.accept("mouseUpOutside"+self.name,self.onMouseUpOutside)

        self.obj=p
        self.setBaseColor(1,1,1)

        self.highlightColor=Vec4(1,1,1,1)

        self.selectColor=Vec4(1,1,1,1)

    def setBaseColor(self,r,g,b):

        self.baseColor = Vec4(r,g,b,1)

        self.obj.setColor(self.baseColor)

    def setHighlightColor(self,r,g,b):

        self.highlightColor = Vec4(r,g,b,1)

    def setSelectColor(self,r,g,b):

        self.selectColor = Vec4(r,g,b,1)

    def onMouseEnter(self):

        self.obj.setColor(self.highlightColor)

    def onMouseLeave(self):

        self.obj.setColor(self.baseColor)

    def onMouseDown(self):

        self.obj.setColor(self.selectColor)

    def onMouseUp(self):

        self.obj.setColor(self.highlightColor)

    def onMouseUpOutside(self):

        self.obj.setColor(self.baseColor)

w=World()
run()

Tutorial – Projectiles and Collisions

Ben Chang — Tue, 13 Apr 2010 02:23:10 +0000

This tutorial includes projectiles, simple fake physics, collisions, mouse interaction, and some handy vector math techniques to create a simple game.

There are several steps:

Create a projectile and animate it through code
Set up interaction to aim and launch the projectile
Create and animate targets to hurl projectiles at
Set up collision detection so you know when the target has been hit

All the completed code, with models and Maya files, is included in this archive:

TUTORIAL FILES

Projectiles

To animate a projectile, we'll use the same basic method as any other form of code-based animation:

Create an update task
Store a variable with a velocity vector
Each time the update task runs, get the current position of the object using getPos()
Add the velocity vector to the current position to get the new position
Update the position of the object using setPos()

# -*- coding: utf-8 -*-
# Projectile example

import direct.directbase.DirectStart

from pandac.PandaModules import *

from direct.actor.Actor import Actor

from direct.interval.ActorInterval import ActorInterval

from direct.interval.IntervalGlobal import *

from direct.showbase.DirectObject import DirectObject

import MousePickingManager

import random
class Bullet:

  def __init__(self):

    # property for this class to store the current velocity    

    self.velocity=Vec3(0,0,0)

    # set up the update task to animate the bullet

    self.updateTask = taskMgr.add(self.update,"update")

    self.obj=loader.loadModel("models/ball")

    self.obj.reparentTo(render)

    self.obj.setScale(.25)

    # this variable is used to calculate the elapsed time between calls to the update function

    self.lastTime=0

  def setVelocity (self,v):

    self.velocity=v

  def setPos(self,v):

    self.obj.setPos(v)

  def update(self,task):

    # how much time elapsed since the last update

    dt=task.getElapsedTime()-self.lastTime

    self.lastTime=task.getElapsedTime()
    # multiply the elapsed time X the velocity

    delta = self.velocity * dt
    # add the amount of change onto the current position

    newPos = self.obj.getPos() + delta
    # update the position of the object

    self.obj.setPos(newPos)
    return task.cont
    
class World(DirectObject):

  def __init__(self):

    base.disableMouse()

    terrain=loader.loadModel("models/terrain")

    terrain.reparentTo(render)

    terrain.setScale(1,3,1)

    light1=render.attachNewNode(PointLight("light1"))

    light1.setPos(0,0,20)

    render.setLight(light1)

    camera.setPos(0,0,1) 

    base.setBackgroundColor(.3,.3,7)

    # create a bullet

    bullet=Bullet()

    # give it an initial velocity

    v = Vec3(0,5,1)

    bullet.setVelocity(v)
w=World()

run()

This example uses two classes: one for the World, and one for the Bullet. This lets you create multiple bullets, just by creating more instances of the class, which we'll do a little later.

The core of the bullet code is this:

newPos = self.obj.getPos() + delta

where delta is the amount of change. But the way we calculate delta deserves some explanation. Notice the additional code before that point, dealing with time? This is important, but to understand why, let's look at a much simpler way we might try to write the same function:

def update(self,task):
# add the amount of change onto the current position

    newPos = self.obj.getPos() + self.velocity
    # update the position of the object

    self.obj.setPos(newPos)
    return task.cont

Much simpler, right? In the example, the velocity vector is set to (0,5,1), which is 5 units forward along the Y axis and 1 unit up along the Z axis. Thinking just about the Y axis, this means the bullet moves 5 units forward every time the update() function is called. This will work, although it will be way to fast, such that the bullet disappears into space immediately. Try setting the velocity to something smaller:

v = Vec3(0,.1,.01)

    bullet.setVelocity(v)

and that'll slow it down so you can see it. So this works fine - why do we need all that stuff with the timing variables?

The reason is that using the timing variables lets you describe velocity in terms of actual relationships between distance and time. Also, without using timing variables, you have no way of knowing how quickly the update() task is really getting called - sometimes it'll be really fast, other times, as your scene gets heavier, it might get called less often, causing the motion of the projectile to slow down. Using timing variables solves this problem.

Ok, so what ARE the timing variables, anyway? Here's the idea: first, think about how we describe speed in the real world. We might say a car is going 60 miles per hour, or a fastball is moving at 80 miles per hour. To animate an object in this way, we need to know the time step between one position and the next, and use that to determine how much change should happen.

In the case of a baseball traveling 80 miles an hour, let's say the time step is 1 second (meaning our animation is running at 1 frame per second). There are 60 * 60 = 3600 seconds in an hour, so in each second the ball should move 80/3600 = .02222 miles. In more reasonable units, that's around 117 feet per second.

So a chart of the ball's progress would look like this:

Time (seconds)    Position (feet)
-------------------------------
0                       0
1                       117
2                       234
3                       351
...

"Change" is often labeled using the Greek symbol "Delta." The Time Step, the amount of time that elapses from one update to the next, is also called "Delta Time" or just "dT". The amount of change along one axis is often called Delta X, Delta Y, etc., or just dX and dY.

In Panda, Tasks don't have a framerate setting, they just run as fast as they possibly can, which will change depending on how complex the scene is and how fast the computer is. So in order to find out how long the time step, or dT is, we do this:

Get the current timestamp using task.getElapsedTime()
Subtract the timestamp of the last call to update(): dt=task.getElapsedTime()-self.lastTime
Store the current timestamp so we can use it the next time update() is called: self.lastTime=task.getElapsedTime()

Then we multiply dt times the velocity vector before adding it on. If the velocity vector is expressed in meters per second, dt will contain a fraction of a second and so multiplying it times the velocity will give the correct amount of movement.

Adding Gravity

To create the effect of gravity, make another vector variable with the gravity direction in it, and add that (multiplied times dt) in each update.

# -*- coding: utf-8 -*-
import direct.directbase.DirectStart
from pandac.PandaModulesimport*
from direct.actor.Actorimport Actor
from direct.interval.ActorIntervalimport ActorInterval
from direct.interval.IntervalGlobalimport*
from direct.showbase.DirectObjectimport DirectObject
import MousePickingManager
importrandom
GRAVITY=Vec3(0,0,-2)
class Bullet:

  def __init__(self):

    # property for this class to store the current velocity    

    self.velocity=Vec3(0,0,0)

    # set up the update task to animate the bullet

    self.updateTask = taskMgr.add(self.update,"update")

    self.obj=loader.loadModel("models/ball")

    self.obj.reparentTo(render)

    self.obj.setScale(.25)

    # this variable is used to calculate the elapsed time between calls to the update function

    self.lastTime=0

  def setVelocity (self,v):

    self.velocity=v

  def setPos(self,v):

    self.obj.setPos(v)

  def update(self,task):

    # how much time elapsed since the last update

    dt=task.getElapsedTime()-self.lastTime

    self.lastTime=task.getElapsedTime()
    self.velocity=self.velocity+ (GRAVITY * dt)
    # multiply the elapsed time X the velocity

    delta = self.velocity * dt
    # add the amount of change onto the current position

    newPos = self.obj.getPos() + self.velocity * dt
    # update the position of the object

    self.obj.setPos(newPos)
    return task.cont
    
class World(DirectObject):

  def __init__(self):

    base.disableMouse()

    terrain=loader.loadModel("models/terrain")

    terrain.reparentTo(render)

    terrain.setScale(1,3,1)

    light1=render.attachNewNode(PointLight("light1"))

    light1.setPos(0,0,20)

    render.setLight(light1)

    camera.setPos(0,0,1) 

    base.setBackgroundColor(.3,.3,7)

    # create a bullet

    bullet=Bullet()

    # give it an initial velocity

    v = Vec3(0,5,3)

    bullet.setVelocity(v)

w=World()

run()

Aiming

This code example sets up a gun and rotates it to follow the mouse. The gun is positioned just underneath the camera, and the update() task maps the X and Y movement of the mouse to the Heading and Pitch rotations of the gun. (Remember Heading is Left-Right rotation, and Pitch is Up-Down rotation).

There are a number of other ways to accomplish this effect, but this one is pretty straightforward. This example uses the "MousePickingManager" utility class, so you'll need that file in the same directory so you can import it; but this can also be done easily with Panda's built in mouse functions. MousePickingManager is used here just for consistency with some of the other examples.

# -*- coding: utf-8 -*-
import direct.directbase.DirectStart
from pandac.PandaModulesimport*
from direct.actor.Actorimport Actor
from direct.interval.ActorIntervalimport ActorInterval
from direct.interval.IntervalGlobalimport*
from direct.showbase.DirectObjectimport DirectObject
import MousePickingManager
importrandom
class World(DirectObject):

  def __init__(self):

    self.mousemanager=MousePickingManager.MousePickingManager(self)

    terrain=loader.loadModel("models/terrain")

    terrain.reparentTo(render)

    terrain.setScale(1,3,1)

    light1=render.attachNewNode(PointLight("light1"))

    light1.setPos(0,0,20)

    render.setLight(light1)

    camera.setPos(0,0,1)

    base.setBackgroundColor(.3,.3,7)

    self.gun=loader.loadModel("models/gun")

    self.gun.setPos(0,.8,.65)

    self.gun.setScale(.5)

    self.gun.reparentTo(render)
    self.accept("mouseDown",self.onMouseDown)

    taskMgr.add(self.update,"update")
  def onMouseDown(self):

    print "Click!"

  def update(self,task):

    # get the X,Y coordinates of the mouse, on a range from -1 to 1

    p=self.mousemanager.getMouse()

    # scale the X,Y mouse coordinates to rotations: -45 to 45 degrees left/right, and 0 to 30 degrees up

    self.gun.setHpr(p.getX() * -45,(p.getY()+1)*15,0)

    return task.cont
w=World()

run()

Firing

To fire the bullet, we add a "fire" function and call it from onMouseDown(). It doesn't necessarily need to be its own function, all that code could just go straight into onMouseDown(), but this keeps the code more organized.

The bullet is created here:

def fire(self):

    bullet = Bullet()

    fvec = Vec3(0,1,0)

    bullet.setVelocity(render.getRelativeVector(self.gun,fvec*20))

    bullet.setPos(self.gun.getPos() + render.getRelativeVector(self.gun,fvec))

As soon as it's created, it begins animating (through Bullet's update() methdo). The last three lines in the fire() function make the bullet launch in the direction the gun is pointing, and deserve some explanation.

The key is the function getRelativeVector:

Vec3 NodePath.getRelativeVector(NodePath N,Vec3 V)

which takes the vector V relative to NodePath N, and returns an equivalent vector relative to the NodePath you use to call the method. Here's how it's used.

the vector fvec (0,1,0) points forward along the Y axis - it's a Forward Vector. What we want is to make the bullet move forward, but in the direction the gun is pointing. We could get that effect by simply parenting the bullet to the gun, but then the bullet would move as the gun rotates even after it's in flight.

So what we want is a new vector, in world coordinates, pointing forward from the gun. That's where getRelativeVector comes in - given the forward vector in the gun's coordinate system, it finds the equivalent vector in the world render coordinate system.

Note that you can launch as many bullets as you want. The bullet variable is temporary, since it's a local variable within the fire() method; but the bullet objects you've spawned all stay around. In some cases you'll want to add these to a list or keep track of them in some other way, but for this example it won't be necessary - we can store everything we need via the scene graph.

# -*- coding: utf-8 -*-
import direct.directbase.DirectStart
from pandac.PandaModulesimport*
from direct.actor.Actorimport Actor
from direct.interval.ActorIntervalimport ActorInterval
from direct.interval.IntervalGlobalimport*
from direct.showbase.DirectObjectimport DirectObject
import MousePickingManager
importrandom
GRAVITY = Vec3 (0,0,-2)
class Bullet:

  def __init__(self):

    self.velocity=Vec3(0,0,0)

    self.updateTask = taskMgr.add(self.update,"update")

    self.obj=loader.loadModel("models/ball")

    self.obj.reparentTo(render)

    self.obj.setScale(.25)

    self.lastTime=0

  def setVelocity (self,v):

    self.velocity=v

    #print self.velocity

  def setPos(self,v):

    self.obj.setPos(v)

  def update(self,task):

    dt=task.getElapsedTime()-self.lastTime

    self.lastTime=task.getElapsedTime()

    #print dt,task.getDt()

    self.velocity = self.velocity + (GRAVITY * dt)

    #print task.getDt(),self.velocity,self.obj.getPos()

    delta = self.velocity * dt

    #print task.getElapsedTime(),self.velocity.getY(),self.obj.getY()

    #print delta.getY()

    newPos = self.obj.getPos() + (self.velocity * dt)

    if newPos.getZ() < 0:

      self.obj.setPos(newPos)

      self.obj.removeNode()

      taskMgr.remove(self.updateTask)

      del(self)     

    else:

      self.obj.setPos(newPos)

    #print self.obj.getPos()

    return task.cont

class World(DirectObject):

  def __init__(self):

    self.mousemanager=MousePickingManager.MousePickingManager(self)

    terrain=loader.loadModel("models/terrain")

    terrain.reparentTo(render)

    terrain.setScale(1,3,1)

    light1=render.attachNewNode(PointLight("light1"))

    light1.setPos(0,0,20)

    render.setLight(light1)

    camera.setPos(0,0,1)

    base.setBackgroundColor(.3,.3,7)

    self.gun=loader.loadModel("models/gun")

    self.gun.setPos(0,.8,.65)

    self.gun.setScale(.5)

    self.gun.reparentTo(render)

    #self.gun.setHpr(15,0,0)

    self.accept("mouseDown",self.onMouseDown)

    taskMgr.add(self.update,"update")

  def onMouseDown(self):

    self.fire()

  def fire(self):

    bullet = Bullet()

    fvec = Vec3(0,1,0)

    bullet.setVelocity(render.getRelativeVector(self.gun,fvec*20))

    bullet.setPos(self.gun.getPos() + render.getRelativeVector(self.gun,fvec))

  def update(self,task):

    p=self.mousemanager.getMouse()

    self.gun.setHpr(p.getX() * -45,(p.getY()+1)*15,0)

    return task.cont

w=World()

run()

Mouse example – object follows mouse

Ben Chang — Thu, 08 Apr 2010 19:34:13 +0000

# Mouse Example 4
# Moving an object around to follow the mouse
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random
from MousePickingManager import *
class World(DirectObject.DirectObject):

  def __init__(self):
    self.mousemanager = MousePickingManager(self)
    taskMgr.add(self.update,"update")
    self.hand = loader.loadModel("models/hand")

    self.hand.reparentTo(render)

    camera.setPos(0,-10,0)

    self.light = render.attachNewNode(PointLight('light1'))

    self.light.reparentTo(render)

    self.light.setPos(0,-50,50)

    render.setLight(self.light)

  def update(self,task):

    # get the current position of the mouse on the screen

    mousepos = self.mousemanager.getMouse()

    x=mousepos.getX() * 4

    y=mousepos.getY() * 4
    self.hand.setPos(x,0,y)

    return Task.cont
w=World()

run()

Rotate object to follow mouse

Ben Chang — Thu, 08 Apr 2010 19:33:40 +0000

# Rotate a model based on mouse movement
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random
from MousePickingManager import *
class World(DirectObject.DirectObject):

  def __init__(self):
    self.mousemanager = MousePickingManager(self)
    taskMgr.add(self.update,"update")
    self.eye = loader.loadModel("models/eye")

    self.eye.reparentTo(render)

    camera.setPos(0,-10,0)
  def update(self,task):

    # get the current position of the mouse on the screen

    mousepos = self.mousemanager.getMouse()

    x=mousepos.getX()

    y=mousepos.getY()
    print x,y
    xangle = x * 45

    yangle = y * -45
    self.eye.setH(xangle)

    self.eye.setP(yangle)
    return Task.cont
w=World()

run()

Navigation, dragging, collision example

Ben Chang — Thu, 08 Apr 2010 19:32:36 +0000

NavigationExample_1.tar

Mouse Examples

Ben Chang — Thu, 08 Apr 2010 15:34:53 +0000

Mouse Examples Set 1

# Mouse Example 1
# Getting mouse position and checking the buttons
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random
from MousePickingManager import *
class World(DirectObject.DirectObject):

  def __init__(self):

    self.mousemanager = MousePickingManager(self)

    taskMgr.add(self.update,"update")
  def update(self,task):

    # get the current position of the mouse on the screen

    mousepos = self.mousemanager.getMouse()

    print mousepos

    leftbutton = self.mousemanager.getButtonState(0)
    print leftbutton

    return Task.cont
w=World()

run()

# Mouse Example 2
# mouseUp and mouseDown events
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random
from MousePickingManager import *
class World(DirectObject.DirectObject):

  def __init__(self):
    self.mousemanager = MousePickingManager(self)
    taskMgr.add(self.update,"update")
    self.accept ("mouseDown",self.onMouseDown)

    self.accept ("mouseUp",self.onMouseUp)
  def onMouseDown(self):

    print "CLICK"
  def onMouseUp(self):

    print "RELEASE"
  def update(self,task):

    # get the current position of the mouse on the screen

    mousepos = self.mousemanager.getMouse()

    #print mousepos

    

    leftbutton = self.mousemanager.getButtonState(0)
    #print leftbutton

    return Task.cont
w=World()

run()

# Mouse Example 3
# start and stop an animation
from pandac.PandaModules import *

from direct.task import *

from direct.showbase import DirectObject

import direct.directbase.DirectStart

import random
from direct.actor.Actor import Actor
from MousePickingManager import *
class World(DirectObject.DirectObject):

  def __init__(self):
    self.mousemanager = MousePickingManager(self)
    taskMgr.add(self.update,"update")
    self.accept ("mouseDown",self.onMouseDown)

    self.accept ("mouseUp",self.onMouseUp)
    base.setBackgroundColor(.8,.8,.8)
    light1 = render.attachNewNode (PointLight("light1"))

    render.setLight(light1)

    light1.setPos(0,-50,20)
    base.disableMouse()
    base.cam.setPos(0,-50,10)
    self.hair = Actor ("models/hair.egg",{"clip1":"models/hair_anim.egg"})

    self.hair.reparentTo(render)
  def onMouseDown(self):

    self.hair.loop("clip1")
  def onMouseUp(self):

    self.hair.stop()
  def update(self,task):

    return Task.cont
w=World()

run()