def EdgeMaker(self, startpos, bearing, primitive_width):
"""function returns a bend edge"""
"""function returns a bend edge"""
viz.startlayer(self.primitive)
for ins, out in zip(inside,outside):
viz.vertex(ins[0], ABOVEGROUND, ins[1])
viz.vertexcolor(self.colour)
viz.vertex(out[0], ABOVEGROUND, out[1])
viz.vertexcolor(self.colour)
"""
while i < self.Edge_Pts:
x1 = ((bearing - primitive_width)*np.cos(self.RoadArray[i])) + startpos[0]
z1 = self.Zdirection*((bearing - primitive_width)*np.sin(self.RoadArray[i])) + startpos[2]
#print (z1[i])
viz.vertex(x1, ABOVEGROUND, z1)
viz.vertexcolor(self.colour)
if self.primitive == viz.QUAD_STRIP:
x2 = ((rads + primitive_width)*np.cos(self.RoadArray[i])) + startpos[0]
z2 = self.Zdirection*((rads + primitive_width)*np.sin(self.RoadArray[i])) + startpos[2]
viz.vertex(x2, ABOVEGROUND, z2)
viz.vertexcolor(self.colour)
i += 1
"""
Bend = viz.endlayer()
return Bend
def StraightMaker(x,
start_z,
end_z,
colour=[.8, .8, .8],
primitive=viz.QUAD_STRIP,
width=None):
"""returns a straight, given some starting coords and length"""
viz.startlayer(primitive)
if width is None:
if primitive == viz.QUAD_STRIP:
width = .05
elif primitive == viz.LINE_STRIP:
width = 2
viz.linewidth(width)
width = 0
viz.vertex(x - width, .1, start_z)
viz.vertexcolor(colour)
viz.vertex(x + width, .1, start_z)
viz.vertexcolor(colour)
viz.vertex(x - width, .1, end_z)
viz.vertexcolor(colour)
viz.vertex(x + width, .1, end_z)
straightedge = viz.endlayer()
return straightedge
def placeMirror():
mirrorPos = [0, 1.5, -2];
global wall, mirrorRight, mirrorLeft, mirrorPlane
wall = viz.addTexQuad()
wall.setPosition(0, 0, mirrorPos[2] - 0.02)
wall.setScale(20, 20, 1)
# Apply nice repeating brick texture
wallmatrix = vizmat.Transform()
wallmatrix.setScale(20, 20, 1)
wall.texmat( wallmatrix )
bricks = viz.addTexture('brick.jpg')
bricks.wrap(viz.WRAP_T, viz.REPEAT)
bricks.wrap(viz.WRAP_S, viz.REPEAT)
wall.texture(bricks)
mirrorPlane = vizshape.addPlane()
mirrorPlane.setPosition(mirrorPos, viz.ABS_GLOBAL)
mirrorPlane.setEuler(0, 90, 0)
mirrorPlane.setScale(0.09, 1, 0.05)
windowBox = mirrorPlane.getBoundingBox(mode = viz.ABS_GLOBAL)
x0 = windowBox.xmin
x1 = windowBox.xmax
y0 = windowBox.ymin
y1 = windowBox.ymax
z = windowBox.zmax
viz.startlayer(viz.QUADS)
viz.texcoord(0,0)
viz.vertex( x0 , y0 , z )
viz.texcoord(0,1)
viz.vertex( x0 , y1, z )
viz.texcoord(1,1)
viz.vertex( x1 , y1, z)
viz.texcoord(1,0)
viz.vertex( x1 , y0 , z)
mirrorRight = viz.endlayer( )
mirrorLeft = mirrorRight.copy()
#specify the matrix
m = viz.Matrix()
#Try moving the mirror
#print "z: " + str(z);
m.setPosition([0, 0, z])
m.setEuler(0, 0, 0)
#Apply mirror settings to mirror object
mirrorPlane.alpha(0.0)
addMirror(mirrorRight,m,viz.RIGHT_EYE)
addMirror(mirrorLeft,m,viz.LEFT_EYE)
# Add collision
mirrorPlane.collideBox()
wall.visible(viz.OFF)
mirrorRight.visible(viz.OFF)
mirrorLeft.visible(viz.OFF)
def setARfov( val ): global node, ARfov_vert, hmdview ARfov_vert = val #ARfov_vert = HMDfov_vert #ARfov_vert = 20 ARheight = (int) (HMDheight / HMDfov_vert * ARfov_vert) ARwidth = ARheight * HMDaspect #recalculate ARfov_vert #ARfov_vert = (ARheight / HMDheight) * HMDfov_vert ARx = (HMDwidth - ARwidth)/2 ARy = (HMDheight - ARheight)/2 #print "AR view dimensions:",ARwidth,ARheight,ARx,ARy,ARfov_vert node.setSize( ARwidth,ARheight,ARx,ARy ) node.setFov( ARfov_vert, HMDaspect, HMDnear, HMDfar ) #return if(hmdview != 0): hmdview.remove() viz.startlayer(viz.QUADS) viz.vertex([ARx,ARy,0]) viz.vertex([ARx + ARwidth, ARy,0]) viz.vertex([ARx + ARwidth,ARy + ARheight,0]) viz.vertex([ARx,ARy + ARheight,0]) hmdview = viz.endlayer(viz.WORLD,viz.Scene3) hmdview.alpha(0.15)
def BendMaker(self, t, yawrate, transition_duration, rw, speed, sp, x_dir):
"""function returns a bend edge"""
"""function returns a bend edge"""
x, y, bearing = cc.clothoid_curve(t, speed, yawrate,
transition_duration)
if x_dir < 0:
bearing[:] = [(2 * (np.pi) - b) for b in bearing[:]]
midline = np.array([((x * x_dir) + sp[0]), (y + sp[1])]).T
outside = np.array(cc.add_edge((x * x_dir), y, (rw / 2), sp)).T
inside = np.array(cc.add_edge((x * x_dir), y, -(rw / 2), sp)).T
#print(outside.shape)
#print(inside.shape)
viz.startlayer(self.Primitive)
for ins, out in zip(inside, outside):
#print(ins)
#print(ins.shape)
viz.vertex(ins[0], ABOVEGROUND, ins[1])
viz.vertexcolor(self.Colour)
#print(ins[0], ins[1])
viz.vertex(out[0], ABOVEGROUND, out[1])
viz.vertexcolor(self.Colour)
#print(out[0], out[1])
Bend = viz.endlayer()
return ([Bend, midline, inside, outside, bearing])
def createQuad(left_bot, left_top, right_bot, right_top):
viz.startlayer(viz.QUADS)
viz.vertexcolor(0, 0, 0)
viz.vertex(left_bot)
viz.vertex(left_top)
viz.vertex(right_top)
viz.vertex(right_bot)
return viz.endlayer()
def StraightMaker(self, startpos, bearing, length, primitive_width):
endpos = [(startpos[0] + (length * (np.sin(bearing)))),
(startpos[1] + (length * (np.cos(bearing))))]
viz.startlayer(self.Primitive)
#print ("Startpos: ", startpos)
# print ("Endpos: ", endpos)
start_left = ([
(startpos[0] + (primitive_width * (np.sin(bearing - np.pi / 2)))),
ABOVEGROUND,
(startpos[1] + (primitive_width * (np.cos(bearing - np.pi / 2))))
])
#print('1L', start_left)
viz.vertex(start_left)
viz.vertexcolor(self.Colour)
# start rightside
start_right = ([
(startpos[0] + (primitive_width * (np.sin(bearing + np.pi / 2)))),
ABOVEGROUND,
(startpos[1] + (primitive_width * (np.cos(bearing + np.pi / 2))))
])
#print('1R', start_right)
viz.vertex(start_right)
viz.vertexcolor(self.Colour)
# end leftside:
end_left = ([
(endpos[0] + (primitive_width * (np.sin(bearing - np.pi / 2)))),
ABOVEGROUND,
(endpos[1] + (primitive_width * (np.cos(bearing - np.pi / 2))))
])
#print('2L', end_left)
viz.vertex(end_left)
viz.vertexcolor(self.Colour)
# end rightside:
end_right = ([
(endpos[0] + (primitive_width * (np.sin(bearing + np.pi / 2)))),
ABOVEGROUND,
(endpos[1] + (primitive_width * (np.cos(bearing + np.pi / 2))))
])
#print('2R', end_right)
viz.vertex(end_right)
viz.vertexcolor(self.Colour)
straight = viz.endlayer()
return (straight, endpos)
def setStage():
global groundplane, groundtexture
# ###should set this hope so it builds new tiles if you are reaching the boundary.
# fName = 'textures\strong_edge.bmp'
#
# # add groundplane (wrap mode)
# groundtexture = viz.addTexture(fName)
# groundtexture.wrap(viz.WRAP_T, viz.REPEAT)
# groundtexture.wrap(viz.WRAP_S, viz.REPEAT)
#
# groundplane = viz.addTexQuad() ##ground for right bends (tight)
# tilesize = 5000#300 #F***ING MASSIVE
# planesize = tilesize/5
# groundplane.setScale(tilesize, tilesize, tilesize)
# groundplane.setEuler((0, 90, 0),viz.REL_LOCAL)
# #groundplane.setPosition((0,0,1000),viz.REL_LOCAL) #move forward 1km so don't need to render as much.
# matrix = vizmat.Transform()
# matrix.setScale( planesize, planesize, planesize )
# groundplane.texmat( matrix )
# groundplane.texture(groundtexture)
# groundplane.visible(1)
gsize = [1000, 1000] #groundplane size, metres
groundplane = vizshape.addPlane(size=(gsize[0], gsize[1]),
axis=vizshape.AXIS_Y,
cullFace=True) ##make groundplane
groundplane.texture(viz.add('black.bmp')) #make groundplane black
#Build dot plane to cover black groundplane
ndots = 200000 #arbitrarily picked. perhaps we could match dot density to K & W, 2013?
viz.startlayer(viz.POINTS)
viz.vertexColor(viz.WHITE)
viz.pointSize(2)
for i in range(0, ndots):
x = (random.random() - .5) * gsize[0]
z = (random.random() - .5) * gsize[1]
viz.vertex([x, 0, z])
dots = viz.endLayer()
dots.setPosition(0, 0, 0)
dots.visible(1)
groundplane.visible(1)
def StraightEdgeMaker(self, startpos, endpos, primitive_width):
"""function returns a bend edge"""
i = 0
viz.startlayer(self.primitive)
#print ("Startpos: ", startpos)
#print ("Endpos: ", endpos)
viz.vertex([startpos[0] - primitive_width, startpos[1], startpos[2]])
viz.vertexcolor(self.colour)
viz.vertex([startpos[0] + primitive_width, startpos[1], startpos[2]])
viz.vertexcolor(self.colour)
viz.vertex([endpos[0] - primitive_width, endpos[1], endpos[2]])
viz.vertexcolor(self.colour)
viz.vertex([endpos[0] + primitive_width, endpos[1], endpos[2]])
viz.vertexcolor(self.colour)
straightedge = viz.endlayer()
return (straightedge)
def build_curve_viz(t, yawrate, transition, rw=3, speed=8):
x, y, bearing = clothoid_curve(t, speed, yawrate, transition)
midline = add_edge(x, y, rw=0)
outside = add_edge(x, y, rw)
inside = add_edge(x, y, -rw)
viz.startlayer(viz.POINTS)
for mid, ins, out in zip(midline, inside, outside):
viz.vertex(mid[0], ABOVEGROUND, mid[1])
viz.vertexcolor(viz.RED)
viz.vertex(ins[0], ABOVEGROUND, ins[1])
viz.vertexcolor(viz.BLUE)
viz.vertex(out[0], ABOVEGROUND, out[1])
viz.vertexcolor(viz.GREEN)
return (np.array((x, y, bearing)))
def setARfov( val ): global HMDheight, HMDwidth, HMDfov_vert, HMDaspect, HMDnear, HMDfar global node, ARfov_vert, ARgraybox print "********* val is ",val ARfov_vert = val ARheight = (int) (HMDheight / HMDfov_vert * ARfov_vert) ARwidth = ARheight * HMDaspect ARx = (HMDwidth - ARwidth)/2 ARy = (HMDheight - ARheight)/2 node.setSize( ARwidth,ARheight,ARx,ARy ) node.setFov( ARfov_vert, HMDaspect, HMDnear, HMDfar ) if(ARgraybox != 0): ARgraybox.remove() viz.startlayer(viz.QUADS) viz.vertex([ARx,ARy,0]) viz.vertex([ARx + ARwidth, ARy,0]) viz.vertex([ARx + ARwidth,ARy + ARheight,0]) viz.vertex([ARx,ARy + ARheight,0]) ARgraybox = viz.endlayer(viz.WORLD,viz.Scene3) ARgraybox.alpha(0.15)
def placeMirror(): global m windowBox = mirrorPlane.getBoundingBox(mode = viz.ABS_GLOBAL) x0 = windowBox.xmin x1 = windowBox.xmax y0 = windowBox.ymin y1 = windowBox.ymax z = windowBox.zmax viz.startlayer(viz.QUADS) viz.texcoord(0,0) viz.vertex( x0 , y0 , z ) viz.texcoord(0,1) viz.vertex( x0 , y1, z ) viz.texcoord(1,1) viz.vertex( x1 , y1, z) viz.texcoord(1,0) viz.vertex( x1 , y0 , z) mirrorRight = viz.endlayer( ) mirrorLeft = mirrorRight.copy() #specify the matrix m = viz.Matrix() #Try moving the mirror #m.setPosition([ 0.5*(x0+x1), 0.5*(y0+y1), z]) m.setPosition([0,0,z]) m.setEuler(180, 0, 0) # Adjust these! # #m.setPosition([0,0,z-1.50]) #this makes the mirror not reflect the space of the 4th row #m.setScale(2, 2, 2) #Apply mirror settings to mirror object mirrorPlane.alpha(0.0) addMirror(mirrorRight,m,viz.RIGHT_EYE) addMirror(mirrorLeft,m,viz.LEFT_EYE)
def EdgeMaker(self, startpos, rads, primitive_width):
"""function returns a bend edge"""
i = 0
viz.startlayer(self.primitive)
while i < self.Edge_Pts:
x1 = ((rads-primitive_width)*np.cos(self.RoadArray[i])) + startpos[0]
z1 = self.Z_direction*((rads-primitive_width)*np.sin(self.RoadArray[i])) + startpos[2]
#print (z1[i])
viz.vertex(x1, ABOVEGROUND, z1)
viz.vertexcolor(self.colour)
if self.primitive == viz.QUAD_STRIP:
x2 = ((rads+primitive_width)*np.cos(self.RoadArray[i])) + startpos[0]
z2 = self.Z_direction*((rads+primitive_width)*np.sin(self.RoadArray[i])) + startpos[2]
viz.vertex(x2, ABOVEGROUND, z2)
viz.vertexcolor(self.colour)
i += 1
Bend = viz.endlayer()
return Bend
def __init__( self , av_type = 0):
self.in_quad = 0
if av_type == 0:
type = random.randrange(0,4)
if type == 0:
self.avatar = viz.add('male.cfg',viz.WORLD,scene=viz.MainScene)
elif type == 1:
self.avatar = viz.add('vcc_male.cfg',viz.WORLD,scene=viz.MainScene)
elif type == 2:
self.avatar = viz.add('female.cfg',viz.WORLD,scene=viz.MainScene)
else:
self.avatar = viz.add('vcc_female.cfg',viz.WORLD,scene=viz.MainScene)
else:
self.avatar = viz.add('vcc_male.cfg',viz.WORLD,scene=viz.MainScene)
#Add the hat model
self.hat = viz.add('tophat.3ds')
self.hat.setScale([1,5,1])
#Get the head bone of the avatar
head = self.avatar.getBone('Bip01 Head')
#Link the hat to the head
HatLink = viz.link(head,self.hat)
#Tweek the hat link so it fits snuggly on the head
HatLink.preTrans( [0,0.1,-0.0] )
HatLink.preEuler( [0,-10,0] )
#HatLink.([0,5,0])
self.avatar.setPosition(get_random_point())
self.next_point = get_quadrant(self.avatar.getPosition()).get_random_walk()
self.coll = 0
self.avatar.collideMesh()
self.avatar.enable(viz.COLLIDE_NOTIFY)
#setup the AR
viz.startlayer(viz.QUADS)
viz.vertexcolor(1,0,0)
#viz.pointsize(20)
viz.linewidth(20)
pos = self.avatar.getPosition()
#viz.vertex(pos[0], -20, pos[2])
#viz.vertex(pos[0], 20, pos[2])
#rx = 0.5
#ry = 1
#viz.vertex(-rx, 0, 0)
#viz.vertex(-rx, r, 0)
#viz.vertex(r, r, 0)
#viz.vertex(r, -r, 0)
#viz.vertex(0,0,0)
#viz.vertex(0,2,0)
viz.vertex(-0.3,0,0)
viz.vertex(0.3,0,0)
viz.vertex(0.3,2,0)
viz.vertex(-0.3,2,0)
self.pointAR = viz.endlayer(viz.WORLD, viz.Scene2)
self.set_AR(True)
#self.pointAR.alpha(0.3)
self.arev = vizact.ontimer(.01,self.move_AR)
def BendMaker(radlist):
#make left and right road edges for for a given radii and return them in a list.
#needs to work with an array of radii
rdsize = 1000 # Hz size for curve length
#left_array= np.arange(0.0, np.pi*1000)/1000
left_array = np.linspace(0.0, np.pi, rdsize)
#right_array = np.arange(np.pi*1000, 0.0, -1)/1000 ##arange(start,stop,step). Array with 3142(/1000) numbers
right_array = np.linspace(
np.pi, 0.0,
rdsize) ##arange(start,stop,step). Array with 3142(/1000) numbers
leftbendlist = []
rightbendlist = []
grey = [.8, .8, .8]
for r in radlist:
x1 = np.zeros(rdsize)
z1 = np.zeros(rdsize)
x2 = np.zeros(rdsize)
z2 = np.zeros(rdsize)
i = 0
viz.startlayer(viz.LINE_STRIP)
#viz.linewidth(5)
viz.linewidth(3)
viz.vertexColor(grey)
viz.vertex(0, .1, 0) #START AT ORIGIN
if r > 0: #r=-1 means it is a straight.
while i < rdsize:
x1[i] = (r * np.cos(right_array[i])) + r
z1[i] = (r * np.sin(right_array[i]))
#print (z1[i])
viz.vertexColor(grey)
viz.vertex(x1[i], .1, z1[i])
i += 1
else:
viz.vertex(0, .1, 100.0) #100m straight
rightbend = viz.endlayer()
rightbend.visible(0)
rightbend.dynamic()
# left bend of a given radii
viz.startlayer(viz.LINE_STRIP)
#viz.linewidth(5)
viz.linewidth(3)
viz.vertexColor(grey)
viz.vertex(0, .1, 0) #START AT ORIGIN
i = 0
if r > 0: #r=-1 means it is a straight.
while i < rdsize:
x1[i] = (r * np.cos(left_array[i])) - r
z1[i] = (r * np.sin(left_array[i]))
viz.vertexColor(grey)
viz.vertex(x1[i], .1, z1[i])
i += 1
else:
viz.vertex(0, .1, 100.0) #100m straight
leftbend = viz.endlayer()
leftbend.visible(0)
leftbend.dynamic()
leftbendlist.append(leftbend)
rightbendlist.append(rightbend)
return leftbendlist, rightbendlist
def runtrials(self):
"""Loops through the trial sequence"""
setStage()
self.driver = vizdriver.Driver(self.caveview)
self.SAVEDATA = True # switch saving data on.
viz.MainScene.visible(viz.ON, viz.WORLD)
#add text to denote conditons - COMMENT OUT FOR EXPERIMENT
# txtCondt = viz.addText("Condition",parent = viz.SCREEN)
# txtCondt.setPosition(.7,.2)
# txtCondt.fontSize(36)
if self.EYETRACKING:
comms.start_trial()
for i, trialtype_signed in enumerate(self.TRIALSEQ_signed):
### iterates each trial ###
#import vizjoy
print("Trial: ", str(i))
print("TrialType: ", str(trialtype_signed))
print("gplanez", self.gplane_z_size)
print("gplane2", self.gplane2)
trialtype = abs(trialtype_signed)
trial_heading = self.ConditionList_heading[
trialtype] #set heading for that trial
trial_dots = self.ConditionList_dots[trialtype]
print(str([trial_heading, trial_dots]))
######choose correct road object.######
# changes message on screen
# msg = msg = "Heading: " + str(trial_heading) # COMMENT OUT FOR EXPERIMENT
#update class trial parameters#
self.Trial_N = i
self.Trial_heading = trial_heading
self.Trial_dots = trial_dots
self.Trial_trialtype_signed = trialtype_signed
#1) Offset camera and manipulate dot flow
#FOR EQUAL AND OPPOSITE USE THE LINE BELOW:
self.Trial_Camera_Offset = trial_heading
#put a mask on so that the jump isn't so visible
self.blackscreen.visible(viz.ON)
yield viztask.waitFrame(
12) #wait for six frames (.2 s) originally 6
viz.startlayer(viz.POINTS)
viz.vertexColor(viz.WHITE)
viz.pointSize(2)
for i in range(0, trial_dots):
x = (random.random() - .5) * tilesize
z = (random.random() - .5) * tilesize
viz.vertex([x, 0, z])
dots = viz.endLayer()
dots.setPosition(0, 0, 0)
dots.visible(1)
offset = viz.Matrix.euler(self.Trial_Camera_Offset, 0, 0)
viz.MainWindow.setViewOffset(offset) # counter rotates camera
self.blackscreen.visible(viz.OFF) #turn the mask
#2) give participant time with new flow field - might be extra important when manipulating flow field
yield viztask.waitTime(
2) #wait for one second after change of camera heading
# msg = msg + '\n' + 'Offset: ' + str(self.Trial_Camera_Offset) #Save your variables - COMMENT OUT FOR EXPERIMENT
# txtCondt.message(msg) # COMMENT OUT FOR EXPERIMENT
#3) Move straight to desired position
# Translate straight to driver position.
driverpos = viz.MainView.getPosition()
print(driverpos)
self.Straight.setPosition(driverpos[0], 0, driverpos[2])
# Match straight orientation to the driver
driverEuler = viz.MainView.getEuler(
) # gets current driver euler (orientation)
print("driverEuler", driverEuler) # prints the euler
self.Straight.setEuler(
driverEuler, viz.ABS_GLOBAL
) # then sets the straight euler as the driver euler in global coordinates.
# Offset the angle
offsetEuler = [trial_heading, 0,
0] # this creates the straight offset
self.Straight.setEuler(offsetEuler, viz.REL_LOCAL)
#will need to save initial vertex for line origin, and Euler. Is there a nifty way to save the relative position to the road?
#4) Reset set point and make the straight visible
self.Trial_setpoint = self.driver.reset_setpoint()
self.driver.setSWA_invisible() # sets SWA invisible on screen
self.Straight.visible(1)
#5) Wait for the trial time
yield viztask.waitTime(
self.VisibleRoadTime
) # add the road again. 2.5s to avoid ceiling effects.
#6) Remove straight
self.Straight.visible(0)
#7) remove dot flow - unsure whether this is the correct thing to do - might need standard level of flow that is then manipulated
dots.remove()
def checkCentred():
centred = False
x = self.driver.getPos()
if abs(x) < .1:
centred = True
return (centred)
##wait a while
#print "waiting"
#TODO: Recentre the wheel on automation.
#yield viztask.waitTrue(checkCentred)
#print "waited"
#loop has finished.
CloseConnections(self.EYETRACKING)
def createSolidBox(min, max):
viz.startlayer(viz.QUADS, "top")
viz.vertexcolor(1.0, 0.5, 0.0)
# top
# viz.vertexcolor(0.0,1.0,0.0)
viz.normal(0, 1, 0)
viz.vertex(max[0], max[1], min[2])
viz.vertex(min[0], max[1], min[2])
viz.vertex(min[0], max[1], max[2])
viz.vertex(max[0], max[1], max[2])
viz.startlayer(viz.QUADS, "bottom")
viz.vertexcolor(0.5, 0.5, 0.0)
viz.linewidth(2.0)
# bottom
# viz.vertexcolor(1.0,0.5,0.0)
viz.normal(0, -1, 0)
viz.vertex(max[0], min[1], max[2])
viz.vertex(min[0], min[1], max[2])
viz.vertex(min[0], min[1], min[2])
viz.vertex(max[0], min[1], min[2])
viz.startlayer(viz.QUADS, "front")
viz.vertexcolor(0.5, 0.5, 0.0)
viz.linewidth(2.0)
# front
# viz.vertexcolor(1.0,0.0,0.0)
viz.normal(0, 0, 1)
viz.vertex(max[0], max[1], max[2])
viz.vertex(min[0], max[1], max[2])
viz.vertex(min[0], min[1], max[2])
viz.vertex(max[0], min[1], max[2])
viz.startlayer(viz.QUADS, "back")
viz.vertexcolor(0.5, 0.5, 0.0)
viz.linewidth(2.0)
# back
# viz.vertexcolor(1.0,1.0,0.0)
viz.normal(0, 0, -1)
viz.vertex(max[0], min[1], min[2])
viz.vertex(min[0], min[1], min[2])
viz.vertex(min[0], max[1], min[2])
viz.vertex(max[0], max[1], min[2])
viz.startlayer(viz.QUADS, "left")
viz.vertexcolor(0.5, 0.5, 0.0)
viz.linewidth(2.0)
# left
# viz.vertexcolor(0.0,0.0,1.0)
viz.normal(-1, 0, 0)
viz.vertex(min[0], max[1], max[2])
viz.vertex(min[0], max[1], min[2])
viz.vertex(min[0], min[1], min[2])
viz.vertex(min[0], min[1], max[2])
viz.startlayer(viz.QUADS, "right")
viz.vertexcolor(0.5, 0.5, 0.0)
viz.linewidth(2.0)
# right
# viz.vertexcolor(1.0,0.0,1.0)
viz.normal(1, 0, 0)
viz.vertex(max[0], max[1], min[2])
viz.vertex(max[0], max[1], max[2])
viz.vertex(max[0], min[1], max[2])
viz.vertex(max[0], min[1], min[2])
return viz.endlayer()
def __init__( self , speedMultiplier = 1.0, av_type = 0 ):
print "Creating a person"
self.speedMultiplier = speedMultiplier
self.save_path = path.Path()
self.in_quad = 0
if av_type == 0:
type = random.randrange(0,4)
if type == 0:
self.avatar = viz.add('male.cfg',viz.WORLD,scene=viz.MainScene)
elif type == 1:
self.avatar = viz.add('vcc_male.cfg',viz.WORLD,scene=viz.MainScene)
elif type == 2:
self.avatar = viz.add('female.cfg',viz.WORLD,scene=viz.MainScene)
else:
self.avatar = viz.add('vcc_female.cfg',viz.WORLD,scene=viz.MainScene)
else:
self.avatar = viz.add('vcc_male.cfg',viz.WORLD,scene=viz.MainScene)
#Add the hat model
self.hat = viz.add('tophat.3ds')
self.hat.setScale([1,5,1])
#Get the head bone of the avatar
head = self.avatar.getBone('Bip01 Head')
#Link the hat to the head
HatLink = viz.link(head,self.hat)
#Tweek the hat link so it fits snuggly on the head
HatLink.preTrans( [0,0.1,-0.0] )
HatLink.preEuler( [0,-10,0] )
self.avatar.setPosition(quadSet.get_random_point())
#self.save_path.setStart(self.avatar.getPosition())
self.save_path.addPoint(self.avatar.getPosition(), 0)
self.next_point = quadSet.get_quadrant(self.avatar.getPosition())[0].get_random_walk()
self.next_speed = get_next_speed()
self.save_path.addPoint(self.next_point, self.next_speed)
self.coll = 0
self.avatar.collideMesh()
self.avatar.enable(viz.COLLIDE_NOTIFY)
#setup the AR
viz.startlayer(viz.QUADS)
if av_type == 0:
viz.vertexcolor(1,0,0)
else:
viz.vertexcolor(1,0,0)
viz.linewidth(20)
pos = self.avatar.getPosition()
viz.vertex(-0.3,0,0)
viz.vertex(0.3,0,0)
viz.vertex(0.3,2,0)
viz.vertex(-0.3,2,0)
self.pointAR = viz.endlayer(viz.WORLD, viz.Scene2)
self.pointAR.alpha(0.3)
self.tracking_error = []
self.arev = vizact.ontimer(.01,self.move_AR)
self.myquadrants = [False,False,False,False,False,False,False,False]
self.lastTime = 0
self.timeNotVisible = 0
def roadEdges(): global inside_edge, outside_edge, trialtype_signed, rdsize, edge, trialtype if edge == 1: #if already drawn inside_edge.remove() outside_edge.remove() road_x = 0 roadWidth = 3.0 r = 60 x1 = np.zeros(rdsize) z1 = np.zeros(rdsize) x2 = np.zeros(rdsize) z2 = np.zeros(rdsize) #normal edges if trialtype_signed > 0: #right curve ##Outside Edge - Right # outside edge drawing of straight line i = 0 viz.startlayer(viz.LINE_STRIP) viz.linewidth(1) viz.vertex((road_x-(roadWidth/2)), .1, 0) viz.vertex((road_x-(roadWidth/2)), .1, straight_road) # outside edge drawing of right curve while i < rdsize: x1[i] = (r+(roadWidth/2))*np.cos(right_array[i]) + r z1[i] = (r+(roadWidth/2))*np.sin(right_array[i]) + straight_road viz.vertex(x1[i], .1, z1[i] ) i += 1 outside_edge = viz.endlayer() outside_edge.alpha(1) # inside edge drawing of straight line i = 0 viz.startlayer(viz.LINE_STRIP) viz.linewidth(1) viz.vertex(road_x-(roadWidth/2), 0.1, 0) viz.vertex(road_x-(roadWidth/2), 0.1, straight_road) # inside edge drawing of right curve while i < rdsize: x2[i] = (r-(roadWidth/2))*np.cos(right_array[i]) + r z2[i] = (r-(roadWidth/2))*np.sin(right_array[i]) + straight_road viz.vertex(x2[i], 0.1, z2[i]) i += 1 inside_edge = viz.endlayer() inside_edge.alpha(1) elif trialtype_signed < 0: # left curve # outside edge drawing of straight line viz.startlayer(viz.LINE_STRIP) viz.linewidth(1) viz.vertex(road_x+(roadWidth/2), .1, 0) viz.vertex(road_x+(roadWidth/2), .1, straight_road) i = 0 # outside edge drawing of left curve while i < rdsize: x1[i] = (r+(roadWidth/2))*np.cos(left_array[i]) - r z1[i] = (r+(roadWidth/2))*np.sin(left_array[i]) + straight_road viz.vertex(x1[i], .1, z1[i]) i += 1 outside_edge = viz.endlayer() outside_edge.alpha(1) # inside edge drawing of straight line viz.startlayer(viz.LINE_STRIP) viz.linewidth(1) viz.vertex(road_x-(roadWidth/2), .1, 0) viz.vertex(road_x-(roadWidth/2), .1, straight_road) # inside edge drawing of left curve i = 0 while i < rdsize: x2[i] = (r-(roadWidth/2))*np.cos(left_array[i]) - r z2[i] = (r-(roadWidth/2))*np.sin(left_array[i]) + straight_road viz.vertex(x2[i], 0.1, z2[i]) i += 1 inside_edge = viz.endlayer() inside_edge.alpha(1) edge = 1
def __init__(self, texFile, **kw):
viz.startlayer(viz.QUADS)
self.node = viz.endlayer(**kw)
vert = """
uniform int light;
uniform float osg_FrameTime;
uniform mat4 osg_ViewMatrixInverse;
void main(void)
{
/* Parameters are encoded in vertex color
r - Animation time offset
g - Animation speed
b - Particle Size
*/
//Compute alpha based on time
float time = (osg_FrameTime+gl_Color.r)*gl_Color.g;
//Animate vertex
//gl_Vertex.xyz += gl_Normal*sin(time)*0.2;
gl_Vertex.x += gl_Normal.x*sin(time)*0.2;
gl_Vertex.z += gl_Normal.z*sin(time)*0.2;
//Convert to eye space
gl_Vertex.xyz = gl_ModelViewMatrix * gl_Vertex;
//Extrude point
gl_Vertex.x += (gl_MultiTexCoord0.x*2.0-1.0)*gl_Color.b;
gl_Vertex.y += (gl_MultiTexCoord0.y*2.0-1.0)*gl_Color.b;
//Save clip vertex in eye space
gl_ClipVertex = gl_Vertex;
//Convert to screen coordinates
gl_Position = gl_ProjectionMatrix * gl_Vertex;
gl_FogFragCoord = abs(gl_ClipVertex.z);
gl_TexCoord[0].xy = gl_MultiTexCoord0.xy;
}
"""
frag = """
uniform float fog;
uniform sampler2D tex;
void main(void)
{
gl_FragColor = texture2D(tex,gl_TexCoord[0].xy);
float alpha = gl_FragColor.a;
if(fog != 0.0) {
float f = exp2(fog * gl_FogFragCoord);
f = clamp(f, 0.0, 1.0);
gl_FragColor = mix(gl_Fog.color, gl_FragColor, f);
}
gl_FragColor.a = alpha;
}
"""
tex = viz.add(texFile)
texUniform = viz.addUniformInt('tex',0)
shader = viz.addShader(vert=vert,frag=frag)
self.node.apply(shader)
self.node.apply(texUniform)
# self.node.apply(_fogUniform)
self.node.disable(viz.CULLING)
self.node.texture(tex)
self.node.enable(viz.SAMPLE_ALPHA_TO_COVERAGE)
self.node.disable(viz.BLEND)
#Initialize remove list
self.removeList = []
self.removeList.append(shader)
self.removeList.append(self.node)
self.removeList.append(tex)
self.removeList.append(texUniform)
def createSolidBox(min,max): viz.startlayer(viz.QUADS, 'top') viz.vertexcolor(1.0,0.5,0.0) #top #viz.vertexcolor(0.0,1.0,0.0) viz.normal(0,1,0) viz.vertex( max[0], max[1], min[2]) viz.vertex( min[0], max[1], min[2]) viz.vertex( min[0], max[1], max[2]) viz.vertex( max[0], max[1], max[2]) viz.startlayer(viz.QUADS,'bottom') viz.vertexcolor(.5,.5,0.0) viz.linewidth(2.0) #bottom #viz.vertexcolor(1.0,0.5,0.0) viz.normal(0,-1,0) viz.vertex( max[0], min[1], max[2]) viz.vertex( min[0], min[1], max[2]) viz.vertex( min[0], min[1], min[2]) viz.vertex( max[0], min[1], min[2]) viz.startlayer(viz.QUADS,'front') viz.vertexcolor(.5,.5,0.0) viz.linewidth(2.0) #front #viz.vertexcolor(1.0,0.0,0.0) viz.normal(0,0,1) viz.vertex( max[0], max[1], max[2]) viz.vertex( min[0], max[1], max[2]) viz.vertex( min[0], min[1], max[2]) viz.vertex( max[0], min[1], max[2]) viz.startlayer(viz.QUADS,'back') viz.vertexcolor(.5,.5,0.0) viz.linewidth(2.0) #back #viz.vertexcolor(1.0,1.0,0.0) viz.normal(0,0,-1) viz.vertex( max[0], min[1], min[2]) viz.vertex( min[0], min[1], min[2]) viz.vertex( min[0], max[1], min[2]) viz.vertex( max[0], max[1], min[2]) viz.startlayer(viz.QUADS,'left') viz.vertexcolor(.5,.5,0.0) viz.linewidth(2.0) #left #viz.vertexcolor(0.0,0.0,1.0) viz.normal(-1,0,0) viz.vertex( min[0], max[1], max[2]) viz.vertex( min[0], max[1], min[2]) viz.vertex( min[0], min[1], min[2]) viz.vertex( min[0], min[1], max[2]) viz.startlayer(viz.QUADS,'right') viz.vertexcolor(.5,.5,0.0) viz.linewidth(2.0) #right #viz.vertexcolor(1.0,0.0,1.0) viz.normal(1,0,0) viz.vertex( max[0], max[1], min[2]) viz.vertex( max[0], max[1], max[2]) viz.vertex( max[0], min[1], max[2]) viz.vertex( max[0], min[1], min[2]) return viz.endlayer()
node2D = viz.addRenderNode() node2D.setScene(viz.Scene3) node2D.setBuffer( viz.RENDER_FRAME_BUFFER ) node2D.setOrder( viz.POST_RENDER ) node2D.setInheritView(0) node2D.setSize( HMDwidth,HMDheight ) node2D.setProjectionMatrix(viz.Matrix.ortho2D(0,HMDwidth,0,HMDheight)) node2D.setClearMask(0) node2D.disable(viz.DEPTH_TEST) #viz.startlayer(viz.LINES) #viz.vertex([HMDwidth/2,0,0]) #viz.vertex([HMDwidth/2,HMDheight,0]) #viz.endlayer(viz.WORLD,viz.Scene3) viz.startlayer(viz.LINES) viz.vertexcolor([1,0,0]) viz.vertex([HMDwidth/2-10,HMDheight/2,0]) viz.vertex([HMDwidth/2+10,HMDheight/2,0]) viz.vertex([HMDwidth/2,HMDheight/2-10,0]) viz.vertex([HMDwidth/2,HMDheight/2+10,0]) viz.vertexcolor([1,1,1]) viz.endlayer(viz.WORLD,viz.Scene3)
