def load_bbone(self, structure, node):
for chain in structure.get_chains():
carr = np.random.rand(3, 1)
ccolor = float(carr[0]), float(carr[1]), float(carr[2]), 1.0
can_atoms = [
atom for atom in chain.get_atoms()
if atom.get_name() == 'CA' or atom.get_name() == 'N'
]
can_coordinates = [atom.coord for atom in can_atoms]
for atom in can_atoms:
x, y, z = atom.coord
id = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.reparentTo(pnode)
a.setColor(ccolor)
a.setScale(vrad(id) / 2.5)
lines = LineSegs()
lines.setColor(ccolor)
lines.moveTo(can_coordinates[0][0], can_coordinates[0][1],
can_coordinates[0][2])
for i in range(len(can_atoms))[1:]:
lines.drawTo(can_coordinates[i][0], can_coordinates[i][1],
can_coordinates[i][2])
lines.setThickness(6)
lnode = lines.create()
linenp = NodePath(lnode)
linenp.reparentTo(pnode)
node.flattenStrong()
def make_circle(self, angle_deg=360):
ls = LineSegs()
angle_radians = np.deg2rad(angle_deg)
# assume visual angle is approximately the same for x and y,
# which probably is not true, maybe need to change
#radius = 1 * Positions().visual_angle()[0]
res = [1024, 768]
# Screen size
screen = [1337, 991]
v_dist = 1219
# number of visual angles want circle radius to be
# (so twice this is the x and y of the square)
angle = 0.25
# visual angle returns degrees per pixel, so invert since
# we want pixel per degree
deg_per_pixel = visual_angle(screen, res, v_dist)
x_radius = angle * 1 / deg_per_pixel[0]
y_radius = angle * 1 / deg_per_pixel[0]
for i in range(50):
a = angle_radians * i / 49
y = y_radius * np.sin(a)
#print y
x = x_radius * np.cos(a)
#print x
ls.drawTo(x, self.depth, y)
#node = ls.create()
node = self.base.render.attachNewNode(ls.create(True))
return NodePath(node)
def show_window(self, target_pos):
# draw line around target representing how close the subject has to be looking to get reward
# print('show window around square', square_pos)
tolerance = self.plot_variables[
self.text_dict['Tolerance']] / self.deg_per_pixel
# print 'tolerance in pixels', tolerance
# print 'square', square[0], square[2]
eye_window = LineSegs()
eye_window.setThickness(2.0)
eye_window.setColor(1, 0, 0, 1)
angle_radians = radians(360)
for i in range(50):
a = angle_radians * i / 49
y = tolerance * sin(a)
x = tolerance * cos(a)
eye_window.drawTo((x + target_pos[0], 55, y + target_pos[1]))
# draw a radius line
# eye_window.moveTo(square[0], 55, square[2])
# eye_window.drawTo(square[0], 55, square[2] + self.plot_variables[self.text_dict['Tolerance']])
# print 'distance drawn', self.distance((square[0], square[2]), (square[0], square[2] + self.plot_variables[self.text_dict['Tolerance']]))
# True optimizes the line segments, which sounds useful
node = self.base.render.attachNewNode(eye_window.create(True))
node.show(BitMask32.bit(0))
node.hide(BitMask32.bit(1))
self.eye_window.append(node)
def createMoveVis(self):
# Instance each selected map object to the vis root
for obj in base.selectionMgr.selectedObjects:
instRoot = NodePath("instRoot")
inst = obj.np.instanceTo(instRoot)
instRoot.wrtReparentTo(self.toolVisRoot)
self.xformObjects.append((obj, instRoot, inst))
# Show an infinite line along the axis we are moving the object
# if we are using the 3D view
if self.widget.activeAxis:
axis = self.widget.activeAxis.axisIdx
segs = LineSegs()
col = Vec4(0, 0, 0, 1)
col[axis] = 1.0
segs.setColor(col)
p = Point3(0)
p[axis] = -1000000
segs.moveTo(p)
p[axis] = 1000000
segs.drawTo(p)
self.axis3DLines = self.toolRoot.attachNewNode(segs.create())
self.axis3DLines.setLightOff(1)
self.axis3DLines.setFogOff(1)
self.widget.stash()
def makeBulletRicochet(self, dgi):
pos = CIGlobals.getVec3(dgi)
dir = CIGlobals.getVec3(dgi)
scale = dgi.getFloat64()
start = (0, 0, 0)
end = dir * scale
from panda3d.core import LineSegs, Vec4
from direct.interval.IntervalGlobal import Sequence, Func, Parallel
lines = LineSegs()
lines.setColor(Vec4(1, 1, 1, 1))
lines.setThickness(1)
lines.moveTo(start)
lines.drawTo(end)
np = render.attachNewNode(lines.create())
np.setLightOff(1)
np.setPos(pos)
Sequence(
Parallel(np.posInterval(0.1, pos + end, pos),
np.scaleInterval(0.1, (0.001, 0.001, 0.001), (1, 1, 1))),
Func(np.removeNode)).start()
import random
soundDir = "sound/weapons/ric{0}.wav"
soundIdx = random.randint(1, 5)
CIGlobals.emitSound(soundDir.format(soundIdx), pos)
def plot_eye_trace(self, first_eye):
# print 'plot trace'
# if plotting too many eye positions, things slow down and
# python goes into lala land. Never need more than 500, and
# last 300 is definitely plenty, so every time it hits 500,
# get rid of first 200.
if len(self.eye_nodes) > 500:
# print('get rid of eye nodes', len(self.eye_nodes))
# Since this just removes the node, but doesn't delete
# the object in the list, can do this in a for loop,
for index in range(200):
self.eye_nodes[index].removeNode()
# now get rid of the empty nodes in eye_nodes
# print('new length', len(self.eye_nodes))
self.eye_nodes = self.eye_nodes[200:]
# print('new length', len(self.eye_nodes))
eye = LineSegs()
# eye.setThickness(2.0)
eye.setThickness(2.0)
# print 'last', last_eye
# print 'now', self.current_eye_data
eye.moveTo(first_eye[0], 55, first_eye[1])
for data_point in self.current_eye_data:
eye.drawTo(data_point[0], 55, data_point[1])
# print('plotted eye', eye_data_to_plot)
node = self.base.render.attachNewNode(eye.create(True))
node.show(BitMask32.bit(0))
node.hide(BitMask32.bit(1))
self.eye_nodes.append(node)
def getUnitCone():
global UnitCone
if not UnitCone:
segs = LineSegs('unitCone')
dist = 1
points = [
Vec3(-dist, 1, 0),
Vec3(0, 1, dist),
Vec3(0, 1, -dist),
Vec3(dist, 1, 0)
]
for point in points:
segs.moveTo(Vec3(0))
segs.drawTo(point)
vertices = LEUtils.circle(0, 0, dist, 64)
for i in range(len(vertices)):
x1, y1 = vertices[i]
x2, y2 = vertices[(i + 1) % len(vertices)]
pFrom = Vec3(x1, 1, y1)
pTo = Vec3(x2, 1, y2)
segs.moveTo(pFrom)
segs.drawTo(pTo)
UnitCone = NodePath(segs.create())
UnitCone.setAntialias(AntialiasAttrib.MLine)
UnitCone.setLightOff(1)
UnitCone.setFogOff(1)
UnitCone.hide(DirectRender.ShadowCameraBitmask
| DirectRender.ReflectionCameraBitmask)
return UnitCone
def plot_xy_vs_t(self):
then = self.now
if self.now == 0:
then = time.time()
self.now = time.time()
#print self.now
dt = (self.now - then) / 10
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
y_mag = event_mag
#print('forward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('forward', self.y_mag)
elif event_name == 'moveBackward':
y_mag = -event_mag
#print('backward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('backward', self.y_mag)
elif event_name == 'turnRight':
x_mag = event_mag
#print('right', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('right', self.x_mag)
elif event_name == 'turnLeft':
x_mag = -event_mag
#print('left', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('left', self.x_mag)
plot_x = LineSegs()
plot_x.setThickness(2.0)
plot_x.setColor(Vec4(1, 1, 0, 1))
plot_x.moveTo(self.time, 0, self.old_x)
plot_y = LineSegs()
plot_y.setThickness(2.0)
plot_y.setColor(Vec4(1, 0, 0, 1))
plot_y.moveTo(self.time, 0, self.old_y)
self.time += dt
#print('dt', dt)
#print('time', self.time)
plot_x.drawTo(self.time, 0, self.x_mag)
node = base.render2d.attach_new_node(plot_x.create(True))
self.plot.append(node)
plot_y.drawTo(self.time, 0, self.y_mag)
node = base.render2d.attach_new_node(plot_y.create(True))
self.plot.append(node)
self.old_x = self.x_mag
self.old_y = self.y_mag
if self.time > 1:
self.clear_plot()
def checkCollisions(self, task):
sensorPoints = []
self.sensorDistances = []
for queue in self.sensorCollisionHandlers:
if queue.getNumEntries() > 0:
queue.sortEntries()
entry = queue.getEntry(0)
sensorPoint = entry.getSurfacePoint(entry.getFromNodePath())
sensorPoints.append(sensorPoint)
tmp = sensorPoint - Vec3(0.0, 0.0, self.sensorHeight)
self.sensorDistances.append(tmp.length())
# DEBUG
tmp = self.car.find("sensorsSegs")
if not tmp.isEmpty():
tmp.removeNode()
if self.debugMode:
sensorSegs = LineSegs("sensorsSegs")
sensorSegs.setColor(1.0, 0.45, 0.0)
sensorSegs.setThickness(4)
for point in sensorPoints:
sensorSegs.moveTo(Point3(0.0, 0.0, self.sensorHeight))
sensorSegs.drawTo(point)
sensorNode = sensorSegs.create()
self.car.attachNewNode(sensorNode)
return task.cont
def add_line(self, start_p: Union[Vec3, Tuple], end_p: Union[Vec3, Tuple], color, thickness: float):
line_seg = LineSegs("interface")
line_seg.setColor(*color)
line_seg.moveTo(start_p)
line_seg.drawTo(end_p)
line_seg.setThickness(thickness)
NodePath(line_seg.create(False)).reparentTo(self.render)
def update_LFP(self, dt, last_lfp, lfp_trace, offset, gen_lfp):
# lfp data is taken at 1000Hz, and dt is the number of seconds since
# the last frame was flipped, so plot number of points = dt * 1000
lfp = LineSegs()
lfp.setThickness(1.0)
#print('points to plot', int(dt * 1000))
#self.lfp_test += int(dt * 1000)
#print('points so far', self.lfp_test)
for i in range(int(dt * 1000)):
try:
last_lfp.append((next(gen_lfp) * self.lfp_gain) + offset)
#last_lfp_x += 0.05
# only plotting 200 data points at a time
while len(last_lfp) > 3500:
last_lfp.pop(0)
except StopIteration:
#print('done with lfp')
break
if lfp_trace:
lfp_trace[0].removeNode()
lfp_trace.pop(0)
lfp.moveTo(self.start_x_trace, 55, last_lfp[0])
x = self.start_x_trace
for i in last_lfp:
x += .1
lfp.drawTo(x, 55, i)
node = self.base.pixel2d.attachNewNode(lfp.create())
lfp_trace.append(node)
def plot_xy(self):
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
self.y_mag = event_mag
print('forward', self.y_mag)
elif event_name == 'moveBackward':
self.y_mag = -event_mag
print('backward', self.y_mag)
elif event_name == 'turnRight':
self.x_mag = event_mag
print('right', self.x_mag)
elif event_name == 'turnLeft':
self.x_mag = -event_mag
print('left', self.x_mag)
plot_xy = LineSegs()
plot_xy.setThickness(2.0)
plot_xy.setColor(Vec4(1, 1, 0, 1))
plot_xy.moveTo(self.old_x, 0, self.old_y)
plot_xy.drawTo(self.x_mag, 0, self.y_mag)
base.render2d.attach_new_node(plot_xy.create(True))
self.old_x = self.x_mag
self.old_y = self.y_mag
def plot_xy(self):
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
self.y_mag = event_mag
print('forward', self.y_mag)
elif event_name == 'moveBackward':
self.y_mag = -event_mag
print('backward', self.y_mag)
elif event_name == 'turnRight':
self.x_mag = event_mag
print('right', self.x_mag)
elif event_name == 'turnLeft':
self.x_mag = -event_mag
print('left', self.x_mag)
plot_xy = LineSegs()
plot_xy.setThickness(2.0)
plot_xy.setColor(Vec4(1, 1, 0, 1))
plot_xy.moveTo(self.old_x, 0, self.old_y)
plot_xy.drawTo(self.x_mag, 0, self.y_mag)
base.render2d.attach_new_node(plot_xy.create(True))
self.old_x = self.x_mag
self.old_y = self.y_mag
def plot_xy_vs_t(self):
then = self.now
if self.now == 0:
then = time.time()
self.now = time.time()
#print self.now
dt = (self.now - then) / 10
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
y_mag = event_mag
#print('forward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('forward', self.y_mag)
elif event_name == 'moveBackward':
y_mag = -event_mag
#print('backward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('backward', self.y_mag)
elif event_name == 'turnRight':
x_mag = event_mag
#print('right', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('right', self.x_mag)
elif event_name == 'turnLeft':
x_mag = -event_mag
#print('left', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('left', self.x_mag)
plot_x = LineSegs()
plot_x.setThickness(2.0)
plot_x.setColor(Vec4(1, 1, 0, 1))
plot_x.moveTo(self.time, 0, self.old_x)
plot_y = LineSegs()
plot_y.setThickness(2.0)
plot_y.setColor(Vec4(1, 0, 0, 1))
plot_y.moveTo(self.time, 0, self.old_y)
self.time += dt
#print('dt', dt)
#print('time', self.time)
plot_x.drawTo(self.time, 0, self.x_mag)
node = base.render2d.attach_new_node(plot_x.create(True))
self.plot.append(node)
plot_y.drawTo(self.time, 0, self.y_mag)
node = base.render2d.attach_new_node(plot_y.create(True))
self.plot.append(node)
self.old_x = self.x_mag
self.old_y = self.y_mag
if self.time > 1:
self.clear_plot()
def draw_trails(self):
# draw trails
# self.trails = []
for i, ball in enumerate(self.box.particles):
trail = []
# for j in range(self.box.trail):
for j in range(MAX_TRAILS):
line = LineSegs(f"trail[{i},{j}]")
color = [c / 255 for c in ball.color]
line.setColor(*color, 1)
# line.setColor(0.3, 0.3, 0.3, 1)
line.moveTo((0, 0, 0))
line.drawTo((0, 1, 0))
line.setThickness(1)
node = line.create()
nodepath = NodePath(node)
# nodepath.reparentTo(self.render)
nodepath.reparentTo(self.boxnode)
# nodepath.reparentTo(ball.object)
# nodepath.setColor(0,0.5,0,1)
trail.append(nodepath)
self.trails.append(trail)
return self.box.particles
def gen_linesegs(linesegs, thickness=0.001, rgba=[0, 0, 0, 1]):
"""
gen linsegs -- non-continuous segs are allowed
:param linesegs: [[pnt0, pn1], [pnt0, pnt1], ...], pnti 1x3 nparray, defined in local 0 frame
:param rgba:
:param thickness:
:param refpos, refrot: the local coordinate frame where the pnti in the linsegs are defined
:return: a geomtric model
author: weiwei
date: 20161216, 20201116
"""
M_TO_PIXEL = 3779.53
# Create a set of line segments
ls = LineSegs()
ls.setThickness(thickness * M_TO_PIXEL)
ls.setColor(rgba[0], rgba[1], rgba[2], rgba[3])
for p0p1tuple in linesegs:
ls.moveTo(p0p1tuple[0][0], p0p1tuple[0][1], p0p1tuple[0][2])
ls.drawTo(p0p1tuple[1][0], p0p1tuple[1][1], p0p1tuple[1][2])
# Create and return a node with the segments
lsnp = NodePath(ls.create())
lsnp.setTransparency(TransparencyAttrib.MDual)
lsnp.setLightOff()
ls_sgm = StaticGeometricModel(lsnp)
return ls_sgm
def createCurve(self):
self.curve = []
self.progress = 0
self.showCurve = True
lineThickness = 2
ls = LineSegs("LogSpiral")
ls.setThickness(lineThickness)
iteration_count = 10001
step_delta = 0.001
curve_length = step_delta * iteration_count
for index in np.arange(1 + (curve_length * self.truncate_percentage),
curve_length, step_delta):
# Calculate curve point position
spiral_x = self.radius_scale * self.a * pow(
math.e, self.k * index) * math.cos(index)
spiral_y = self.radius_scale * self.a * pow(
math.e, self.k * index) * math.sin(index)
spiral_z = self.height_scale * self.height_scale * math.log(
index, math.e) + self.lower_bound
if (self.showCurve): ls.drawTo(spiral_x, spiral_y, spiral_z)
self.curve.append(Vec3(spiral_x, spiral_y, spiral_z))
self.curve.reverse()
if (self.curve_segment != None): self.curve_segment.removeNode()
node = ls.create(dynamic=False)
body = BulletRigidBodyNode("lsRB")
bodyNP = self.worldNP.attachNewNode(body)
self.curve_segment = bodyNP.attachNewNode(node)
if (not self.show_curve): self.curve_segment.hide()
def draw(self, start, end):
segs = LineSegs()
segs.set_color(*self.color)
segs.moveTo(start._vec) # access to a protected member
segs.drawTo(end._vec) # access to a protected member
segs_node = segs.create()
self.lines += [render.attachNewNode(segs_node)]
def create_line_seg(panda3d):
print("Draw LineSeg")
line = LineSegs()
print(LineSegs)
line.setThickness(4)
print(coredata["start"])
x0, y0, z0 = coredata["start"]
x1, y1, z1 = app.work_plane_mouse
line.setColor(1.0, 0.0, 0.0, 1.0)
line.moveTo(x0, y0, z0)
line.drawTo(x1, y1, z1)
coredata["line"] = line
node = line.create(dynamic=True)
node_path = NodePath(node)
node_path.reparentTo(panda3d.render)
coredata["line_node"] = node_path
return line, node
def makeGizmoAxis(self, axis, text, textOffset=1.1):
color = Vec4(0, 0, 0, 1)
color[axis] = 1
pos = Vec3(0, 1, 0)
if axis == 1:
pos[1] = -pos[1]
if axis == 1:
textOffset = -textOffset
direction = Vec3(0)
direction[axis] = 1
segs = LineSegs()
segs.setColor(color)
segs.moveTo(Point3(0))
segs.drawTo(pos)
np = self.np.attachNewNode(segs.create())
np.lookAt(direction)
tn = TextNode('gizmoAxis%iText' % axis)
tn.setTextColor(color)
tn.setAlign(TextNode.ACenter)
tn.setText(text)
tnnp = np.attachNewNode(tn.generate())
tnnp.setY(textOffset)
tnnp.setBillboardPointEye()
tnnp.setScale(0.5)
return np
def create(self, s):
segs = LineSegs( )
segs.setThickness( 2.0 )
segs.setColor( Vec4(1,0,0,1) )
segs.moveTo( s.points[0] )
for p in s.points[1:]:
segs.drawTo( p )
return segs.create( )
def plot_zero_lines(self):
plot_zero = LineSegs()
plot_zero.setThickness(2.0)
plot_zero.setColor(Vec4(1, 0, 1, 1))
plot_zero.moveTo(-1, 0, self.x_mag)
plot_zero.drawTo(1, 0, self.x_mag)
plot_zero.moveTo(-1, 0, self.y_mag)
plot_zero.drawTo(1, 0, self.y_mag)
base.render2d.attach_new_node(plot_zero.create(True))
def _drawActualDroneLine(self):
self.actualDroneLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 0.0, 0.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.actualDronePosition)
node = ls.create()
self.actualDroneLineNP = self.base.render.attachNewNode(node)
def _drawSetpointLine(self):
self.setpointNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(1.0, 1.0, 1.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.setpoint)
node = ls.create()
self.setpointNP = self.base.render.attachNewNode(node)
def _drawForceLine(self):
self.forceLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 1.0, 0.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.getPos() + self.rigidBody.getTotalForce() * 0.2)
node = ls.create()
self.forceLineNP = self.base.render.attachNewNode(node)
def _drawVelocityLine(self):
self.velocityLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 0.0, 1.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.getPos() + self.getVel())
node = ls.create()
self.velocityLineNP = self.base.render.attachNewNode(node)
def draw_edge(self, e, e_color):
line_drawer = LineSegs('line_drawer')
line_drawer.setColor(e_color)
line_drawer.setThickness(1.5)
line_drawer.moveTo(e.v1.pos)
line_drawer.drawTo(e.v2.pos)
edge_node = line_drawer.create()
rendered_edge = self.render_root.attachNewNode(edge_node)
self.render_nodes['edge_' + str(e.ID)] = rendered_edge
def plot_zero_lines(self):
plot_zero = LineSegs()
plot_zero.setThickness(2.0)
plot_zero.setColor(Vec4(1, 0, 1, 1))
plot_zero.moveTo(-1, 0, self.x_mag)
plot_zero.drawTo(1, 0, self.x_mag)
plot_zero.moveTo(-1, 0, self.y_mag)
plot_zero.drawTo(1, 0, self.y_mag)
base.render2d.attach_new_node(plot_zero.create(True))
def draw_line(self,p,col):
line = LineSegs()
line.setColor(col[0],col[1],col[2], 1)
line.setThickness(2)
line.moveTo(p[0],p[1],0)
line.drawTo(p[2],p[3],0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def draw(self, start, end):
if self.car.fsm.getCurrentOrNextState() != 'Results':
if self.car.name == game.player_car.name:
segs = LineSegs()
segs.set_color(*self.color)
segs.moveTo(start)
segs.drawTo(end)
segs_node = segs.create()
self.gnd_lines += [render.attachNewNode(segs_node)]
def draw_edge(self,e,e_color):
line_drawer = LineSegs('line_drawer')
line_drawer.setColor(e_color)
line_drawer.setThickness(1.5)
line_drawer.moveTo(e.v1.pos)
line_drawer.drawTo(e.v2.pos)
edge_node = line_drawer.create()
rendered_edge = self.render_root.attachNewNode(edge_node)
self.render_nodes['edge_'+str(e.ID)] = rendered_edge
def drawLineSeg(self, loader, parent, start, end):
lines = LineSegs()
lines.setThickness(5.0)
lines.setColor(VBase4(1, 0.5, 0.5, 1.0))
lines.moveTo(start)
lines.drawTo(end)
np = parent.attachNewNode(lines.create())
np.setDepthWrite(True)
np.setDepthTest(True)
def draw(self, subdiv=1000):
ls = LineSegs('mopath')
p = Point3()
for ti in range(subdiv):
t = float(ti) / float(subdiv) * self.maxT
tp = self.calcTime(t)
self.xyzNurbsCurve.getPoint(tp, p)
ls.drawTo(p)
return NodePath(ls.create())
def fire_laser(self, panda3dworld, entity_id):
now = globalClock.getRealTime()
if now - self.last_time_laser_fired < self.laser_reload_time:
if defines.ENTITIES[entity_id]["CATEGORY"] == "ship":
panda3dworld.keys["fire"] = 0
elif defines.ENTITIES[entity_id]["CATEGORY"] == "ship2":
panda3dworld.keys["p2fire"] = 0
else:
self.last_time_laser_fired = now
pos = defines.ENTITIES[entity_id]["NODE"].getPos()
angle = 360 - defines.ENTITIES[entity_id]["NODE"].getR()
# print angle
start_pos_x = pos.x + 0.5 * cos(angle * pi / 180)
start_pos_y = pos.z + 0.5 * sin(angle * pi / 180)
pos_x = pos.x + 10 * cos(angle * pi / 180)
pos_y = pos.z + 10 * sin(angle * pi / 180)
callback = test_laser_collision(start_pos_x, start_pos_y, pos_x, pos_y)
if callback.hit:
pos_x = callback.point.x
pos_y = callback.point.y
for contact_id, entity in defines.ENTITIES.items():
if entity["BODY"].fixtures[0] == callback.fixture:
if (
entity["CATEGORY"] == "ship"
or entity["CATEGORY"] == "ship2"
or entity["CATEGORY"] == "asteroid"
):
entity["SHIELD"] -= 10
elif entity["CATEGORY"] == "bullet":
defines.ENTITIES[contact_id]["NODE"].removeNode()
defines.ENTITIES[contact_id]["PHYSIC_NODE"].removeNode()
defines.world.DestroyBody(defines.ENTITIES[contact_id]["BODY"])
del defines.ENTITIES[contact_id]
ls = LineSegs("lines")
ls.setColor(1, 1, 1, 1)
ls.drawTo(start_pos_x, 55, start_pos_y)
ls.drawTo(pos_x, 55, pos_y)
laser = ls.create(False)
laserPath = render.attachNewNode(laser)
laserPath.setBin("unsorted", 0)
laserPath.setDepthTest(False)
sound = base.loader.loadSfx("sounds/laser.ogg")
sound.setVolume(0.2)
sound.play()
taskMgr.doMethodLater(0.05, remove_laser_task, "remove laser", extraArgs=[laserPath], appendTask=True)
defines.ENTITIES[entity_id]["ENERGY"] -= 5
if defines.ENTITIES[entity_id]["CATEGORY"] == "ship":
panda3dworld.keys["fire"] = 0
elif defines.ENTITIES[entity_id]["CATEGORY"] == "ship2":
panda3dworld.keys["p2fire"] = 0
def draw_path(self,path):
if self.vis:
self.vis.removeNode()
l=LineSegs()
l.setColor(1,0,0,1)
l.setThickness(2)
l.moveTo(path[0])
for point in path:
l.drawTo(point)
self.vis=render.attachNewNode(l.create())
self.vis.setZ(0.5)
def draw_cross(self, deg_per_pixel):
cross = LineSegs()
cross.setThickness(2.0)
# cross hair is 1/2 degree visual angle,
# so go 1/4 on each side
dist_from_center = 0.25 / deg_per_pixel
cross.moveTo(0 + dist_from_center, 55, 0)
cross.drawTo(0 - dist_from_center, 55, 0)
cross.moveTo(0, 55, 0 - dist_from_center)
cross.drawTo(0, 55, 0 + dist_from_center)
self.x_node = self.base.render.attachNewNode(cross.create(True))
self.x_node.hide()
def createGrid(self):
segs = LineSegs()
segs.setThickness(4.0)
segs.setColor(Vec4(1, 1, 0, 0.3))
for i in xrange(self.level.maxX):
segs.moveTo(i + 1, 0, utils.GROUND_LEVEL)
segs.drawTo(i + 1, self.level.maxY, utils.GROUND_LEVEL + 0.02)
for j in xrange(self.level.maxY):
segs.moveTo(0, j + 1, utils.GROUND_LEVEL)
segs.drawTo(self.level.maxX, j + 1, utils.GROUND_LEVEL + 0.02)
self.grid = NodePath(segs.create())
self.grid.setTransparency(TransparencyAttrib.MAlpha)
def redraw_wps(self):
if not hasattr(self.mediator, 'phys'): return # first frame, refactor
if not self.mediator.phys.waypoints: return
# it may be invoked on track's destruction
if self.wp_np: self.wp_np.remove_node()
segs = LineSegs()
for w_p in self.mediator.phys.waypoints:
for dest in w_p.prevs:
segs.moveTo(w_p.pos)
segs.drawTo(dest.pos)
segs_node = segs.create()
self.wp_np = render.attach_new_node(segs_node)
def drawWheelBase(self):
wheelSegs = LineSegs("wheelBase")
wheelSegs.setThickness(5)
wheelSegs.moveTo(self.wheelFront + Vec3(0.0, 5.0, 1.44))
wheelSegs.drawTo(self.wheelFront + Vec3(0.0, -5.0, 1.44))
wheelSegs.moveTo(self.wheelBack + Vec3(0.0, 5.0, 1.44))
wheelSegs.drawTo(self.wheelBack + Vec3(0.0, -5.0, 1.44))
wheelNode = wheelSegs.create()
wheelNodePath = self.car.attachNewNode(wheelNode)
return wheelNodePath
def __init__(self, widget, axis):
TransformWidgetAxis.__init__(self, widget, axis)
segs = LineSegs()
segs.setThickness(2)
vertices = LEUtils.circle(0, 0, 1, 64)
for i in range(len(vertices)):
x1, y1 = vertices[i]
x2, y2 = vertices[(i + 1) % len(vertices)]
segs.moveTo(x1, 0, y1)
segs.drawTo(x2, 0, y2)
self.axisCircle = self.attachNewNode(segs.create())
self.axisCircle.setAntialias(AntialiasAttrib.MLine)
def create_lines(joints, color, thickness=5.0):
for node, parent in joints:
if parent is not None:
lines = LineSegs()
lines.setThickness(thickness)
lines.setColor(color)
lines.moveTo(0, 0, 0)
lines.drawTo(node.getPos(parent))
np = parent.attachNewNode(lines.create())
np.setDepthWrite(True)
np.setDepthTest(True)
def draw(self, subdiv = 1000):
""" Draws a quick and cheesy visualization of the Mopath using
LineSegs. Returns the NodePath representing the drawing. """
ls = LineSegs('mopath')
p = Point3()
for ti in range(subdiv):
t = float(ti) / float(subdiv) * self.maxT
tp = self.calcTime(t)
self.xyzNurbsCurve.getPoint(tp, p)
ls.drawTo(p)
return NodePath(ls.create())
def __init__(self):
BareBonesEditor.__init__(self)
camera.setPos( 0.0, 0.0, 50.0)
camera.lookAt(0)
# hole1 = HorseShoeCentered()
# hole2 = SquareOffCenter()
# holes = []
# holes.append(hole1)
# holes.append(hole2)
#
# map10 = SquareMap10x10()
# mapWholes = []
# mapWholes.append(map10)
# mapWholes.append(holes)
# for i in mapWholes:
# print "mapWholes", i
#
# mesh_trilator = makeTriMesh(mapWholes[0], mapWholes[1]) # , holes) ############
mapThrs = TheirMap()
# for i in mapThrs:
# print "mapThrs", i
mesh_trilator = makeTriMesh(mapThrs[0], mapThrs[1]) # , holes) ###########
aLst = AdjacencyList(mesh_trilator[1])
# for i in aLst.aLst:
# print i
indsNP = drawInds(aLst.adjLst) # put text on each triangle
indsNP.setPos(0, 0, .2)
indsNP.setColor(0, 1, 1, 1)
mapNP = render.attachNewNode(mesh_trilator[0])
wireNP = render.attachNewNode('wire')
wireNP.setPos(0, 0, .1)
wireNP.setColor(1, 0, 0, 1)
wireNP.setRenderMode(RenderModeAttrib.MWireframe, .5, 0)
mapNP.instanceTo(wireNP)
# aStar = TriangulationAStar(aLst.adjLst, Point3(-11, -11, 0), Point3(11, 11, 0))aLst.adjLst[11].getCenter()
aStar = TriangulationAStarR(aLst.adjLst, Point3(-11, 11, 0), aLst.adjLst[17].getCenter(), radius=.55)
path = aStar.AStar()
print "\n\nEND PATH\n", path
# https://www.panda3d.org/manual/index.php?title=Putting_your_new_geometry_in_the_scene_graph&diff=prev&oldid=6303
linesegs = LineSegs("lines")
linesegs.setColor(0, 0, 1, 1)
linesegs.setThickness(5)
for p in path:
linesegs.drawTo(p)
node = linesegs.create(False)
nodePath = render.attachNewNode(node)
nodePath.setZ(.15)
def __make_border__(cls, parent, thickness, color, l, r , b, t):
moveto_drawto = (
((l,0,t), (l,0,b)),
((r,0,t), (r,0,b)),
((l,0,b), (r,0,b)),
((l,0,t), (r,0,t)),
)
for moveto, drawto in moveto_drawto:
Border = LineSegs()
Border.setThickness(thickness)
Border.setColor(*color)
Border.moveTo(*moveto)
Border.drawTo(*drawto)
b = parent.attachNewNode(Border.create())
b.setBin(*cls.DRAW_ORDER['border'])
def line_small_lakes(self):
for l in range(len(small_lake_lines)):
line = LineSegs()
line.setColor(0,0,0, 1)
line.setThickness(2)
for n in range(len(small_lake_lines[l])):
x = (small_lake_nodes[small_lake_lines[l][n]]["x"]-map_center[0])*amplification
y = (small_lake_nodes[small_lake_lines[l][n]]["y"]-map_center[1])*amplification
if n == 0:
line.moveTo(x,y,0)
else:
line.drawTo(x,y,0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def line_border(self):
line = LineSegs()
line.setColor(0,0,0, 1)
line.setThickness(5)
x1 = (175.152-map_center[0])*amplification
x2 = (177.358-map_center[0])*amplification
y1 = (-38.808-map_center[1])*amplification
y2 = (-37.462-map_center[1])*amplification
line.moveTo(x1,y1,0)
line.drawTo(x1,y2,0)
line.drawTo(x2,y2,0)
line.drawTo(x2,y1,0)
line.drawTo(x1,y1,0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def _createDebugLine(self, points, connectToEnd=False):
""" Helper for visualizing the light bounds.
Draws a line trough all points. When connectToEnd is true,
the last point will get connected to the first point. """
segs = LineSegs()
segs.setThickness(1.0)
segs.setColor(Vec4(1, 1, 0, 1))
segs.moveTo(points[0])
for point in points[1:]:
segs.drawTo(point)
if connectToEnd:
segs.drawTo(points[0])
return NodePath(segs.create())
def selection_ring_create(self, segments = 16,size = 1.0):
ls = LineSegs()
ls.setThickness(2)
ls.setColor(0.8,0.8,0.8)
radians = deg2Rad(360)
for i in range(segments+1):
a = radians * i / segments
y = math.sin(a)*size
x = math.cos(a)*size
ls.drawTo(x, y, 0.2)
node = ls.create()
return NodePath(node)
def draw_floor_plane(self,size,granularity):
line_drawer = LineSegs('grid_line_drawer')
line_drawer.setColor(0.0,0.0,0.0,1.0)
line_drawer.setThickness(1.0)
for i in range(-size,size+1,granularity):
line_drawer.moveTo(Vec3(float(i),float(-size),0.0))
line_drawer.drawTo(Vec3(float(i),float(size),0.0))
for i in range(-size,size+1,granularity):
line_drawer.moveTo(Vec3(float(-size),float(i),0.0))
line_drawer.drawTo(Vec3(float(size),float(i),0.0))
edge_node = line_drawer.create()
rendered_edges = render.attachNewNode(edge_node)
rendered_edges.setTransparency(TransparencyAttrib.MAlpha)
rendered_edges.setAlphaScale(0.5)
return 0
def make_circle(self, radius, center, color=None):
circle = LineSegs()
circle.setThickness(2.0)
if not color:
circle.setColor(1, 1, 0, 1)
else:
circle.setColor(color)
angle_radians = radians(360)
# print alpha_pos
for i in range(50):
a = angle_radians * i / 49
y = radius * sin(a)
x = radius * cos(a)
circle.drawTo((x + center[0], self.drawing_layer, y + center[2]))
if not color:
self.alpha_circle_node.append(self.base.render.attachNewNode(circle.create()))
else:
self.base.render.attachNewNode(circle.create())
def walkJointHierarchy(self, actor, part, parentNode = None, indent = ""):
if isinstance(part, CharacterJoint):
np = actor.exposeJoint(None, 'modelRoot', part.getName())
if parentNode and parentNode.getName() != "root":
lines = LineSegs()
lines.setThickness(3.0)
lines.setColor(random.random(), random.random(), random.random())
lines.moveTo(0, 0, 0)
lines.drawTo(np.getPos(parentNode))
lnp = parentNode.attachNewNode(lines.create())
lnp.setBin("fixed", 40)
lnp.setDepthWrite(False)
lnp.setDepthTest(False)
parentNode = np
for child in part.getChildren():
self.walkJointHierarchy(actor, child, parentNode, indent + " ")
def update_avt_p(self, t_time):
avt = LineSegs()
avt.setThickness(5)
avt.setColor(self.avatar_color[0], self.avatar_color[1], self.avatar_color[2])
group_avatar = []
while self.avatar_pt[-1] < t_time:
group_avatar.append(self.avatar_pos.pop())
# print points
self.avatar_pt.pop()
if not self.avatar_pt:
break
# print('positions', group_avatar)
if group_avatar:
avt.moveTo(self.last_avt[0], self.drawing_layer, self.last_avt[1])
self.last_avt = [i * self.scale_factor for i in group_avatar[0]]
for i in group_avatar:
# print(i[0], i[1], i[2])
pos = [j * self.scale_factor for j in i]
avt.drawTo(pos[0], self.drawing_layer, pos[1])
self.avatar_node.append(self.base.render.attachNewNode(avt.create()))
def frame_loop(self, task):
dt = task.time - task.last
task.last = task.time
plot_x = LineSegs()
plot_x.setThickness(2.0)
plot_x.setColor(Vec4(1, 1, 0, 1))
plot_x.moveTo(self.time, 55, self.old_x)
plot_y = LineSegs()
plot_y.setThickness(2.0)
plot_y.moveTo(self.time, 55, self.old_y)
self.time += dt
plot_x.drawTo(self.time, 55, self.x_mag)
plot_y.drawTo(self.time, 55, self.y_mag)
self.old_x = self.x_mag
self.old_y = self.y_mag
node = render.attachNewNode(plot_x.create())
self.plot.append(node)
node = render.attachNewNode(plot_y.create())
self.plot.append(node)
if self.time > 20:
self.clear_plot()
return task.cont
def __init__(self):
ShowBase.__init__(self)
#BareBonesEditor.__init__(self)
PanditorDisableMouseFunc()
camera.setPos( 0.0, 0.0, 50.0)
camera.lookAt(0.0)
PanditorEnableMouseFunc()
# mapThrs = TheirMap()
mapThrs = CrossWithHole()
print mapThrs[1]
mesh_trilator = makeTriMesh(mapThrs[0], mapThrs[1]) # , holes) ###########
aLst = AdjacencyList(mesh_trilator[1])
indsNP = drawInds(aLst.adjLst) # put text on each triangle
indsNP.setPos(0.0, 0.0, .2)
indsNP.setColor(0.0, 1.0, 1.0, 1.0)
mapNP = render.attachNewNode(mesh_trilator[0])
wireNP = render.attachNewNode('wire')
wireNP.setPos(0.0, 0.0, .1)
wireNP.setColor(1.0, 0.0, 0.0, 1)
wireNP.setRenderMode(RenderModeAttrib.MWireframe, .5, 0)
mapNP.instanceTo(wireNP)
aStar = TriangulationAStarR(aLst.adjLst, Point3(0.0, -5.0, 0.0), Point3(0.0, 5.5, 0.0), radius=0.0)
# aStar = TriangulationAStarR(aLst.adjLst, Point3(aLst.adjLst[17].getCenter() + Point3(5, 0, 0)), Point3(0, 11, 0), radius=.55)
# aStar = TriangulationAStarR(aLst.adjLst, Point3(-5, 4, 0), Point3(aLst.adjLst[17].getCenter() + Point3(5, 0, 0)), radius=.55)
path = aStar.AStar()
print "\n\nEND PATH\n", path
# https://www.panda3d.org/manual/index.php?title=Putting_your_new_geometry_in_the_scene_graph&diff=prev&oldid=6303
linesegs = LineSegs("lines")
linesegs.setColor(0, 0, 1, 1)
linesegs.setThickness(5)
for p in path:
linesegs.drawTo(p)
node = linesegs.create(False)
nodePath = render.attachNewNode(node)
nodePath.setZ(.15)
def __init__(self, parent, color, hpr, dim):
PandaNode.__init__(self, dim+'handle')
self.path = NodePath(self)
self.parent = parent
self.dim = dim
arrow = GeomNode('gnode')
arrow.addGeomsFrom(self.geomNode)
arrownp = self.path.attachNewNode(arrow)
arrownp.hide(BitMask32(1))
clickNode = ClickableNode('clicknode')
clickNode.setDepthLevel(0.5)
clickNode.addMouseListener(self)
clicknp = self.path.attachNewNode(clickNode)
clickgeom = clicknp.attachNewNode(GeomNode('clicknode'))
clickgeom.hide(BitMask32(7))
clickgeom.node().addGeomsFrom(self.clickableGeomNode)
linesegs = LineSegs()
linesegs.setColor(color)
linesegs.setThickness(2)
linesegs.moveTo(Vec3(0, 0, -30))
linesegs.drawTo(Vec3(0, 0, -0.5))
linesegs.moveTo(Vec3(0, 0, 0.5))
linesegs.drawTo(Vec3(0, 0, 30))
lines = self.path.attachNewNode(linesegs.create())
lines.show(BitMask32(1))
lines.hide(BitMask32(2|4|8|16))
lines.setBin('opaque', 30, 100)
lines.setAntialias(AntialiasAttrib.MNone)
self.path.setColor(color)
self.path.setHpr(hpr)
self.mDownPos = Vec2()
def show_window(self):
# draw line around target representing how close the subject has to be looking to get reward
# print('show window around square', square_pos)
photo_window = LineSegs()
photo_window.setThickness(2.0)
photo_window.setColor(1, 0, 0, 1)
photo_window.moveTo(self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
# photo_window.drawTo(self.tolerance[0], 55, -self.tolerance[1] - 100)
photo_window.drawTo(self.tolerance[0], 55, -self.tolerance[1])
# print photo_window.getCurrentPosition()
# photo_window.drawTo(-self.tolerance[0], 55, -self.tolerance[1] - 100)
photo_window.drawTo(-self.tolerance[0], 55, -self.tolerance[1])
# print photo_window.getCurrentPosition()
photo_window.drawTo(-self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
photo_window.drawTo(self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
node = self.base.render.attachNewNode(photo_window.create(True))
node.show(BitMask32.bit(0))
node.hide(BitMask32.bit(1))
self.photo_window.append(node)
def getWidthAcrossEdges(self, searchTri, edge1, edge2):
"""Calculates the path width through this triangle. Edge1 and edge2 are the edges being crossed."""
# this calculates the distance from the point shared by edge1 and edge2 to the nearest obstacle
# 1st it sets the width of the triangle to the shortest edge being crossed
# then it searches across the third edge to see if there is an obstacle closer than its own vertices
# yes that can happen!!!
for p in edge1:
if p in edge2:
pt = p # get the point that both edges share. This is the point we are measuring the distance to.
if edge2 == searchTri.getEdge12() and searchTri.n12 is None\
or edge2 == searchTri.getEdge23() and searchTri.n23 is None\
or edge2 == searchTri.getEdge13() and searchTri.n13 is None:
# if edge2 is on a constrained side swap it for edge1
# doint this makes it so we only have to check edge1. It cuts our code for the next step in half.
tmp = edge2
edge2 = edge1
edge1 = tmp
# TODO make this work with edge 1, 2, & 3 and local vars nayb 1, 2, & 3 so it's not sooo much code
if edge1 == searchTri.getEdge12() and searchTri.n12 is None:
if edge2 == searchTri.getEdge23() and searchTri.n23 is None:
# Both search edges are constrained, so the width of the triangle is the width of the third edge.
return getDistance(searchTri.getPoint1(), searchTri.getPoint3())
elif edge2 == searchTri.getEdge13() and searchTri.n13 is None:
# ditto
return getDistance(searchTri.getPoint2(), searchTri.getPoint3())
else:
# the other edge is not constrained, so the initial width
# should be the shortest of either the length of this unconstrained edge
# or the distance from its non-shared point to the constrained side
if edge2 == searchTri.getEdge23():
minWidth = getDistance(searchTri.getPoint2(), searchTri.getPoint3())
# we also need to find the end point for the next step
if pt != edge2[0]:
otherPt = edge2[0]
else:
otherPt = edge2[1]
else: # the other (non-constrained) edge is 13
minWidth = getDistance(searchTri.getPoint1(), searchTri.getPoint3())
# we also need to find the end point for the next step
if pt != edge2[0]:
otherPt = edge2[0]
else:
otherPt = edge2[1]
# so now get the distance from the end to the other (constrained) edge
debugEdgeConstrained = edge1 ############################# DEBUG
distAcrossTri = getDistance(getNearestPointOnLine(otherPt, edge1),
otherPt)
if distAcrossTri < minWidth:
minWidth = distAcrossTri
# ########################### this next bit seems off
else:
minWidth = getDistance(searchTri.getPoint1(), searchTri.getPoint3())
elif edge1 == searchTri.getEdge13() and searchTri.n13 is None:
if edge2 == searchTri.getEdge23() and searchTri.n23 is None:
# both are constrained, so the width of the triangle is the length of the unconstrained edge
return getDistance(searchTri.getPoint1(), searchTri.getPoint2())
elif edge2 == searchTri.getEdge12() and searchTri.n12 is None:
return getDistance(searchTri.getPoint2(), searchTri.getPoint3())
else:
# the other edge is not constrained, so the initial width
# should be either the length of this unconstrained edge
# or the distance from its non-shared point to the constrained side, whichever is shortest
if edge2 == searchTri.getEdge23():
minWidth = getDistance(searchTri.getPoint2(), searchTri.getPoint3())
# we also need to find the end point for the next step
if pt != edge2[0]:
otherPt = edge2[0]
else:
otherPt = edge2[1]
else: # the other (non-constrained) edge is 12
minWidth = getDistance(searchTri.getPoint1(), searchTri.getPoint2())
# we also need to find the end point for the next step
if pt != edge2[0]:
otherPt = edge2[0]
else:
otherPt = edge2[1]
# so now get the distance from the end to the other (constrained) edge
debugEdgeConstrained = edge1 ############################# DEBUG
distAcrossTri = getDistance(getNearestPointOnLine(otherPt, edge1),
otherPt)
if distAcrossTri < minWidth:
minWidth = distAcrossTri
# ########################### this next bit seems off
else:
minWidth = getDistance(searchTri.getPoint1(), searchTri.getPoint3())
elif edge1 == searchTri.getEdge23() and searchTri.n23 is None:
if edge2 == searchTri.getEdge13() and searchTri.n13 is None:
# both are constrained, so the width of the triangle is the length of the unconstrained edge
return getDistance(searchTri.getPoint1(), searchTri.getPoint2())
elif edge2 == searchTri.getEdge12() and searchTri.n12 is None:
return getDistance(searchTri.getPoint1(), searchTri.getPoint2())
else:
# the other edge is not constrained, so the initial width
# should be either the length of this unconstrained edge
# or the distance from its non-shared point to the constrained side, whichever is shortest
if edge2 == searchTri.getEdge12():
minWidth = getDistance(searchTri.getPoint1(), searchTri.getPoint2())
# we also need to find the end point for the next step
if pt != edge2[0]:
otherPt = edge2[0]
else:
otherPt = edge2[1]
else: # the other (non-constrained) edge is 13
minWidth = getDistance(searchTri.getPoint1(), searchTri.getPoint3())
# we also need to find the end point for the next step
if pt != edge2[0]:
otherPt = edge2[0]
else:
otherPt = edge2[1]
# so now get the distance from the end to the other (constrained) edge
debugEdgeConstrained = edge1 ############################# DEBUG
distAcrossTri = getDistance(getNearestPointOnLine(otherPt, edge1),
otherPt)
if distAcrossTri < minWidth:
minWidth = distAcrossTri
# ########################### this next bit seems off
else:
minWidth = getDistance(searchTri.getPoint1(), searchTri.getPoint3())
else: # edge1 and edge2 are not constrained
# Get the width of the shortest of the these two edges
minWidth = min((edge1[0] - edge1[1]).length(), (edge2[0] - edge2[1]).length())
# if minWidth < 1:
# print "minWidth < 1 pt = ", pt, " || otherPt = ", otherPt, " || debugConstrained = ", debugEdgeConstrained
# save these so we don't consider them as nearest points later, else every triangle's width will be 0
edgePts = [edge1[0], edge1[1]]
edgePts.extend([edge2[0], edge2[1]])
# FINALLY search across the third edge for a constrained edge
# that's closer (to the shared point) than this triangle's vertices
# print self.adjLst
# ###################################################
counter = 0
# ###################################################
for t in range(0, len(self.adjLst)):
# if the edge is constrained, check to see if it narrows the width of this path
tri = self.adjLst[t]
# print tri
if tri.selfInd != searchTri.selfInd:
if tri.n12 is None:
# if the constrained edge, is on the opposite side
# from the point shared between the shared edges i.e. for point C check across edge c
nearest = getNearestPointOnLine(pt, [tri.tri[0], tri.tri[1]], True)
# print tri.selfInd, " 12 is none nearest", nearest
if isPointInWedge(nearest, edge1, edge2) and nearest not in edgePts:
# and it's in the wedge, check the distance against the current minimum width
newW = getDistance(pt, nearest)
# print "in wedge newW", newW
if newW < minWidth:
# ####################################################
from panda3d.core import LineSegs
# print "pt = ", pt, " || nearest = ", nearest
counter += 1
linesegs2 = LineSegs("lines" + str(counter))
linesegs2.setColor(0, 1, 1, 1)
linesegs2.setThickness(5)
linesegs2.drawTo(pt)
linesegs2.drawTo(nearest)
node2 = linesegs2.create(False)
nodePath = render.attachNewNode(node2)
nodePath.setZ(.25)
# ####################################################
minWidth = newW
# do likewise for the other edges
if tri.n23 is None:
nearest = getNearestPointOnLine(pt, [tri.tri[1], tri.tri[2]], True)
# print tri.selfInd, " 23 is none nearest", nearest
if isPointInWedge(nearest, edge1, edge2) and nearest not in edgePts:
newW = getDistance(pt, nearest)
# print "in wedge newW", newW
if newW < minWidth:
# ####################################################
from panda3d.core import LineSegs
# print "pt = ", pt, " || nearest = ", nearest
counter += 1
linesegs2 = LineSegs("lines" + str(counter))
linesegs2.setColor(0, 1, 1, 1)
linesegs2.setThickness(5)
linesegs2.drawTo(pt)
linesegs2.drawTo(nearest)
node2 = linesegs2.create(False)
nodePath = render.attachNewNode(node2)
nodePath.setZ(.25)
# ####################################################
minWidth = newW
if tri.n13 is None:
nearest = getNearestPointOnLine(pt, [tri.tri[0], tri.tri[2]], True)
# print tri.selfInd, " 13 is none nearest", nearest
if isPointInWedge(nearest, edge1, edge2) and nearest not in edgePts:
newW = getDistance(pt, nearest)
# print "in wedge newW", newW
if newW < minWidth:
# ####################################################
from panda3d.core import LineSegs
# print "pt = ", pt, " || nearest = ", nearest
counter += 1
linesegs2 = LineSegs("lines" + str(counter))
linesegs2.setColor(0, 1, 1, 1)
linesegs2.setThickness(5)
linesegs2.drawTo(pt)
linesegs2.drawTo(nearest)
node2 = linesegs2.create(False)
nodePath = render.attachNewNode(node2)
nodePath.setZ(.25)
# ####################################################
minWidth = newW
return minWidth
def renderCharts(facegraph, verts, vert_indices, lineset=None):
from meshtool.filters.panda_filters.pandacore import getVertexData, attachLights, ensureCameraAt
from meshtool.filters.panda_filters.pandacontrols import KeyboardMovement, MouseDrag, MouseScaleZoom, ButtonUtils
from panda3d.core import GeomTriangles, Geom, GeomNode, GeomVertexFormat, GeomVertexData, GeomVertexWriter, LineSegs
from direct.showbase.ShowBase import ShowBase
vformat = GeomVertexFormat.getV3c4()
vdata=GeomVertexData('tris', vformat, Geom.UHDynamic)
vertex=GeomVertexWriter(vdata, 'vertex')
color=GeomVertexWriter(vdata, 'color')
colors = gen_color3(len(facegraph))
numtris = 0
for chart, data in facegraph.nodes_iter(data=True):
curcolor = next(colors)
for tri in data['tris']:
triv = verts[vert_indices[tri]]
vertex.addData3f(triv[0][0], triv[0][1], triv[0][2])
vertex.addData3f(triv[1][0], triv[1][1], triv[1][2])
vertex.addData3f(triv[2][0], triv[2][1], triv[2][2])
color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
numtris += 1
tris=GeomTriangles(Geom.UHDynamic)
tris.addConsecutiveVertices(0, 3*numtris)
tris.closePrimitive()
linenodes = []
if lineset:
for lines in lineset:
ls = LineSegs()
ls.setThickness(4)
curcolor = next(colors)
ls.setColor(curcolor[0]/256.0, curcolor[1]/256.0, curcolor[2]/256.0, 1)
tuples = False
for blah in lines:
if isinstance(blah, tuple):
tuples = True
break
if tuples:
for i, j in lines:
frompt = verts[i]
topt = verts[j]
ls.moveTo(frompt[0], frompt[1], frompt[2])
ls.drawTo(topt[0], topt[1], topt[2])
else:
for i in range(len(lines)-1):
frompt = verts[lines[i]]
topt = verts[lines[i+1]]
ls.moveTo(frompt[0], frompt[1], frompt[2])
ls.drawTo(topt[0], topt[1], topt[2])
linenodes.append(ls.create())
pgeom = Geom(vdata)
pgeom.addPrimitive(tris)
node = GeomNode("primitive")
node.addGeom(pgeom)
p3dApp = ShowBase()
#attachLights(render)
geomPath = render.attachNewNode(node)
for linenode in linenodes:
geomPath.attachNewNode(linenode)
#geomPath.setRenderModeWireframe()
ensureCameraAt(geomPath, base.cam)
boundingSphere = geomPath.getBounds()
base.cam.setPos(boundingSphere.getCenter() + boundingSphere.getRadius())
base.cam.lookAt(boundingSphere.getCenter())
KeyboardMovement()
ButtonUtils(geomPath)
MouseDrag(geomPath)
MouseScaleZoom(geomPath)
#render.setShaderAuto()
p3dApp.run()
def __init__(self):
ShowBase.__init__(self)
winProps = WindowProperties()
winProps.setTitle("Triangle and SimpleCircle Unittest")
# base.win.requestProperties(winProps) (same as below e.g. self == base)
self.win.requestProperties(winProps)
# 1) create GeomVertexData
frmt = GeomVertexFormat.getV3n3cp()
vdata = GeomVertexData('triangle_developer', frmt, Geom.UHDynamic)
# 2) create Writers/Rewriters (must all be created before any readers and readers are one-pass-temporary)
vertex = GeomVertexRewriter(vdata, 'vertex')
normal = GeomVertexRewriter(vdata, 'normal')
color = GeomVertexRewriter(vdata, 'color')
zUp = Vec3(0, 0, 1)
wt = Vec4(1.0, 1.0, 1.0, 1.0)
gr = Vec4(0.5, 0.5, 0.5, 1.0)
# 3) write each column on the vertex data object (for speed, have a different writer for each column)
def addPoint(x, y, z):
vertex.addData3f(x, y, z)
normal.addData3f(zUp)
color.addData4f(wt)
addPoint(0.0, 0.0, 0.0)
addPoint(5.0, 0.0, 0.0)
addPoint(0.0, 5.0, 0.0)
addPoint(15.0, 15.0, 0.0)
# 4) create a primitive and add the vertices via index (not truely associated with the actual vertex table, yet)
tris = GeomTriangles(Geom.UHDynamic)
t1 = Triangle(0, 1, 2, vdata, tris, vertex)
t2 = Triangle(2, 1, 3, vdata, tris, vertex)
c1 = t1.getCircumcircle()
t1AsEnum = t1.asPointsEnum()
r0 = (t1AsEnum.point0 - c1.center).length()
r1 = (t1AsEnum.point1 - c1.center).length()
r2 = (t1AsEnum.point2 - c1.center).length()
assert abs(r0 - r2) < utilities.EPSILON and abs(r0 - r1) < utilities.EPSILON
t2AsEnum = t2.asPointsEnum()
c2 = t2.getCircumcircle()
r0 = (t2AsEnum.point0 - c2.center).length()
r1 = (t2AsEnum.point1 - c2.center).length()
r2 = (t2AsEnum.point2 - c2.center).length()
assert abs(r0 - r2) < utilities.EPSILON and abs(r0 - r1) < utilities.EPSILON
assert t1.getAngleDeg0() == 90.0
assert t1.getAngleDeg1() == t1.getAngleDeg2()
oldInd0 = t1.pointIndex0
oldInd1 = t1.pointIndex1
oldInd2 = t1.pointIndex2
t1.pointIndex0 = t1.pointIndex1
t1.pointIndex1 = oldInd0
assert t1.pointIndex0 == oldInd1
assert t1.pointIndex1 == oldInd0
assert t1.pointIndex0 != t1.pointIndex1
t1.reverse()
assert t1.pointIndex1 == oldInd2
# 5.1) (adding to scene) create a Geom and add primitives of like base-type i.e. triangles and triangle strips
geom = Geom(vdata)
geom.addPrimitive(tris)
# 5.2) create a GeomNode to hold the Geom(s) and add the Geom(s)
gn = GeomNode('gnode')
gn.addGeom(geom)
# 5.3) attache the node to the scene
gnNodePath = render.attachNewNode(gn)
# setup a wire frame
wireNP = render.attachNewNode('wire')
wireNP.setPos(0.0, 0.0, .1)
wireNP.setColor(0.1, 0.1, 0.1, 1)
wireNP.setRenderMode(RenderModeAttrib.MWireframe, .5, 0)
gnNodePath.instanceTo(wireNP)
# test and draw intersections and circles
pt1 = Point3(0.0, 5.0, 0.0)
pt2 = Point3(1.0, 5.0, 0.0)
intersection = t2.getIntersectionsWithCircumcircle(pt1, pt2)
circle = t2.getCircumcircle()
cuts = 128
border = circle.getBorder(cuts, closed=True)
assert len(border) == cuts or (len(border) == cuts + 1 and border[0] == border[len(border) - 1])
n = len(border)
xMid = yMid = 0
for p in border:
xMid += p.x
yMid += p.y
mid = Point3(xMid / n, yMid / n, border[0].z)
assert mid.almostEqual(circle.center, 0.06)
assert t2.isCcw()
assert t1.containsPoint(c1.center) != t1.containsPoint(c1.center, includeEdges=False)
circleSegs = LineSegs("circleLines")
circleSegs.setColor(1.0, 0.0, 0.0, 1.0)
for p in border:
circleSegs.drawTo(*p)
circleNode = circleSegs.create(False)
circleNP = render.attachNewNode(circleNode)
circleNP.setZ(-5)
originSpot = LineSegs("intersection")
originSpot.setColor(1.0, 0.0, 0.0, 1.0)
originSpot.setThickness(10)
for p in intersection:
originSpot.drawTo(p)
spotNode = originSpot.create(False)
spotNP = render.attachNewNode(spotNode)
circleNP.setZ(-0.75)
# fix the camera rot/pos
PHF.PanditorDisableMouseFunc()
camera.setPos(0.0, 0.0, 50.0)
camera.lookAt(c2.center)
PHF.PanditorEnableMouseFunc()
class GolfScoreBoard:
notify = directNotify.newCategory('GolfScoreBoard')
def __init__(self, golfCourse):
self.golfCourse = golfCourse
self.numPlayas = len(golfCourse.avIdList)
self.avIdList = golfCourse.avIdList
self.playaTags = []
self.scoreTags = []
self.totalTags = []
self.scoreLabels = []
self.holeLabels = []
self.parLabels = []
self.numExited = 0
self.setup()
def setup(self):
self.scoreboard = DirectFrame(parent=aspect2d, relief=None, geom=DGG.getDefaultDialogGeom(), geom_color=ToontownGlobals.GlobalDialogColor, geom_scale=(1.9, 1, 1.05), pos=(0, 0, 0.375))
self.lines = LineSegs()
self.lines.setColor(0, 0, 0, 1)
self.lines.setThickness(2)
guiModel = loader.loadModel('phase_6/models/golf/golf_gui')
highlight = loader.loadModel('phase_6/models/golf/headPanel')
self.maximizeB = DirectButton(parent=base.a2dBottomRight, pos=(-0.15, 0, 0.15), relief=None, state=DGG.NORMAL, image=(guiModel.find('**/score_card_icon'), guiModel.find('**/score_card_icon_rollover'), guiModel.find('**/score_card_icon_rollover')), image_scale=(0.2, 1, 0.2), command=self.showBoard)
self.vertOffset = 0.13
self.playaTop = 0.12
horzOffset = 0.12
holeTop = 0.3
self.vCenter = 0.025
totScore = 0
totPar = 0
self.lineVStart = -0.465
self.lineHStart = 0.17
self.lineHorOffset = 0.13
self.lineVertOffset = 0.125
self.lineVCenter = 0.025
buttons = loader.loadModel('phase_3/models/gui/dialog_box_buttons_gui')
self.minimizeB = DirectButton(parent=self.scoreboard, pos=(0, 0, self.lineHStart - 0.59), relief=None, state=DGG.NORMAL, image=(buttons.find('**/CloseBtn_UP'), buttons.find('**/CloseBtn_DN'), buttons.find('**/CloseBtn_Rllvr')), image_scale=(1, 1, 1), command=self.hideBoard, extraArgs=[None])
self.exitCourseB = DirectButton(parent=self.scoreboard, pos=(0, 0, self.lineHStart - 0.59), relief=None, state=DGG.NORMAL, image=(buttons.find('**/CloseBtn_UP'), buttons.find('**/CloseBtn_DN'), buttons.find('**/CloseBtn_Rllvr')), image_scale=(1, 1, 1), text=TTLocalizer.GolfExitCourse, text_scale=0.04, text_pos=TTLocalizer.GSBexitCourseBPos, command=self.exitCourse)
self.exitCourseB.hide()
self.highlightCur = DirectLabel(parent=self.scoreboard, relief=None, pos=(-0.003, 0, 0.038), image=highlight, image_scale=(1.82, 1, 0.135))
self.titleBar = DirectLabel(parent=self.scoreboard, relief=None, pos=(-0.003, 0, 0.166), color=(0.7, 0.7, 0.7, 0.3), image=highlight, image_scale=(1.82, 1, 0.195))
self.titleBar.show()
self.highlightCur.show()
buttons.removeNode()
guiModel.removeNode()
title = GolfGlobals.getCourseName(self.golfCourse.courseId) + ' - ' + GolfGlobals.getHoleName(self.golfCourse.holeIds[self.golfCourse.curHoleIndex])
self.titleLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(0, 0, holeTop + 0.1), text_align=TextNode.ACenter, text=title, text_scale=TTLocalizer.GSBtitleLabel, text_font=ToontownGlobals.getSignFont(), text_fg=(0, 0.5, 0.125, 1))
self.playaLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart - 0.23, 0, holeTop), text_align=TextNode.ACenter, text=TTLocalizer.GolfHole, text_font=ToontownGlobals.getMinnieFont(), text_scale=0.05)
for holeLIndex in xrange(self.golfCourse.numHoles):
holeLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.055 + horzOffset * holeLIndex, 0, holeTop), text_align=TextNode.ACenter, text='%s' % (holeLIndex + 1), text_scale=0.05)
self.holeLabels.append(holeLabel)
self.totalLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.1 + horzOffset * 9.5, 0, holeTop), text_align=TextNode.ACenter, text=TTLocalizer.GolfTotal, text_font=ToontownGlobals.getMinnieFont(), text_scale=0.05)
self.parTitleLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart - 0.23, 0, holeTop - 0.1), text_align=TextNode.ACenter, text=TTLocalizer.GolfPar, text_font=ToontownGlobals.getMinnieFont(), text_scale=0.05)
for parHoleIndex in xrange(self.golfCourse.numHoles):
parLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.055 + horzOffset * parHoleIndex, 0, holeTop - 0.1), text_align=TextNode.ACenter, text='%s' % GolfGlobals.HoleInfo[self.golfCourse.holeIds[parHoleIndex]]['par'], text_scale=0.05, text_wordwrap=10)
totPar = totPar + GolfGlobals.HoleInfo[self.golfCourse.holeIds[parHoleIndex]]['par']
self.parLabels.append(parLabel)
parLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.1 + horzOffset * 9.5, 0, holeTop - 0.1), text_align=TextNode.ACenter, text='%s' % totPar, text_scale=0.05, text_wordwrap=10)
self.parLabels.append(parLabel)
vert = 0.0
self.numPlayas = len(self.golfCourse.avIdList)
for playaIndex in xrange(self.numPlayas):
name = TTLocalizer.GolfUnknownPlayer
av = base.cr.doId2do.get(self.golfCourse.avIdList[playaIndex])
if av:
name = av.getName()
playaLabel = DirectLabel(parent=self.scoreboard, relief=None, text_align=TextNode.ACenter, text=name, text_scale=0.05, text_wordwrap=9)
self.playaTags.append(playaLabel)
textN = playaLabel.component(playaLabel.components()[0])
if type(textN) == OnscreenText:
try:
if textN.textNode.getWordwrappedWtext() != name:
vert = self.playaTop - self.vertOffset * playaIndex
else:
vert = self.playaTop - self.vertOffset * playaIndex - self.vCenter
except:
vert = self.playaTop - self.vertOffset * playaIndex
self.playaTags[playaIndex].setPos(self.lineVStart - 0.23, 0, vert)
self.notify.debug('self.text height = %f' % self.playaTags[playaIndex].getHeight())
holeIndex = 0
for holeIndex in xrange(self.golfCourse.numHoles):
holeLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.055 + horzOffset * holeIndex, 0, self.playaTop - self.vertOffset * playaIndex - self.vCenter), text_align=TextNode.ACenter, text='-', text_scale=0.05, text_wordwrap=10)
self.scoreTags.append(holeLabel)
holeLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.1 + horzOffset * 9.5, 0, self.playaTop - self.vertOffset * playaIndex - self.vCenter), text_align=TextNode.ACenter, text='-', text_scale=0.05, text_wordwrap=10)
self.totalTags.append(holeLabel)
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart + 0.19)
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart + 0.09)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart + 0.09)
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart)
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart - 0.45, 0, self.lineHStart - 4 * 0.13)
self.lines.moveTo(self.lineVStart, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart, 0, self.lineHStart - 4 * 0.13)
for x in xrange(4):
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart - (x + 1) * self.lineHorOffset)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset + 0.005, 0, self.lineHStart - (x + 1) * self.lineHorOffset)
for y in xrange(10):
self.lines.moveTo(self.lineVStart + y * self.lineVertOffset, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart + y * self.lineVertOffset, 0, self.lineHStart - 4 * 0.13)
self.lines.moveTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart - 4 * 0.13)
self.scoreboard.attachNewNode(self.lines.create())
self.hide()
return
def getScoreLabel(self, avIdorIndex, holeNum):
index = None
if avIdorIndex < 100:
index = avIdorIndex
else:
for playaIndex in xrange(self.numPlayas):
if self.golfCourse.avIdList[playaIndex] == avIdorIndex:
index = playaIndex
return self.scoreTags[index * self.golfCourse.numHoles + holeNum]
def update(self):
self.showBoard()
taskMgr.doMethodLater(AUTO_HIDE_TIMEOUT, self.hideBoard, 'hide score board')
def hideBoard(self, task):
self.hide()
def hide(self):
self.scoreboard.hide()
self.maximizeB.show()
def showBoardFinal(self, task = None):
self.exitCourseB.show()
self.minimizeB.hide()
self.showBoard()
def showBoard(self, task = None):
scoreDict = self.golfCourse.scores
x = 0
currentGolfer = self.golfCourse.getCurGolfer()
for playaIndex in xrange(self.numPlayas):
if self.golfCourse.isGameDone():
self.playaTags[playaIndex].setColor(0, 0, 0, 1)
elif currentGolfer == self.golfCourse.avIdList[playaIndex]:
self.highlightCur.setColor(*GolfGlobals.PlayerColors[playaIndex])
self.highlightCur.setAlphaScale(0.4)
self.highlightCur.setPos(-0.003, 0, 0.038 - playaIndex * (self.lineVertOffset + 0.005))
self.highlightCur.show()
else:
self.playaTags[playaIndex].setColor(0, 0, 0, 1)
for avId in self.avIdList:
holeIndex = 0
totScore = 0
playerExited = False
for y in xrange(len(self.golfCourse.exitedAvIdList)):
if self.golfCourse.exitedAvIdList[y] == avId:
self.playaTags[x].setColor(0.7, 0.7, 0.7, 1)
holeIndex = 0
for holeIndex in xrange(self.golfCourse.numHoles):
self.getScoreLabel(self.avIdList[x], holeIndex).setColor(0.7, 0.7, 0.7, 1)
self.totalTags[x].setColor(0.7, 0.7, 0.7, 1)
playerExited = True
if playerExited == False:
for holeIndex in xrange(self.golfCourse.numHoles):
if holeIndex <= self.golfCourse.curHoleIndex:
self.getScoreLabel(avId, holeIndex)['text'] = '%s' % scoreDict[avId][holeIndex]
totScore = totScore + scoreDict[avId][holeIndex]
if self.golfCourse.isGameDone() == False:
if holeIndex == self.golfCourse.curHoleIndex:
self.getScoreLabel(avId, holeIndex).setColor(1, 0, 0, 1)
self.holeLabels[holeIndex].setColor(1, 0, 0, 1)
self.parLabels[holeIndex].setColor(1, 0, 0, 1)
title = GolfGlobals.getCourseName(self.golfCourse.courseId) + ' - ' + GolfGlobals.getHoleName(self.golfCourse.holeIds[self.golfCourse.curHoleIndex])
self.titleLabel['text'] = title
else:
self.getScoreLabel(avId, holeIndex).setColor(0, 0, 0, 1)
self.holeLabels[holeIndex].setColor(0, 0, 0, 1)
self.parLabels[holeIndex].setColor(0, 0, 0, 1)
self.totalTags[x]['text'] = '%s' % totScore
if self.golfCourse.isGameDone():
self.getScoreLabel(avId, self.golfCourse.numHoles - 1).setColor(0, 0, 0, 1)
self.totalTags[x].setColor(1, 0, 0, 1)
x = x + 1
y = 0
if self.golfCourse.isGameDone():
self.parLabels[self.golfCourse.numHoles - 1].setColor(0, 0, 0, 1)
self.holeLabels[self.golfCourse.numHoles - 1].setColor(0, 0, 0, 1)
self.parLabels[self.golfCourse.numHoles].setColor(1, 0, 0, 1)
self.totalLabel.setColor(1, 0, 0, 1)
self.scoreboard.show()
self.maximizeB.hide()
def exitCourse(self):
course = self.golfCourse
self.delete()
course.exitEarly()
def delete(self):
if self.maximizeB:
self.maximizeB.destroy()
self.maximizeB = None
if self.scoreboard:
self.scoreboard.destroy()
self.scoreboard = None
self.golfCourse = None
taskMgr.remove('hide score board')
return
