def makeSelectRect():
ctup = (1,1,1,1)
fmt = GeomVertexFormat.getV3c4()
vertexData = GeomVertexData('points', fmt, Geom.UHDynamic)
points = ( #makes nice for Tristrips
(0,0,0),
(0,0,1),
(1,0,0),
(1,0,1),
)
verts = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
for point in points:
verts.addData3f(*point)
color.addData4f(*ctup)
boxLines = GeomLinestrips(Geom.UHDynamic)
boxLines.addVertices(0,1,3,2)
boxLines.addVertex(0)
boxLines.closePrimitive()
boxTris = GeomTristrips(Geom.UHDynamic)
boxTris.addConsecutiveVertices(0,3)
boxTris.closePrimitive()
box = Geom(vertexData)
box.addPrimitive(boxLines)
#box.addPrimitive(boxTris)
return box
def makePoints(n=1000):
""" make a cloud of points that are a single node VS branching and making subnodes to control display """
#points = np.random.uniform(-10,10,(n,4))
points = np.random.randn(n,3)
colors = np.random.rand(n,4)
fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
verts = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
for point,clr4 in zip(points,colors):
#for point in points:
verts.addData3f(*point)
#color.addData4f(*point)
color.addData4f(*clr4)
#color.addData4f(.1,.1,.1,1)
#pointCloud = GeomLinestrips(Geom.UHStatic) #this is f*****g cool!
pointCloud = GeomTristrips(Geom.UHStatic) #this is f*****g cool!
#pointCloud = GeomPoints(Geom.UHStatic)
#pointCloud.addVerticies(*range(n))
pointCloud.addConsecutiveVertices(0,n) #warning may error since n-1?
pointCloud.closePrimitive()
cloud = Geom(vertexData)
cloud.addPrimitive(pointCloud)
return cloud
def __init__(self, base_object):
PandaNode.__init__(self, "Moon")
self.geom = GeomNode("Moon")
self.vertexData = GeomVertexData("Basis", GeomVertexFormat.getV3cpt2(),
Geom.UHStatic)
self.vertex = GeomVertexWriter(self.vertexData, 'vertex')
self.tex_coord = GeomVertexWriter(self.vertexData, 'texcoord')
self.mesh = Geom(self.vertexData)
self.tris = GeomTristrips(Geom.UHStatic)
size = 700
z = 1000
dx = 0
dy = 500
self.vertex.addData3f(z, size + dx, -size + dy)
self.tex_coord.addData2f(1.0, 0.0)
self.vertex.addData3f(z, -size + dx, -size + dy)
self.tex_coord.addData2f(1.0, 1.0)
self.vertex.addData3f(z, size + dx, size + dy)
self.tex_coord.addData2f(0.0, 0.0)
self.vertex.addData3f(z, -size + dx, size + dy)
self.tex_coord.addData2f(0.0, 1.0)
self.tris.add_vertices(0, 1, 2, 3)
self.tris.closePrimitive()
self.mesh.addPrimitive(self.tris)
self.geom.addGeom(self.mesh)
self.node = base_object.render.attachNewNode(self.geom)
self.node.set_p(90)
# self.node.set_r(-90)
# self.node.set_h(90)
# self.node.set_p(90)
# self.node.set_scale(500)
# self.node.set_pos(1.7 * self.node.get_scale()[0],
# 0,
# self.node.get_scale()[0] * 0.5)
self.texture = base_object.loader.loadTexture(
base_object.params("moon_texture"))
self.node.set_texture(self.texture)
self.node.setLightOff()
self.node.setColorOff()
self.node.setTransparency(True)
self.node.set_bin('fixed', 2)
self.node.set_depth_write(0)
self.node.set_depth_test(0)
class Earth(PandaNode):
def __init__(self, base_object):
PandaNode.__init__(self, "Earth")
self.geom = GeomNode("earth")
self.vertexData = GeomVertexData("Basis", GeomVertexFormat.getV3cpt2(),
Geom.UHStatic)
self.vertex = GeomVertexWriter(self.vertexData, 'vertex')
self.tex_coord = GeomVertexWriter(self.vertexData, 'texcoord')
self.mesh = Geom(self.vertexData)
self.tris = GeomTristrips(Geom.UHStatic)
size = 200
z = -1000
dx = 0
dy = -200
self.vertex.addData3f(z, size + dx, -size + dy)
self.tex_coord.addData2f(1.0, 0.0)
self.vertex.addData3f(z, -size + dx, -size + dy)
self.tex_coord.addData2f(1.0, 1.0)
self.vertex.addData3f(z, size + dx, size + dy)
self.tex_coord.addData2f(0.0, 0.0)
self.vertex.addData3f(z, -size + dx, size + dy)
self.tex_coord.addData2f(0.0, 1.0)
self.tris.add_vertices(1, 0, 3, 2)
self.tris.closePrimitive()
self.mesh.addPrimitive(self.tris)
self.geom.addGeom(self.mesh)
self.node = base_object.render.attachNewNode(self.geom)
self.node.set_p(90)
# self.node.set_h(90)
self.texture = base_object.loader.loadTexture(
base_object.params("earth_texture"))
self.node.set_texture(self.texture)
self.node.setLightOff()
self.node.setColorOff()
self.node.setTransparency(True)
# self.node.set_bin('fixed', 3)
# self.node.set_depth_write(0)
# self.node.set_depth_test(0)
# self.node.setBillboardPointEye()
def move(self, dx):
self.node.set_pos(self.node.get_pos() + dx)
class Sun(PandaNode):
def __init__(self, base_object):
PandaNode.__init__(self, "Sun")
self.geom = GeomNode("Sun")
self.vertexData = GeomVertexData("Basis", GeomVertexFormat.getV3cpt2(),
Geom.UHStatic)
self.vertex = GeomVertexWriter(self.vertexData, 'vertex')
self.tex_coord = GeomVertexWriter(self.vertexData, 'texcoord')
self.mesh = Geom(self.vertexData)
self.tris = GeomTristrips(Geom.UHStatic)
self.vertex.addData3f(0.0, 0.0, 0.0)
self.tex_coord.addData2f(1.0, 0.0)
self.vertex.addData3f(1.0, 0.0, 0.0)
self.tex_coord.addData2f(1.0, 1.0)
self.vertex.addData3f(0.0, 1.0, 0.0)
self.tex_coord.addData2f(0.0, 0.0)
self.vertex.addData3f(1.0, 1.0, 0.0)
self.tex_coord.addData2f(0.0, 1.0)
self.tris.add_vertices(0, 1, 2, 3)
self.tris.closePrimitive()
self.mesh.addPrimitive(self.tris)
self.geom.addGeom(self.mesh)
self.node = base_object.render.attachNewNode(self.geom)
self.node.set_r(-90)
self.node.set_h(90)
self.node.set_scale(40)
self.node.set_pos(0, 500, 0)
self.texture = base_object.loader.loadTexture(
base_object.params("sun_texture"))
self.node.set_texture(self.texture)
self.node.setLightOff()
self.node.setColorOff()
self.node.setTransparency(True)
self.node.set_bin('fixed', 1)
self.node.set_depth_write(0)
self.node.set_depth_test(0)
self.node.setBillboardPointEye()
def move(self, dx):
self.node.set_pos(self.node.get_pos() + dx)
def moveForwardTask(self, task):
change = 0.7
self.counter = self.counter + change
x, y, z = self.camera.get_pos()
self.camera.set_pos(x, y + change, z)
for i in range(0, len(self.plights)):
x, y, z = self.plights[i].get_pos()
self.plights[i].set_pos(x, y + change, z)
self.render.set_light(self.plights[i])
if y > self.rows1:
self.nodeTrisPath.removeNode()
if self.counter >= 1:
if y > self.rows1:
self.newNodePath[0].removeNode()
del self.newNodePath[0]
self.counter = self.counter - 1
for x in range(0, self.cols):
nz1 = random.uniform(self.pz[x] - 1, self.pz[x] + 1)
nz2 = random.uniform(self.pz[x - 1] - 1, self.pz[x - 1] + 1)
nz3 = random.uniform(self.pz[x + 1] - 1, self.pz[x + 1] + 1)
nz = (nz1 + nz2 + nz3) / 3
self.vertex.add_data3f((x, self.rows + 1, nz))
self.vertex.add_data3f((x, self.rows, self.pz[x]))
if nz < -5:
self.color.add_data4f(0.2, 0.1, 0, 1)
elif nz < -3:
self.color.add_data4f(0, 0.2, 0.1, 1)
elif nz < 0:
self.color.add_data4f(0, 0.4, 0.2, 1)
elif nz < 4:
self.color.add_data4f(0.4, 0.4, 0.4, 1)
else:
self.color.add_data4f(1, 1, 1, 1)
if nz < -5:
self.color.add_data4f(0.2, 0.1, 0, 1)
elif nz < -3:
self.color.add_data4f(0, 0.2, 0.1, 1)
elif self.pz[x] < 0:
self.color.add_data4f(0, 0.4, 0.2, 1)
elif self.pz[x] < 4:
self.color.add_data4f(0.4, 0.4, 0.4, 1)
else:
self.color.add_data4f(1, 1, 1, 1)
self.pz[x] = nz
#print (nz)
geom = Geom(self.vdata)
prim = GeomTristrips(Geom.UH_static)
prim.addVertex(self.cols * 2 * self.rows)
prim.add_next_vertices((self.cols * 2) - 1)
prim.close_primitive()
geom.addPrimitive(prim)
node = GeomNode("TriStrips")
node.addGeom(geom)
self.newNodePath.append(self.render.attachNewNode(node))
self.rows = self.rows + 1
return Task.cont
def makeRotationGeomNode():
vdata = GeomVertexData('rotHandleData', GeomVertexFormat.getV3(),
Geom.UHStatic)
v = GeomVertexWriter(vdata, 'vertex')
radius = 0.7
width = 0.08
res = 30
innerRad = radius - width
for i in xrange(res):
theta = i * (2 * pi / res)
v.addData3f(innerRad * sin(theta), innerRad * cos(theta), width / 2.0)
v.addData3f(innerRad * sin(theta), innerRad * cos(theta), -width / 2.0)
v.addData3f(radius * sin(theta), radius * cos(theta), width / 2.0)
v.addData3f(radius * sin(theta), radius * cos(theta), -width / 2.0)
circle = Geom(vdata)
# Make prims for the faces of the torus
faces = [GeomTristrips(Geom.UHStatic) for i in xrange(4)]
for i in xrange(res):
i = i * 4
faces[0].addVertices(i + 1, i)
faces[1].addVertices(i + 2, i + 1)
faces[2].addVertices(i + 3, i + 2)
faces[3].addVertices(i, i + 3)
for i in xrange(4):
faces[i].addVertices((i + 1) % 4, i)
faces[i].closePrimitive()
circle.addPrimitive(faces[i])
node = GeomNode('geomnode')
node.addGeom(circle)
return node
def create_model(self):
vdata = GeomVertexData('name', Diagram.gformat, Geom.UHStatic)
vdata.setNumRows(len(self.values)*2)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
prim = GeomTristrips(Geom.UHStatic)
i = 0
for x, z in self.values:
vertex.addData3(0, x, 0)
color.addData4(0, 0, 1, 1)
prim.addVertex(i)
vertex.addData3(0, x, z/100)
color.addData4(0, 0, 1, 1)
prim.addVertex(i+1)
i += 2
prim.closePrimitive()
diagram_geom = Geom(vdata)
diagram_geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(diagram_geom)
node.setTag('entity_type', self.__class__.__name__)
node.setTag('entity_id', self.entity_id)
model_parent = self.parent.geom[0]
parent_scale = model_parent.getScale()
nodePath = render.attachNewNode(node)
nodePath.reparentTo(model_parent)
nodePath.set_two_sided(True)
nodePath.setLightOff()
node_parent = self.parent.start.geom[0]
L = self.parent.longitude()
h = 1
nodePath.setScale(h / parent_scale[2], 1 / parent_scale[1], 1 / parent_scale[0])
nodePath.wrtReparentTo(node_parent)
"""
model = app.base.loader.loadModel("data/geom/plate")
model.set_two_sided(True)
model.setTag('entity_type', self.__class__.__name__)
model.setTag('entity_id', self.entity_id)
self.geom = [model]"""
self.update_model()
def createTristrips(self, pointCount, startPoint):
prim = GeomTristrips(Geom.UHStatic)
for i in xrange(pointCount):
prim.addVertex(i+startPoint)
prim.addVertex(i+startPoint+pointCount)
prim.closePrimitive()
return prim
def makeSelectRect():
ctup = (1, 1, 1, 1)
fmt = GeomVertexFormat.getV3c4()
vertexData = GeomVertexData('points', fmt, Geom.UHDynamic)
points = ( #makes nice for Tristrips
(0, 0, 0),
(0, 0, 1),
(1, 0, 0),
(1, 0, 1),
)
verts = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
for point in points:
verts.addData3f(*point)
color.addData4f(*ctup)
boxLines = GeomLinestrips(Geom.UHDynamic)
boxLines.addVertices(0, 1, 3, 2)
boxLines.addVertex(0)
boxLines.closePrimitive()
boxTris = GeomTristrips(Geom.UHDynamic)
boxTris.addConsecutiveVertices(0, 3)
boxTris.closePrimitive()
box = Geom(vertexData)
box.addPrimitive(boxLines)
#box.addPrimitive(boxTris)
return box
def makePoints(n=1000):
""" make a cloud of points that are a single node VS branching and making subnodes to control display """
#points = np.random.uniform(-10,10,(n,4))
points = np.random.randn(n, 3)
colors = np.random.rand(n, 4)
fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
verts = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
for point, clr4 in zip(points, colors):
#for point in points:
verts.addData3f(*point)
#color.addData4f(*point)
color.addData4f(*clr4)
#color.addData4f(.1,.1,.1,1)
#pointCloud = GeomLinestrips(Geom.UHStatic) #this is f*****g cool!
pointCloud = GeomTristrips(Geom.UHStatic) #this is f*****g cool!
#pointCloud = GeomPoints(Geom.UHStatic)
#pointCloud.addVerticies(*range(n))
pointCloud.addConsecutiveVertices(0, n) #warning may error since n-1?
pointCloud.closePrimitive()
cloud = Geom(vertexData)
cloud.addPrimitive(pointCloud)
return cloud
def __init__(self, mp):
vdata = GeomVertexData("name_me", GeomVertexFormat.getV3c4(), Geom.UHStatic)
vertex = GeomVertexWriter(vdata, "vertex")
color = GeomVertexWriter(vdata, "color")
primitive = GeomTristrips(Geom.UHStatic)
film_size = base.cam.node().getLens().getFilmSize()
x = film_size.getX() / 2.0
z = x * 256.0 / 240.0
vertex.addData3f(x, 90, z)
vertex.addData3f(-x, 90, z)
vertex.addData3f(x, 90, -z)
vertex.addData3f(-x, 90, -z)
color.addData4f(VBase4(*mp["backgroundcolor1"]))
color.addData4f(VBase4(*mp["backgroundcolor1"]))
color.addData4f(VBase4(*mp["backgroundcolor2"]))
color.addData4f(VBase4(*mp["backgroundcolor2"]))
primitive.addNextVertices(4)
primitive.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(primitive)
self.node = GeomNode("sky")
self.node.addGeom(geom)
base.camera.attachNewNode(self.node)
def make_cube(x, y, z): # FIXME make prism
""" make x, y, z sized cube (ints pls) """
colors = [[1,1,1,0] for i in range(8)]
#colors[0] = np.array((1,1,1,1))
#colors[1] = np.array((1,0,0,0))
#colors[2] = np.array((0,1,0,0))
#colors[5] = np.array((0,0,1,0))
points = (
(0,0,0),
(0,0,z),
(0,y,0),
(0,y,z),
(x,0,0),
(x,0,z),
(x,y,0),
(x,y,z),
)
order = [0, 5, 1, 7, 3, 2, 1, 0, 5, 4, 7, 6, 2, 4, 0] # perfect for clockwise
#order = [2, 6, 3, 7, 5, 6, 4, 2, 0, 3, 1, 4, 0, 4]
#order.reverse()
#order = [4, 3, 7, 8, 5, 3, 1, 4, 2, 7, 6, 5, 2, 1]
fmt = GeomVertexFormat.getV3c4()
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
verts = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
for p,c in zip(points,colors):
verts.addData3f(*p)
color.addData4f(*c)
targetTris = GeomTristrips(Geom.UHStatic)
targetTris.addConsecutiveVertices(0,8)
for i in order:
targetTris.addVertex(i)#-1)
targetTris.closePrimitive()
target = Geom(vertexData)
target.addPrimitive(targetTris)
return target
def makeEquiTri():
colors = (
(1,1,1,1),
(1,0,0,1),
(0,0,1,1),
(0,1,0,1),
(1,1,1,1),
(1,0,0,1),
)
points = (
(-1,0,0),
(1,0,0),
(0,3**.5/2,3**.5),
(0,3**.5,0),
#(-1,0,0),
#(1,0,0),
)
fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
#fmt = GeomVertexFormat.getV3() #3 component vertex, w/ 4 comp color
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
verts = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
for p,c in zip(points,colors):
verts.addData3f(*p)
color.addData4f(*c)
targetTris = GeomTristrips(Geom.UHStatic)
targetTris.addConsecutiveVertices(0,4)
targetTris.addVertex(0)
targetTris.addVertex(1)
targetTris.closePrimitive()
target = Geom(vertexData)
target.addPrimitive(targetTris)
return target
def _generate_mesh(radius: float, count: int) -> Geom:
"""Generate mesh for the ground plane."""
vertex_data = GeomVertexData('ground', VERTEX_FORMAT, Geom.UH_static)
vertex_data.set_num_rows(count**2)
vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
normal_writer = GeomVertexWriter(vertex_data, 'normal')
texcoord_writer = GeomVertexWriter(vertex_data, 'texcoord')
step = 2 * radius / count
for i, j in product(range(count + 1), repeat=2):
vertex_writer.add_data3f(i * step - radius, j * step - radius, 0.0)
normal_writer.add_data3f(0.0, 0.0, 1.0)
texcoord_writer.add_data2f(i * 512, j * 512)
geom = Geom(vertex_data)
primitive = GeomTristrips(Geom.UH_static)
for j in range(count):
rows = range(count + 1) if j % 2 else reversed(range(count + 1))
for i in rows:
primitive.add_vertex((j + (j + 1) % 2) * (count + 1) + i)
primitive.add_vertex((j + j % 2) * (count + 1) + i)
primitive.close_primitive()
geom.add_primitive(primitive)
return geom
def _generate_mesh(node: Node) -> Geom:
"""Generate mesh for a Node."""
size = len(node.geometry.polygon)
vertex_data = GeomVertexData(str(node.id), VERTEX_FORMAT, Geom.UH_static)
vertex_data.set_num_rows(size)
vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
normal_writer = GeomVertexWriter(vertex_data, 'normal')
texcoord_writer = GeomVertexWriter(vertex_data, 'texcoord')
indexes = [range(i - 1, i + 2) for i in range(0, size, 2)]
triangles = [[node.geometry.polygon[j] for j in t] for t in indexes]
for point in node.geometry.polygon:
vertex_writer.add_data3f(point.x, point.y, LEVEL_HEIGHT * node.level)
normal_writer.add_data3f(0.0, 0.0, 1.0)
texcoord_writer.add_data2f(point.x / LANE_WIDTH, point.y / LANE_WIDTH)
indexes = [
i for i, t in zip(indexes, triangles)
if not t[0].close_to(t[1]) and not t[1].close_to(t[2])
]
geom = Geom(vertex_data)
primitive = GeomTriangles(Geom.UH_static)
for index in chain.from_iterable(indexes):
primitive.add_vertex(index % size)
primitive.close_primitive()
geom.add_primitive(primitive)
if size > 4:
primitive = GeomTristrips(Geom.UH_static)
for index in (i if i % 2 else -i - 1 for i in range(size // 2)):
primitive.add_vertex(index % size)
primitive.close_primitive()
geom.add_primitive(primitive)
return geom
def primitives(self, vdata):
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
r = int(self.diameter / 2.0)
n = 0
for i in range(-r, r + 1, self.resolution):
for j in range(-r, r + 1, self.resolution):
h = elevation(i, j)
vertex.addData3f(i, j, h)
color.addData4f(elevation_color(h))
n += 1
for i in range(n - 1):
row = GeomTristrips(Geom.UHStatic)
for j in range(n):
t = i * n + j
b = t + n
row.addVertices(t, b)
row.closePrimitive()
yield row
def _generate_mesh(way: Way) -> Geom:
"""Generate mesh for a Way."""
geometry = way.geometry
rows = 2 * len(geometry.segments) + 2
vertex_data = GeomVertexData(str(way.id), VERTEX_FORMAT, Geom.UH_static)
vertex_data.set_num_rows(rows)
vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
normal_writer = GeomVertexWriter(vertex_data, 'normal')
texcoord_writer = GeomVertexWriter(vertex_data, 'texcoord')
start_z = way.start.level * LEVEL_HEIGHT
end_z = way.end.level * LEVEL_HEIGHT
lanes_float = float(way.total_lane_count)
segment = geometry.segments[0]
for vertex in (segment.start_left, segment.start_right):
vertex_writer.add_data3f(vertex.x, vertex.y, start_z)
normal_writer.add_data3f(0.0, 0.0, 1.0)
texture_v = 0.0
texcoord_writer.add_data2f(0.0, texture_v)
texcoord_writer.add_data2f(lanes_float, texture_v)
lengths = [s.length() for s in geometry.segments]
total_len = sum(lengths)
for segment, acc_len in zip(geometry.segments, accumulate(lengths)):
height = start_z + (end_z - start_z) * acc_len / total_len
for vertex in (segment.end_left, segment.end_right):
vertex_writer.add_data3f(vertex.x, vertex.y, height)
normal_writer.add_data3f(0.0, 0.0, 1.0)
texture_v = acc_len / LANE_WIDTH
texcoord_writer.add_data2f(0.0, texture_v)
texcoord_writer.add_data2f(lanes_float, texture_v)
primitive = GeomTristrips(Geom.UH_static)
primitive.add_consecutive_vertices(0, rows)
primitive.close_primitive()
geom = Geom(vertex_data)
geom.add_primitive(primitive)
return geom
def primitives(self, vdata):
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
w = ROAD_WIDTH / 2.0
v = 0
for a, b in self.edges:
a, b = self.points[a], self.points[b]
ab = b - a
n = ab.length()
inc = abs(a.z - b.z) / n
probes = max(2, n / 25)
ab_ = Vec3(ab)
ab_.normalize()
pab = Vec3.up().cross(ab_) * w
road = GeomTristrips(Geom.UHStatic)
for i in range(0, int(probes) + 1):
p = a + ab / probes * i
p1 = p + pab
p2 = p - pab
z = max(elevation(p1.x, p1.y), elevation(p2.x, p2.y))
p1.z = z + 0.2
p2.z = z + 0.2
vertex.addData3f(p1)
vertex.addData3f(p2)
if inc > 0.1:
color.addData4f(0.4, 0.0, 0.0, 0.0)
color.addData4f(0.4, 0.0, 0.0, 0.0)
elif n > 1000:
color.addData4f(0.0, 0.0, 0.4, 0.0)
color.addData4f(0.0, 0.0, 0.4, 0.0)
else:
color.addData4f(0.2, 0.2, 0.2, 0.0)
color.addData4f(0.2, 0.2, 0.2, 0.0)
road.addVertices(v, v + 1)
v += 2
road.closePrimitive()
yield road
def __init__(self, mp):
vdata = GeomVertexData('name_me', GeomVertexFormat.getV3c4(),
Geom.UHStatic)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
primitive = GeomTristrips(Geom.UHStatic)
film_size = base.cam.node().getLens().getFilmSize()
x = film_size.getX() / 2.0
z = x * 256.0 / 240.0
vertex.addData3f(x, 90, z)
vertex.addData3f(-x, 90, z)
vertex.addData3f(x, 90, -z)
vertex.addData3f(-x, 90, -z)
color.addData4f(VBase4(*mp['backgroundcolor1']))
color.addData4f(VBase4(*mp['backgroundcolor1']))
color.addData4f(VBase4(*mp['backgroundcolor2']))
color.addData4f(VBase4(*mp['backgroundcolor2']))
primitive.addNextVertices(4)
primitive.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(primitive)
self.node = GeomNode('sky')
self.node.addGeom(geom)
base.camera.attachNewNode(self.node)
def drawBody(nodePath, vdata, pos, vecList, radius=1, keepDrawing=True, numVertices=8):
circleGeom = Geom(vdata)
vertWriter = GeomVertexWriter(vdata, "vertex")
colorWriter = GeomVertexWriter(vdata, "color")
normalWriter = GeomVertexWriter(vdata, "normal")
drawReWriter = GeomVertexRewriter(vdata, "drawFlag")
texReWriter = GeomVertexRewriter(vdata, "texcoord")
startRow = vdata.getNumRows()
vertWriter.setRow(startRow)
colorWriter.setRow(startRow)
normalWriter.setRow(startRow)
sCoord = 0
if (startRow != 0):
texReWriter.setRow(startRow - numVertices)
sCoord = texReWriter.getData2f().getX() + 1
drawReWriter.setRow(startRow - numVertices)
if(drawReWriter.getData1f() == False):
sCoord -= 1
drawReWriter.setRow(startRow)
texReWriter.setRow(startRow)
angleSlice = 2 * math.pi / numVertices
currAngle = 0
#axisAdj=LMatrix4.rotateMat(45, axis)*LMatrix4.scaleMat(radius)*LMatrix4.translateMat(pos)
perp1 = vecList[1]
perp2 = vecList[2]
# vertex information is written here
for i in range(numVertices):
adjCircle = pos + \
(perp1 * math.cos(currAngle) + perp2 * math.sin(currAngle)) * \
radius
normal = perp1 * math.cos(currAngle) + perp2 * math.sin(currAngle)
normalWriter.addData3f(normal)
vertWriter.addData3f(adjCircle)
texReWriter.addData2f(sCoord, (i + 0.001) / (numVertices - 1))
colorWriter.addData4f(0.5, 0.5, 0.5, 1)
drawReWriter.addData1f(keepDrawing)
currAngle += angleSlice
drawReader = GeomVertexReader(vdata, "drawFlag")
drawReader.setRow(startRow - numVertices)
# we cant draw quads directly so we use Tristrips
if (startRow != 0) & (drawReader.getData1f() != False):
lines = GeomTristrips(Geom.UHStatic)
half = int(numVertices * 0.5)
for i in range(numVertices):
lines.addVertex(i + startRow)
if i < half:
lines.addVertex(i + startRow - half)
else:
lines.addVertex(i + startRow - half - numVertices)
lines.addVertex(startRow)
lines.addVertex(startRow - half)
lines.closePrimitive()
lines.decompose()
circleGeom.addPrimitive(lines)
circleGeomNode = GeomNode("Debug")
circleGeomNode.addGeom(circleGeom)
# I accidentally made the front-face face inwards. Make reverse makes the tree render properly and
# should cause any surprises to any poor programmer that tries to use
# this code
circleGeomNode.setAttrib(CullFaceAttrib.makeReverse(), 1)
global numPrimitives
numPrimitives += numVertices * 2
nodePath.attachNewNode(circleGeomNode)
def drawBody(self, pos, quat, radius=1,UVcoord=(1,1), numVertices=_polySize):
# if isRoot:
# self.bodydata = GeomVertexData("body vertices", GeomVertexFormat.getV3n3t2(), Geom.UHStatic)
vdata = self.bodydata
circleGeom = Geom(vdata) # this was originally a copy of all previous geom in vdata...
vertWriter = GeomVertexWriter(vdata, "vertex")
#colorWriter = GeomVertexWriter(vdata, "color")
normalWriter = GeomVertexWriter(vdata, "normal")
# drawReWriter = GeomVertexRewriter(vdata, "drawFlag")
texReWriter = GeomVertexRewriter(vdata, "texcoord")
startRow = vdata.getNumRows()
vertWriter.setRow(startRow)
#colorWriter.setRow(startRow)
normalWriter.setRow(startRow)
texReWriter.setRow(startRow)
#axisAdj=Mat4.rotateMat(45, axis)*Mat4.scaleMat(radius)*Mat4.translateMat(pos)
perp1 = quat.getRight()
perp2 = quat.getForward()
#TODO: PROPERLY IMPLEMENT RADIAL NOISE
#vertex information is written here
angleSlice = 2 * pi / numVertices
currAngle = 0
for i in xrange(numVertices+1):
adjCircle = pos + (perp1 * cos(currAngle) + perp2 * sin(currAngle)) * radius * (.5+bNodeRadNoise*random.random())
normal = perp1 * cos(currAngle) + perp2 * sin(currAngle)
normalWriter.addData3f(normal)
vertWriter.addData3f(adjCircle)
texReWriter.addData2f(float(UVcoord[0]*i) / numVertices,UVcoord[1]) # UV SCALE HERE!
#colorWriter.addData4f(0.5, 0.5, 0.5, 1)
currAngle += angleSlice
#we cant draw quads directly so we use Tristrips
if (startRow != 0):
lines = GeomTristrips(Geom.UHStatic)
for i in xrange(numVertices+1):
lines.addVertex(i + startRow)
lines.addVertex(i + startRow - numVertices-1)
lines.addVertex(startRow)
lines.addVertex(startRow - numVertices)
lines.closePrimitive()
#lines.decompose()
circleGeom.addPrimitive(lines)
circleGeomNode = GeomNode("Debug")
circleGeomNode.addGeom(circleGeom)
self.numPrimitives += numVertices * 2
self.bodies.attachNewNode(circleGeomNode)
return circleGeomNode
def makeCylinder(vdata, numVertices=40):
topCircleGeom = makeCircle(vdata, numVertices, Vec3(0, 0, 1))
bottomCircleGeom = makeCircle(vdata, numVertices, Vec3(0, 0, 0), -1)
body = GeomTristrips(Geom.UHStatic)
j = 40
i = 0
while i < numVertices + 1:
body.addVertex(i)
body.addVertex(j)
i += 1
if j == 40:
j = 2 * numVertices - 1
else:
j -= 1
body.addVertex(i)
body.addVertex(j)
j -= 1
i += 1
body.addVertex(numVertices - 1)
body.addVertex(0)
body.addVertex(numVertices)
body.closePrimitive()
#print body
cylinderGeom = Geom(vdata)
cylinderGeom.addPrimitive(body)
cylinderGeom.copyPrimitivesFrom(topCircleGeom)
cylinderGeom.copyPrimitivesFrom(bottomCircleGeom)
cylinderGeom.decomposeInPlace()
cylinderGeom.unifyInPlace()
return cylinderGeom
def add_button(self, text, label_id, pos_x, pos_y, width=0.0, hight=0.1):
if width == 0.0:
for c in range(len(text)/2):
width += 0.08
ls = LineSegs("lines")
ls.setColor(0,1,0,1)
ls.drawTo(-width/2, 0, hight/2)
ls.drawTo(width/2, 0, hight/2)
ls.drawTo(width/2, 0,-hight/2)
ls.drawTo(-width/2, 0,-hight/2)
ls.drawTo(-width/2, 0, hight/2)
border = ls.create(False)
border.setTag('back_ground', '1')
array = GeomVertexArrayFormat()
array.addColumn("vertex", 4, Geom.NTFloat32, Geom.CPoint)
arr_format = GeomVertexFormat()
arr_format.addArray(array)
arr_format = GeomVertexFormat.registerFormat(arr_format)
vdata = GeomVertexData('fill', arr_format, Geom.UHStatic)
vdata.setNumRows(4)
vertex = GeomVertexWriter(vdata, 'vertex')
vertex.addData3f(-width/2, 0, hight/2)
vertex.addData3f(width/2, 0, hight/2)
vertex.addData3f(-width/2, 0,-hight/2)
vertex.addData3f(width/2, 0,-hight/2)
prim = GeomTristrips(Geom.UHStatic)
prim.addVertex(0)
prim.addVertex(1)
prim.addVertex(2)
prim.addVertex(3)
geom = Geom(vdata)
geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(geom)
nodePath = NodePath("button")
nodePath.attachNewNode(node)
nodePath.setPos(0,0,0)
nodePath.setTag('button', '1')
nodePath.setBin("unsorted", 0)
nodePath.setDepthTest(False)
nodePath.setColor(0,0,0,1)
nodePath.attachNewNode(border)
nodePath1 = NodePath("button")
nodePath1.attachNewNode(node)
nodePath1.setPos(0,0,0)
nodePath1.setTag('button1', '1')
nodePath1.setBin("unsorted", 0)
nodePath1.setDepthTest(False)
nodePath1.setColor(0,1,0,1)
nodePath1.attachNewNode(border)
button=DirectFrame(
enableEdit=1,
text=text,
geom=nodePath,
text_scale=0.05,
text_fg=(0,1,0,1),
borderWidth=(1,1),
relief = None,
text_pos=(0,-0.01,0),
textMayChange=1,
state=DGG.NORMAL,
parent=aspect2d
)
button.setPos(pos_x,0,pos_y)
button.bind(DGG.B1PRESS, button_click, [button])
button.bind(DGG.WITHIN, button_hover, [button])
button.bind(DGG.WITHOUT, button_no_hover, [button])
# button.resetFrameSize()
# self.button.bind(DGG.WITHIN, self.onMouseHoverInFunction, [button, some_value1])
defines.ENTITIES[defines.ENTITY_ID] = {'CATEGORY':'button', 'BUTTON':button, 'NODE':nodePath, 'LABEL':label_id,'STATUS': 0}
defines.ENTITY_ID += 1
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.seeNode = self.render.attachNewNode("see")
self.cam.reparentTo(self.seeNode)
self.cam.setPos(0, 0, 5)
self.fpscamera = fpscontroller.FpsController(self, self.seeNode)
self.fpscamera.setFlyMode(True)
self.prevPos = self.fpscamera.getPos()
self.prevInto = None
self.info = self.genLabelText("Position: <unknown>", 4)
self.makeInstructions()
self.initCollisions()
self.leftColor = LVecBase4i(224, 224, 64, 255)
self.rightColor = LVecBase4i(64, 224, 224, 255)
self.isDrawing = False
self.toggleDrawing()
self.accept("escape", sys.exit) # Escape quits
self.accept("enter", self.toggleDrawing)
def initCollisions(self):
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
self.cTrav.showCollisions(self.render)
# self.cQueue = CollisionHandlerQueue()
# Initialize the Pusher collision handler.
# self.pusher = CollisionHandlerPusher()
self.pusher = CollisionHandlerFloor()
### player
print DirectNotifyGlobal.directNotify.getCategories()
# Create a collsion node for this object.
playerNode = CollisionNode("player")
playerNode.addSolid(CollisionSphere(0, 0, 0, 1))
# playerNode.setFromCollideMask(BitMask32.bit(0))
# playerNode.setIntoCollideMask(BitMask32.allOn())
# Attach the collision node to the object's model.
self.playerC = self.fpscamera.player.attachNewNode(playerNode)
# Set the object's collision node to render as visible.
self.playerC.show()
# Add the 'player' collision node to the Pusher collision handler.
# self.pusher.addCollider(self.playerC, self.fpscamera.player)
# self.pusher.addCollider(playerC, self.fpscamera.player)
# self.cTrav.addCollider(self.playerC, self.cQueue)
def toggleDrawing(self):
self.isDrawing = not self.isDrawing
if self.isDrawing:
self.drawText.setText("Enter: Turn off drawing")
self.fpscamera.setFlyMode(True)
self.prevPos = None
self.cTrav.removeCollider(self.playerC)
self.pusher.removeCollider(self.playerC)
self.removeTask("updatePhysics")
self.addTask(self.drawHere, "drawHere")
self.geomNode = GeomNode("geomNode")
self.geomNodePath = self.render.attachNewNode(self.geomNode)
self.geomNodePath.setTwoSided(True)
# apparently p3tinydisplay needs this
self.geomNodePath.setColorOff()
# Create a collision node for this object.
self.floorCollNode = CollisionNode("geom")
# self.floorCollNode.setFromCollideMask(BitMask32.bit(0))
# self.floorCollNode.setIntoCollideMask(BitMask32.allOn())
# Attach the collision node to the object's model.
floorC = self.geomNodePath.attachNewNode(self.floorCollNode)
# Set the object's collision node to render as visible.
floorC.show()
# self.pusher.addCollider(floorC, self.geomNodePath)
self.newVertexData()
self.newGeom()
else:
self.drawText.setText("Enter: Turn on drawing")
self.removeTask("drawHere")
if self.prevPos:
self.completePath()
self.fpscamera.setFlyMode(True)
self.drive.setPos(self.fpscamera.getPos())
self.cTrav.addCollider(self.playerC, self.pusher)
self.pusher.addCollider(self.playerC, self.fpscamera.player)
self.taskMgr.add(self.updatePhysics, "updatePhysics")
def newVertexData(self):
fmt = GeomVertexFormat.getV3c4()
# fmt = GeomVertexFormat.getV3n3c4()
self.vertexData = GeomVertexData("path", fmt, Geom.UHStatic)
self.vertexWriter = GeomVertexWriter(self.vertexData, "vertex")
# self.normalWriter = GeomVertexWriter(self.vertexData, 'normal')
self.colorWriter = GeomVertexWriter(self.vertexData, "color")
def newGeom(self):
self.triStrips = GeomTristrips(Geom.UHDynamic)
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.triStrips)
def makeInstructions(self):
OnscreenText(text="Draw Path by Walking", style=1, fg=(1, 1, 0, 1), pos=(0.5, -0.95), scale=0.07)
self.drawText = self.genLabelText("", 0)
self.genLabelText("Walk (W/S/A/D), Jump=Space, Look=PgUp/PgDn", 1)
self.genLabelText(" (hint, go backwards with S to see your path immediately)", 2)
self.genLabelText("ESC: Quit", 3)
def genLabelText(self, text, i):
return OnscreenText(text=text, pos=(-1.3, 0.95 - 0.05 * i), fg=(1, 1, 0, 1), align=TextNode.ALeft, scale=0.05)
def drawHere(self, task):
pos = self.fpscamera.getPos()
self.info.setText(
"Position: {0}, {1}, {2} at {3} by {4}".format(
int(pos.x * 100) / 100.0,
int(pos.y * 100) / 100.0,
int(pos.z) / 100.0,
self.fpscamera.getHeading(),
self.fpscamera.getLookAngle(),
)
)
prevPos = self.prevPos
if not prevPos:
self.prevPos = pos
elif (pos - prevPos).length() > 1:
self.drawQuadTo(prevPos, pos, 2)
row = self.vertexWriter.getWriteRow()
numPrims = self.triStrips.getNumPrimitives()
if numPrims == 0:
primVerts = row
else:
primVerts = row - self.triStrips.getPrimitiveEnd(numPrims - 1)
if primVerts >= 4:
self.triStrips.closePrimitive()
if row >= 256:
print "Packing and starting anew"
newGeom = True
self.geom.unifyInPlace(row, False)
else:
newGeom = False
self.completePath()
if newGeom:
self.newVertexData()
self.newGeom()
if not newGeom:
self.triStrips.addConsecutiveVertices(row - 2, 2)
else:
self.drawQuadTo(prevPos, pos, 2)
self.leftColor[1] += 63
self.rightColor[2] += 37
self.prevPos = pos
return task.cont
def drawLineTo(self, pos, color):
self.vertexWriter.addData3f(pos.x, pos.y, pos.z)
# self.normalWriter.addData3f(0, 0, 1)
self.colorWriter.addData4i(color)
self.triStrips.addNextVertices(1)
def drawQuadTo(self, a, b, width):
""" a (to) b are vectors defining a line bisecting a new quad. """
into = b - a
if abs(into.x) + abs(into.y) < 1:
if not self.prevInto:
return
into = self.prevInto
print into
else:
into.normalize()
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
if self.vertexWriter.getWriteRow() == 0:
self.drawQuadRow(a, into, width)
self.drawQuadRow(b, into, width)
self.prevInto = into
def drawQuadRow(self, a, into, width):
""" a defines a point, with 'into' being the normalized direction. """
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
aLeft = Vec3(a.x - into.y * width, a.y + into.x * width, a.z)
aRight = Vec3(a.x + into.y * width, a.y - into.x * width, a.z)
row = self.vertexWriter.getWriteRow()
self.vertexWriter.addData3f(aLeft)
self.vertexWriter.addData3f(aRight)
# self.normalWriter.addData3f(Vec3(0, 0, 1))
# self.normalWriter.addData3f(Vec3(0, 0, 1))
self.colorWriter.addData4i(self.leftColor)
self.colorWriter.addData4i(self.rightColor)
self.triStrips.addConsecutiveVertices(row, 2)
def completePath(self):
self.geomNode.addGeom(self.geom)
if self.triStrips.getNumPrimitives() == 0:
return
floorMesh = CollisionFloorMesh()
tris = self.triStrips.decompose()
p = 0
vertexReader = GeomVertexReader(self.vertexData, "vertex")
for i in range(tris.getNumPrimitives()):
v0 = tris.getPrimitiveStart(i)
ve = tris.getPrimitiveEnd(i)
if v0 < ve:
vertexReader.setRow(tris.getVertex(v0))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(tris.getVertex(v0 + 1))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(tris.getVertex(v0 + 2))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
floorMesh.addTriangle(p, p + 1, p + 2)
p += 3
self.floorCollNode.addSolid(floorMesh)
def updatePhysics(self, task):
pos = self.fpscamera.getPos()
self.info.setText(
"Position: {0}, {1}, {2}".format(int(pos.x * 100) / 100.0, int(pos.y * 100) / 100.0, int(pos.z) / 100.0)
)
return task.cont
def makeCylinder(vdata,numVertices=40): topCircleGeom=makeCircle(vdata, numVertices,Vec3(0,0, 1)) bottomCircleGeom=makeCircle(vdata, numVertices,Vec3(0,0,0),-1) body=GeomTristrips(Geom.UHStatic) j=40 i=0 while i < numVertices+1: body.addVertex(i) body.addVertex(j) i+=1 if j==40: j=2*numVertices-1 else: j-=1 body.addVertex(i) body.addVertex(j) j-=1 i+=1 body.addVertex(numVertices-1) body.addVertex(0) body.addVertex(numVertices) body.closePrimitive() #print body cylinderGeom=Geom(vdata) cylinderGeom.addPrimitive(body) cylinderGeom.copyPrimitivesFrom(topCircleGeom) cylinderGeom.copyPrimitivesFrom(bottomCircleGeom) cylinderGeom.decomposeInPlace() cylinderGeom.unifyInPlace() return cylinderGeom
def _generate_mesh(points: List[Point]) -> Geom:
"""Generate mesh for a Path."""
def calc_color(param):
return interpolate_rgb(START_COLOR, END_COLOR, param)
if len(points) < 2:
return Geom()
vertex_data = GeomVertexData('path', VERTEX_FORMAT, Geom.UH_static)
vertex_data.set_num_rows(2 * len(points) + 1)
vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
normal_writer = GeomVertexWriter(vertex_data, 'normal')
color_writer = GeomVertexWriter(vertex_data, 'color')
length = sum(p1.distance(p2) for p1, p2 in window_iter(points))
vector = points[1] - points[0]
distance = vector.norm()
position = distance / length
vector = vector.normalized()
width_vector = LANE_WIDTH * 0.5 * vector.rotated_left()
for vertex in (points[0] + width_vector, points[0] - width_vector):
vertex_writer.add_data3f(vertex.x, vertex.y, HEIGHT)
normal_writer.add_data3f(0.0, 0.0, 1.0)
color_writer.add_data4f(*START_COLOR)
last_vector = vector
for point, next_ in zip(islice(points, 1, None), islice(points, 2, None)):
vector = next_ - point
distance = vector.norm()
vector = vector.normalized()
try:
bisector = (last_vector + vector).normalized()
width_vector = (sec(bisector, vector) * 0.5 * LANE_WIDTH
* bisector.rotated_left())
except ZeroDivisionError:
width_vector = vector.rotated_right() * 0.5 * LANE_WIDTH
color = calc_color(position)
for vertex in (point + width_vector, point - width_vector):
vertex_writer.add_data3f(vertex.x, vertex.y, HEIGHT)
normal_writer.add_data3f(0.0, 0.0, 1.0)
color_writer.add_data4f(*color)
position = position + distance / length
last_vector = vector
point = points[-1]
width_vector = 0.5 * LANE_WIDTH * last_vector.rotated_left()
distance = LANE_WIDTH if distance > LANE_WIDTH else distance / 2
vector = -last_vector * distance
for vertex in (point + width_vector + vector,
point - width_vector + vector,
point):
vertex_writer.add_data3f(vertex.x, vertex.y, HEIGHT)
normal_writer.add_data3f(0.0, 0.0, 1.0)
color_writer.add_data4f(*END_COLOR)
primitive = GeomTristrips(Geom.UH_static)
primitive.add_consecutive_vertices(0, 2 * len(points) + 1)
primitive.close_primitive()
geom = Geom(vertex_data)
geom.add_primitive(primitive)
return geom
def newGeom(self):
self.triStrips = GeomTristrips(Geom.UHDynamic)
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.triStrips)
def generate(
self
): # call this after setting some of the variables to update it
if not self.vertices:
return
if hasattr(self, 'geomNode'):
self.geomNode.removeAllGeoms()
static_mode = Geom.UHStatic if self.static else Geom.UHDynamic
formats = {
(0, 0, 0): GeomVertexFormat.getV3(),
(1, 0, 0): GeomVertexFormat.getV3c4(),
(0, 1, 0): GeomVertexFormat.getV3t2(),
(0, 0, 1): GeomVertexFormat.getV3n3(),
(1, 0, 1): GeomVertexFormat.getV3n3c4(),
(1, 1, 0): GeomVertexFormat.getV3c4t2(),
(0, 1, 1): GeomVertexFormat.getV3n3t2(),
(1, 1, 1): GeomVertexFormat.getV3n3c4t2(),
}
vertex_format = formats[(bool(self.colors), bool(self.uvs),
bool(self.normals))]
vdata = GeomVertexData('name', vertex_format, static_mode)
vdata.setNumRows(len(self.vertices)) # for speed
vertexwriter = GeomVertexWriter(vdata, 'vertex')
for v in self.vertices:
vertexwriter.addData3f((v[0], v[2], v[1])) # swap y and z
if self.colors:
colorwriter = GeomVertexWriter(vdata, 'color')
for c in self.colors:
colorwriter.addData4f(c)
if self.uvs:
uvwriter = GeomVertexWriter(vdata, 'texcoord')
for uv in self.uvs:
uvwriter.addData2f(uv[0], uv[1])
if self.normals != None:
normalwriter = GeomVertexWriter(vdata, 'normal')
for norm in self.normals:
normalwriter.addData3f((norm[0], norm[2], norm[1]))
modes = {
'triangle': GeomTriangles(static_mode),
'tristrip': GeomTristrips(static_mode),
'ngon': GeomTrifans(static_mode),
'line': GeomLines(static_mode),
'lines': GeomLinestrips(static_mode),
'point': GeomPoints(static_mode),
}
if self.mode == 'line' and len(self.vertices) % 2 > 0:
if len(self.vertices) == 1:
self.mode = point
print(
'warning: number of vertices must be even for line mode, ignoring last vert'
)
self.vertices = self.vertices[:len(self.vertices) - 1]
prim = modes[self.mode]
if self._triangles:
if isinstance(self._triangles[0], int):
for t in self._triangles:
prim.addVertex(t)
elif len(
self._triangles[0]
) >= 3: # if tris are tuples like this: ((0,1,2), (1,2,3))
for t in self._triangles:
if len(t) == 3:
for e in t:
prim.addVertex(e)
elif len(t) == 4: # turn quad into tris
prim.addVertex(t[0])
prim.addVertex(t[1])
prim.addVertex(t[2])
prim.addVertex(t[2])
prim.addVertex(t[3])
prim.addVertex(t[0])
else:
prim.addConsecutiveVertices(0, len(self.vertices))
prim.close_primitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
self.geomNode = GeomNode('mesh')
self.geomNode.addGeom(geom)
self.attachNewNode(self.geomNode)
# print('finished')
self.recipe = f'''Mesh(
def makeClickableGeom():
vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(),
Geom.UHStatic)
v = GeomVertexWriter(vdata, 'vertex')
length = 1.0
cylRad = 0.10
circRes = 8
# Add vertices cylinder.
for z in [length/2.0, -length/2.0]:
for i in xrange(circRes):
theta = i*(2*pi/circRes)
v.addData3f(cylRad*sin(theta), cylRad*cos(theta), z)
geom = Geom(vdata)
# Make polys for the circles
CCW = 1
CW = 0
for i, wind in ((0, CCW), (circRes, CW)):
circle = GeomTristrips(Geom.UHStatic)
l = range(i, i+circRes)
for i in xrange(1-wind, (len(l)-wind)/2):
l.insert(2*i+wind, l.pop())
for v in l:
circle.addVertex(v)
circle.closePrimitive()
geom.addPrimitive(circle)
# Make polys for the cylinder.
cyl = GeomTristrips(Geom.UHStatic)
for i in xrange(circRes):
cyl.addVertex(i + circRes)
cyl.addVertex(i)
cyl.addVertex(circRes)
cyl.addVertex(0)
cyl.closePrimitive()
geom.addPrimitive(cyl)
node = GeomNode('geomnode')
node.addGeom(geom)
return node
def getGeomTristrips(self):
if self._geomTristrips is None:
self._geomTristrips = GeomTristrips(Geom.UHStatic)
return self._geomTristrips
def primitives(self, vdata):
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
n = len(self.border)
# Points
for p in self.border:
vertex.addData3f(p.x, p.y, p.z)
color.addData4f(0.5, 0.5, 0.5, 0.0)
for p in self.border:
vertex.addData3f(p.x, p.y, p.z + self.top)
color.addData4f(1.0, 1.0, 1.0, 0.0)
# Wall
wall = GeomTristrips(Geom.UHStatic)
for i in range(n):
wall.addVertices(i, i + n)
wall.addVertices(0, n)
wall.closePrimitive()
yield wall
# Ceiling
if self.cover:
ceil = GeomTristrips(Geom.UHStatic)
ceil.addConsecutiveVertices(n, n)
ceil.addVertex(n)
ceil.closePrimitive()
yield ceil
def drawBody(self, pos, quat, radius=1, keepDrawing=True, numVertices=16):
"""
this draws the body of the tree. This draws a ring of vertices and
connects the rings with triangles to from the body.
the keepDrawing parameter tells the function whether or not we're
at an end
if the vertices before were an end, don't draw branches to it
"""
vdata = self.bodydata
circleGeom = Geom(vdata)
vertWriter = GeomVertexWriter(vdata, "vertex")
normalWriter = GeomVertexWriter(vdata, "normal")
texReWriter = GeomVertexRewriter(vdata, "texcoord")
startRow = vdata.getNumRows()
vertWriter.setRow(startRow)
normalWriter.setRow(startRow)
sCoord = 0
if (startRow != 0):
texReWriter.setRow(startRow - numVertices)
sCoord = texReWriter.getData2f().getX() + 1
draw = (startRow - numVertices) in self.drawFlags
if not draw:
sCoord -= 1
drawIndex = startRow
texReWriter.setRow(startRow)
angleSlice = 2 * math.pi / numVertices
currAngle = 0
perp1 = quat.getRight()
perp2 = quat.getForward()
#vertex information is written here
for i in xrange(numVertices + 1):
#doubles the last vertex to fix UV seam
adjCircle = pos + (perp1 * math.cos(currAngle) +
perp2 * math.sin(currAngle)) * radius
normal = perp1 * math.cos(currAngle) + perp2 * math.sin(currAngle)
normalWriter.addData3f(normal)
vertWriter.addData3f(adjCircle)
texReWriter.addData2f(1.0 * i / numVertices, sCoord)
if keepDrawing:
self.drawFlags.add(drawIndex)
drawIndex += 1
currAngle += angleSlice
draw = (startRow - numVertices) in self.drawFlags
#we cant draw quads directly so we use Tristrips
if (startRow != 0) and draw:
lines = GeomTristrips(Geom.UHStatic)
for i in xrange(numVertices + 1):
lines.addVertex(i + startRow)
lines.addVertex(i + startRow - numVertices - 1)
lines.addVertex(startRow)
lines.addVertex(startRow - numVertices)
lines.closePrimitive()
#lines.decompose()
circleGeom.addPrimitive(lines)
circleGeomNode = GeomNode("Debug")
circleGeomNode.addGeom(circleGeom)
self.numPrimitives += numVertices * 2
self.bodies.attachNewNode(circleGeomNode)
def __init__(self):
ShowBase.__init__(self)
self.cols = 100
self.rows = 100
base.disableMouse()
base.setFrameRateMeter(True)
self.cameraHeight = 13
self.camera.set_pos(self.cols / 2, -30, self.cameraHeight)
self.camera.look_at(self.cols / 2, 300, 0)
plights = []
for i in range(0, int(self.cols / 5), 2):
plight = PointLight("plight")
plight.setColor(VBase4(1, 1, 1, 1))
plights.append(plight)
plights[i] = self.render.attachNewNode(plight)
x, y, z = self.camera.get_pos()
plights[i].setPos(self.cols / 2 + ((i - int(i / 2)) * 10), y + 20,
5)
self.render.set_light(plights[i])
plight = PointLight("plight")
plight.setColor(VBase4(1, 1, 1, 1))
plights.append(plight)
plights[i + 1] = self.render.attachNewNode(plight)
x, y, z = self.camera.get_pos()
plights[i + 1].setPos(self.cols / 2 + ((i - int(i / 2)) * 10),
y + 20, 10)
self.render.set_light(plights[i + 1])
self.plights = plights
format = GeomVertexFormat.getV3c4()
vdata = GeomVertexData('name', format, Geom.UHStatic)
vdata.setNumRows(self.cols * self.rows)
self.vertex = GeomVertexWriter(vdata, 'vertex')
self.color = GeomVertexWriter(vdata, 'color')
pz = [random.uniform(-1, 1)]
for i in range(self.rows):
pz.append(random.uniform(pz[i - 1] - 1, pz[i] + 1))
for y in range(0, self.rows):
for x in range(0, self.cols):
nz1 = random.uniform(pz[x] - 1, pz[x] + 1)
nz2 = random.uniform(pz[x - 1] - 1, pz[x - 1] + 1)
nz3 = random.uniform(pz[x + 1] - 1, pz[x + 1] + 1)
nz = (nz1 + nz2 + nz3) / 3
self.vertex.add_data3f((x, y + 1, nz))
self.vertex.add_data3f((x, y, pz[x]))
if nz < -5:
self.color.add_data4f(0.2, 0.1, 0, 1)
elif nz < -3:
self.color.add_data4f(0, 0.2, 0.1, 1)
elif nz < 0:
self.color.add_data4f(0, 0.4, 0.2, 1)
elif nz < 2:
self.color.add_data4f(0.4, 0.4, 0.4, 1)
else:
self.color.add_data4f(1, 1, 1, 1)
if nz < -5:
self.color.add_data4f(0.2, 0.1, 0, 1)
elif nz < -3:
self.color.add_data4f(0, 0.2, 0.1, 1)
elif pz[x] < 0:
self.color.add_data4f(0, 0.4, 0.2, 1)
elif pz[x] < 2:
self.color.add_data4f(0.4, 0.4, 0.4, 1)
else:
self.color.add_data4f(1, 1, 1, 1)
pz[x] = nz
#print (nz)
self.pz = pz
geom = Geom(vdata)
for y in range(0, self.rows):
prim = GeomTristrips(Geom.UH_static)
prim.addVertex(y * self.cols * 2)
prim.add_next_vertices((self.cols * 2) - 1)
prim.close_primitive()
geom.addPrimitive(prim)
nodeTris = GeomNode("TriStrips")
nodeTris.addGeom(geom)
self.nodeTrisPath = self.render.attachNewNode(nodeTris)
self.task_mgr.add(self.moveForwardTask, "moveForwardTask")
self.vdata = vdata
self.newNodePath = []
self.counter = 0
self.rows1 = self.rows
skybox = self.loader.loadModel("models/skybox.bam")
skybox.reparent_to(self.render)
skybox.set_scale(20000)
skybox_texture = self.loader.loadTexture("textures/dayfair.jpg")
skybox_texture.set_minfilter(SamplerState.FT_linear)
skybox_texture.set_magfilter(SamplerState.FT_linear)
skybox_texture.set_wrap_u(SamplerState.WM_repeat)
skybox_texture.set_wrap_v(SamplerState.WM_mirror)
skybox_texture.set_anisotropic_degree(16)
skybox.set_texture(skybox_texture)
skybox_shader = Shader.load(Shader.SL_GLSL, "skybox.vert.glsl",
"skybox.frag.glsl")
skybox.set_shader(skybox_shader)
def newGeom(self):
self.triStrips = GeomTristrips(Geom.UHDynamic)
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.triStrips)
def __init__(self,
center: Vec3,
width,
height,
x_grid,
y_grid,
refinement_level=1,
is_hill=True,
map_style="pointy"):
Hexagon.counter += 1
self.vx_center: Vec3 = center
self.refinement_level = refinement_level
self.width = width
self.height = height
self.x_grid = x_grid
self.y_grid = y_grid
self.adjacent_hexagons = []
if map_style == "pointy":
self.adjacent_hexagons = [
Orientation.North, Orientation.NorthEast,
Orientation.SouthEast, Orientation.South,
Orientation.SouthWest, Orientation.NorthWest
]
# self.master_point_indices: List[int] = []
# self.ref_points_indices: List[List[int]] = []
self.triangulation: List[GeomTriangles] = []
self.ref_points_indices: List[List[int]] = []
self.connector_points_indices: List[int] = []
from src.world.hexmap import MapPointMngr
# print(f"ref level ({self.x_grid}|{self.y_grid}): {refinement_level}")
# build up the vertices
for i in range(refinement_level + 1):
z_elevation = self.get_elevation(i)
if i == 0: # center point
uv_map = self.get_uv_mapping(z_elevation, self.vx_center, None,
i)
idx = MapPointMngr.instance().add_critical_point(
(self.vx_center.x, self.vx_center.y, z_elevation),
self.x_grid, self.y_grid, uv_map)
self.ref_points_indices.append([idx])
continue
self.ref_points_indices.append([])
fac = self.get_offset_factor(i)
for o in self.adjacent_hexagons:
p = self.get_vector(o, size=fac) + self.vx_center.xy
n = self.get_normal(o, z_elevation)
uv_map = self.get_uv_mapping(z_elevation, p, o, i)
idx = MapPointMngr.instance().add_critical_point(
(p.x, p.y, z_elevation),
self.x_grid,
self.y_grid,
uv_map,
n=n)
self.ref_points_indices[i].append(idx)
# construct geometric triangulation
# print(self.ref_points_indices)
for i in range(refinement_level):
if i == 0:
for k in range(1, 7, 1):
t = GeomTriangles(Geom.UHStatic)
t.addVertex(self.ref_points_indices[i][0])
t.addVertex(self.ref_points_indices[i + 1][k % 6])
t.addVertex(self.ref_points_indices[i + 1][(k + 1) % 6])
t.closePrimitive()
self.triangulation.append(t)
else:
t = GeomTristrips(Geom.UHStatic)
for k in range(7):
t.addVertex(self.ref_points_indices[i][k % 6])
t.addVertex(self.ref_points_indices[i + 1][k % 6])
t.closePrimitive()
# aat.decompose()
self.triangulation.append(t)
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.seeNode = self.render.attachNewNode('see')
self.cam.reparentTo(self.seeNode)
self.cam.setPos(0, 0, 5)
self.fpscamera = fpscontroller.FpsController(self, self.seeNode)
self.fpscamera.setFlyMode(True)
self.fpscamera.setMouseLook(True)
self.prevPos = self.fpscamera.getPos()
self.prevInto = None
self.makeInstructions()
self.info = self.genLabelText("Position: <unknown>", 2)
self.initCollisions()
self.leftColor = LVecBase4i(224, 224, 64, 255)
self.rightColor = LVecBase4i(64, 224, 224, 255)
self.isDrawing = False
self.toggleDrawing()
self.accept("escape", sys.exit) #Escape quits
self.accept("enter", self.toggleDrawing)
def initCollisions(self):
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
self.cTrav.showCollisions(self.render)
# Initialize the Pusher collision handler.
self.pusher = CollisionHandlerFloor()
### player
# Create a collsion node for this object.
playerNode = CollisionNode('player')
playerNode.addSolid(CollisionSphere(0, 0, 0, 1))
# Attach the collision node to the object's model.
self.playerC = self.fpscamera.player.attachNewNode(playerNode)
# Set the object's collision node to render as visible.
self.playerC.show()
def toggleDrawing(self):
self.isDrawing = not self.isDrawing
if self.isDrawing:
self.instructionText.setText(
'Enter: Generate Tunnel from Movement')
self.fpscamera.setFlyMode(True)
self.prevPos = None
# self.cTrav.remosveCollider(self.playerC)
self.removeTask('updatePhysics')
self.addTask(self.drawHere, 'drawHere')
self.geomNode = GeomNode('geomNode')
self.geomNodePath = self.render.attachNewNode(self.geomNode)
self.geomNodePath.setTwoSided(True)
# apparently p3tinydisplay needs this
self.geomNodePath.setColorOff()
# Create a collision node for this object.
self.floorCollNode = CollisionNode('geom')
# Attach the collision node to the object's model.
floorC = self.geomNodePath.attachNewNode(self.floorCollNode)
# Set the object's collision node to render as visible.
floorC.show()
self.newVertexData()
self.newGeom()
else:
self.instructionText.setText('Enter: Record Movement for Tunnel')
self.removeTask('drawHere')
if self.prevPos:
#self.completePath()
self.completeTunnelPath()
self.fpscamera.setFlyMode(True)
self.drive.setPos(self.fpscamera.getPos())
self.cTrav.addCollider(self.playerC, self.pusher)
self.pusher.addCollider(self.playerC, self.fpscamera.player)
self.taskMgr.add(self.updatePhysics, 'updatePhysics')
def newVertexData(self):
fmt = GeomVertexFormat.getV3c4()
# fmt = GeomVertexFormat.getV3n3c4()
self.vertexData = GeomVertexData("path", fmt, Geom.UHStatic)
self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
# self.normalWriter = GeomVertexWriter(self.vertexData, 'normal')
self.colorWriter = GeomVertexWriter(self.vertexData, 'color')
def newGeom(self):
self.triStrips = GeomTristrips(Geom.UHDynamic)
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.triStrips)
def makeInstructions(self):
OnscreenText(text="Draw Path by Walking (WSAD/space/mouselook)",
style=1,
fg=(1, 1, 0, 1),
pos=(0.5, -0.95),
scale=.07)
self.genLabelText("ESC: Quit", 0)
self.instructionText = self.genLabelText("", 1)
def genLabelText(self, text, i):
return OnscreenText(text=text,
pos=(-1.3, .95 - .05 * i),
fg=(1, 1, 0, 1),
align=TextNode.ALeft,
scale=.05)
def drawHere(self, task):
pos = self.fpscamera.getPos()
self.info.setText("Position: {0}, {1}, {2} at {3} by {4}".format(
int(pos.x * 100) / 100.,
int(pos.y * 100) / 100.,
int(pos.z) / 100., self.fpscamera.getHeading(),
self.fpscamera.getLookAngle()))
prevPos = self.prevPos
if not prevPos:
self.prevPos = pos
elif (pos - prevPos).length() >= 1:
# self.extendPathQuad(prevPos, pos, 2)
self.extendPathTunnel(prevPos, pos, 3)
self.leftColor[1] += 63
self.rightColor[2] += 37
self.prevPos = pos
return task.cont
def extendPathQuad(self, prevPos, pos, width):
self.drawQuadTo(prevPos, pos, width)
row = self.vertexWriter.getWriteRow()
numPrims = self.triStrips.getNumPrimitives()
if numPrims == 0:
primVerts = row
else:
primVerts = row - self.triStrips.getPrimitiveEnd(numPrims - 1)
if primVerts >= 4:
self.triStrips.closePrimitive()
if row >= 256:
print "Packing and starting anew"
newGeom = True
self.geom.unifyInPlace(row, False)
else:
newGeom = False
self.completeQuadPath()
if newGeom:
self.newVertexData()
self.newGeom()
if newGeom:
self.drawQuadTo(prevPos, pos, width)
else:
self.triStrips.addConsecutiveVertices(row - 2, 2)
def extendPathTunnel(self, prevPos, pos, width):
self.drawTunnelTo(prevPos, pos, width)
def drawLineTo(self, pos, color):
self.vertexWriter.addData3f(pos.x, pos.y, pos.z)
# self.normalWriter.addData3f(0, 0, 1)
self.colorWriter.addData4i(color)
self.triStrips.addNextVertices(1)
return 1
def drawQuadTo(self, a, b, width):
""" a (to) b are vectors defining a line bisecting a new quad. """
into = (b - a)
if abs(into.x) + abs(into.y) < 1:
# ensure that if we jump in place, we don't get a thin segment
if not self.prevInto:
return
into = self.prevInto
else:
into.normalize()
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
if self.vertexWriter.getWriteRow() == 0:
self.drawQuadRow(a, into, width)
verts = self.drawQuadRow(b, into, width)
self.prevInto = into
return verts
def drawQuadRow(self, a, into, width):
""" a defines a point, with 'into' being the normalized direction. """
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
aLeft = Vec3(a.x - into.y * width, a.y + into.x * width, a.z)
aRight = Vec3(a.x + into.y * width, a.y - into.x * width, a.z)
row = self.vertexWriter.getWriteRow()
self.vertexWriter.addData3f(aLeft)
self.vertexWriter.addData3f(aRight)
# self.normalWriter.addData3f(Vec3(0, 0, 1))
# self.normalWriter.addData3f(Vec3(0, 0, 1))
self.colorWriter.addData4i(self.leftColor)
self.colorWriter.addData4i(self.rightColor)
self.triStrips.addConsecutiveVertices(row, 2)
return 2
def drawTunnelTo(self, a, b, width):
""" a (to) b are vectors defining a line bisecting a new tunnel segment. """
into = (b - a)
if abs(into.x) + abs(into.y) < 1:
# ensure that if we jump in place, we don't get a thin segment
if not self.prevInto:
return
into = self.prevInto
else:
into.normalize()
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
if self.vertexWriter.getWriteRow() == 0:
self.drawTunnelBoundary(a, into, width)
row = self.vertexWriter.getWriteRow()
verts = self.drawTunnelBoundary(b, into, width)
totalVerts = self.drawTunnelRow(row, verts)
self.prevInto = into
return totalVerts
def drawTunnelBoundary(self, a, into, width):
""" a defines a point, with 'into' being the normalized direction. """
aLowLeft = Vec3(a.x - into.y * width, a.y + into.x * width, a.z)
aLowRight = Vec3(a.x + into.y * width, a.y - into.x * width, a.z)
aHighRight = Vec3(a.x + into.y * width, a.y - into.x * width,
a.z + width * 3)
aHighLeft = Vec3(a.x - into.y * width, a.y + into.x * width,
a.z + width * 3)
self.vertexWriter.addData3f(aLowLeft)
self.vertexWriter.addData3f(aLowRight)
self.vertexWriter.addData3f(aHighRight)
self.vertexWriter.addData3f(aHighLeft)
self.colorWriter.addData4i(self.leftColor)
self.colorWriter.addData4i(self.rightColor)
self.colorWriter.addData4i(self.leftColor)
self.colorWriter.addData4i(self.rightColor)
return 4
def drawTunnelRowX(self, row, verts):
# BOTTOM: bottom-left, new-bottom-left, bottom-right, new-bottom-right
self.triStrips.addConsecutiveVertices(row - verts + 0, 1)
self.triStrips.addConsecutiveVertices(row + 0, 1)
self.triStrips.addConsecutiveVertices(row - verts + 1, 1)
self.triStrips.addConsecutiveVertices(row + 1, 1)
self.triStrips.closePrimitive()
# RIGHT: (new-bottom-right) bottom-right, new-top-right, top-right
self.triStrips.addConsecutiveVertices(row + 1, 1)
self.triStrips.addConsecutiveVertices(row - verts + 1, 1)
self.triStrips.addConsecutiveVertices(row + 2, 1)
self.triStrips.addConsecutiveVertices(row - verts + 2, 1)
self.triStrips.closePrimitive()
# TOP: top-left, new top-right, new top-left
self.triStrips.addConsecutiveVertices(row - verts + 2, 1)
self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
self.triStrips.addConsecutiveVertices(row + 2, 1)
self.triStrips.addConsecutiveVertices(row + 3, 1)
self.triStrips.closePrimitive()
# LEFT: (new top-left) new bottom-left, top-left, bottom-left, new-bottom-left
self.triStrips.addConsecutiveVertices(row + 3, 1)
self.triStrips.addConsecutiveVertices(row + 0, 1)
self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
self.triStrips.addConsecutiveVertices(row - verts + 0, 1)
self.triStrips.closePrimitive()
return verts * 4
def drawTunnelRow(self, row, verts):
# # clockwise for the inside of the tunnel
# # TOP: new-top-left, top-left, new-top-right, top-right
# self.triStrips.addConsecutiveVertices(row + 3, 1)
# self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
# self.triStrips.addConsecutiveVertices(row + 2, 1)
# self.triStrips.addConsecutiveVertices(row - verts + 2, 1)
# # RIGHT: new-bottom-right, bottom-right
# self.triStrips.addConsecutiveVertices(row + 1, 1)
# self.triStrips.addConsecutiveVertices(row - verts + 1, 1)
# # BOTTOM: new-bottom-left, bottom-left
# self.triStrips.addConsecutiveVertices(row, 1)
# self.triStrips.addConsecutiveVertices(row - verts, 1)
# # LEFT: new top-left, top-left
# self.triStrips.addConsecutiveVertices(row + 3, 1)
# self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
# TOP: new-top-left, top-left, new-top-right, top-right
self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
self.triStrips.addConsecutiveVertices(row + 3, 1)
self.triStrips.addConsecutiveVertices(row - verts + 2, 1)
self.triStrips.addConsecutiveVertices(row + 2, 1)
# RIGHT: new-bottom-right, bottom-right
self.triStrips.addConsecutiveVertices(row - verts + 1, 1)
self.triStrips.addConsecutiveVertices(row + 1, 1)
# BOTTOM: new-bottom-left, bottom-left
self.triStrips.addConsecutiveVertices(row - verts, 1)
self.triStrips.addConsecutiveVertices(row, 1)
# LEFT: new top-left, top-left
self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
self.triStrips.addConsecutiveVertices(row + 3, 1)
self.triStrips.closePrimitive()
return verts * 4
def completeQuadPath(self):
self.geomNode.addGeom(self.geom)
if self.triStrips.getNumPrimitives() == 0:
return
floorMesh = CollisionFloorMesh()
vertexReader = GeomVertexReader(self.vertexData, 'vertex')
tris = self.triStrips.decompose()
print "Decomposed prims:", tris.getNumPrimitives()
p = 0
for i in range(tris.getNumPrimitives()):
v0 = tris.getPrimitiveStart(i)
ve = tris.getPrimitiveEnd(i)
if v0 < ve:
vertexReader.setRow(tris.getVertex(v0))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(tris.getVertex(v0 + 1))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(tris.getVertex(v0 + 2))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
floorMesh.addTriangle(p, p + 1, p + 2)
p += 3
self.floorCollNode.addSolid(floorMesh)
def completeTunnelPath(self):
self.geomNode.addGeom(self.geom)
if self.triStrips.getNumPrimitives() == 0:
return
floorMesh = CollisionFloorMesh()
vertexReader = GeomVertexReader(self.vertexData, 'vertex')
print "Original prims:", self.triStrips.getNumPrimitives()
p = 0
for i in range(self.triStrips.getNumPrimitives()):
v0 = self.triStrips.getPrimitiveStart(i)
ve = self.triStrips.getPrimitiveEnd(i)
j = v0 + 4
# add the bottom triangles
vertexReader.setRow(self.triStrips.getVertex(j))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(self.triStrips.getVertex(j + 1))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(self.triStrips.getVertex(j + 2))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
floorMesh.addTriangle(p, p + 1, p + 2)
vertexReader.setRow(self.triStrips.getVertex(j + 3))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
floorMesh.addTriangle(p + 1, p + 3, p + 2)
p += 4
# this adds every triangle, but is not appropriate for a closed path
# tris = self.triStrips.decompose()
# print "Decomposed prims:",tris.getNumPrimitives()
# p = 0
# for i in range(tris.getNumPrimitives()):
# v0 = tris.getPrimitiveStart(i)
# ve = tris.getPrimitiveEnd(i)
# if v0 < ve:
# vertexReader.setRow(tris.getVertex(v0))
# floorMesh.addVertex(Point3(vertexReader.getData3f()))
# vertexReader.setRow(tris.getVertex(v0+1))
# floorMesh.addVertex(Point3(vertexReader.getData3f()))
# vertexReader.setRow(tris.getVertex(v0+2))
# floorMesh.addVertex(Point3(vertexReader.getData3f()))
# floorMesh.addTriangle(p, p+1, p+2)
# p += 3
self.floorCollNode.addSolid(floorMesh)
def updatePhysics(self, task):
pos = self.fpscamera.getPos()
self.info.setText("Position: {0}, {1}, {2}".format(
int(pos.x * 100) / 100.,
int(pos.y * 100) / 100.,
int(pos.z) / 100.))
return task.cont
def drawBody(self,
pos,
quat,
radius=1,
UVcoord=(1, 1),
numVertices=_polySize):
# if isRoot:
# self.bodydata = GeomVertexData("body vertices", GeomVertexFormat.getV3n3t2(), Geom.UHStatic)
vdata = self.bodydata
circleGeom = Geom(
vdata
) # this was originally a copy of all previous geom in vdata...
vertWriter = GeomVertexWriter(vdata, "vertex")
#colorWriter = GeomVertexWriter(vdata, "color")
normalWriter = GeomVertexWriter(vdata, "normal")
# drawReWriter = GeomVertexRewriter(vdata, "drawFlag")
texReWriter = GeomVertexRewriter(vdata, "texcoord")
startRow = vdata.getNumRows()
vertWriter.setRow(startRow)
#colorWriter.setRow(startRow)
normalWriter.setRow(startRow)
texReWriter.setRow(startRow)
#axisAdj=Mat4.rotateMat(45, axis)*Mat4.scaleMat(radius)*Mat4.translateMat(pos)
perp1 = quat.getRight()
perp2 = quat.getForward()
#TODO: PROPERLY IMPLEMENT RADIAL NOISE
#vertex information is written here
angleSlice = 2 * pi / numVertices
currAngle = 0
for i in xrange(numVertices + 1):
adjCircle = pos + (perp1 * cos(currAngle) +
perp2 * sin(currAngle)) * radius * (
.5 + bNodeRadNoise * random.random())
normal = perp1 * cos(currAngle) + perp2 * sin(currAngle)
normalWriter.addData3f(normal)
vertWriter.addData3f(adjCircle)
texReWriter.addData2f(
float(UVcoord[0] * i) / numVertices,
UVcoord[1]) # UV SCALE HERE!
#colorWriter.addData4f(0.5, 0.5, 0.5, 1)
currAngle += angleSlice
#we cant draw quads directly so we use Tristrips
if (startRow != 0):
lines = GeomTristrips(Geom.UHStatic)
for i in xrange(numVertices + 1):
lines.addVertex(i + startRow)
lines.addVertex(i + startRow - numVertices - 1)
lines.addVertex(startRow)
lines.addVertex(startRow - numVertices)
lines.closePrimitive()
#lines.decompose()
circleGeom.addPrimitive(lines)
circleGeomNode = GeomNode("Debug")
circleGeomNode.addGeom(circleGeom)
self.numPrimitives += numVertices * 2
self.bodies.attachNewNode(circleGeomNode)
return circleGeomNode
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.seeNode = self.render.attachNewNode('see')
self.cam.reparentTo(self.seeNode)
self.cam.setPos(0, 0, 5)
self.fpscamera = fpscontroller.FpsController(self, self.seeNode)
self.fpscamera.setFlyMode(True)
self.prevPos = self.fpscamera.getPos()
self.prevInto = None
self.info = self.genLabelText("Position: <unknown>", 4)
self.makeInstructions()
self.initCollisions()
self.leftColor = LVecBase4i(224, 224, 64, 255)
self.rightColor = LVecBase4i(64, 224, 224, 255)
self.isDrawing = False
self.toggleDrawing()
self.accept("escape", sys.exit) #Escape quits
self.accept("enter", self.toggleDrawing)
def initCollisions(self):
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
self.cTrav.showCollisions(self.render)
# self.cQueue = CollisionHandlerQueue()
# Initialize the Pusher collision handler.
#self.pusher = CollisionHandlerPusher()
self.pusher = CollisionHandlerFloor()
### player
print DirectNotifyGlobal.directNotify.getCategories()
# Create a collsion node for this object.
playerNode = CollisionNode('player')
playerNode.addSolid(CollisionSphere(0, 0, 0, 1))
# playerNode.setFromCollideMask(BitMask32.bit(0))
# playerNode.setIntoCollideMask(BitMask32.allOn())
# Attach the collision node to the object's model.
self.playerC = self.fpscamera.player.attachNewNode(playerNode)
# Set the object's collision node to render as visible.
self.playerC.show()
# Add the 'player' collision node to the Pusher collision handler.
#self.pusher.addCollider(self.playerC, self.fpscamera.player)
#self.pusher.addCollider(playerC, self.fpscamera.player)
# self.cTrav.addCollider(self.playerC, self.cQueue)
def toggleDrawing(self):
self.isDrawing = not self.isDrawing
if self.isDrawing:
self.drawText.setText("Enter: Turn off drawing")
self.fpscamera.setFlyMode(True)
self.prevPos = None
self.cTrav.removeCollider(self.playerC)
self.pusher.removeCollider(self.playerC)
self.removeTask('updatePhysics')
self.addTask(self.drawHere, 'drawHere')
self.geomNode = GeomNode('geomNode')
self.geomNodePath = self.render.attachNewNode(self.geomNode)
self.geomNodePath.setTwoSided(True)
# apparently p3tinydisplay needs this
self.geomNodePath.setColorOff()
# Create a collision node for this object.
self.floorCollNode = CollisionNode('geom')
# self.floorCollNode.setFromCollideMask(BitMask32.bit(0))
# self.floorCollNode.setIntoCollideMask(BitMask32.allOn())
# Attach the collision node to the object's model.
floorC = self.geomNodePath.attachNewNode(self.floorCollNode)
# Set the object's collision node to render as visible.
floorC.show()
#self.pusher.addCollider(floorC, self.geomNodePath)
self.newVertexData()
self.newGeom()
else:
self.drawText.setText("Enter: Turn on drawing")
self.removeTask('drawHere')
if self.prevPos:
self.completePath()
self.fpscamera.setFlyMode(True)
self.drive.setPos(self.fpscamera.getPos())
self.cTrav.addCollider(self.playerC, self.pusher)
self.pusher.addCollider(self.playerC, self.fpscamera.player)
self.taskMgr.add(self.updatePhysics, 'updatePhysics')
def newVertexData(self):
fmt = GeomVertexFormat.getV3c4()
# fmt = GeomVertexFormat.getV3n3c4()
self.vertexData = GeomVertexData("path", fmt, Geom.UHStatic)
self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
# self.normalWriter = GeomVertexWriter(self.vertexData, 'normal')
self.colorWriter = GeomVertexWriter(self.vertexData, 'color')
def newGeom(self):
self.triStrips = GeomTristrips(Geom.UHDynamic)
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.triStrips)
def makeInstructions(self):
OnscreenText(text="Draw Path by Walking",
style=1,
fg=(1, 1, 0, 1),
pos=(0.5, -0.95),
scale=.07)
self.drawText = self.genLabelText("", 0)
self.genLabelText("Walk (W/S/A/D), Jump=Space, Look=PgUp/PgDn", 1)
self.genLabelText(
" (hint, go backwards with S to see your path immediately)", 2)
self.genLabelText("ESC: Quit", 3)
def genLabelText(self, text, i):
return OnscreenText(text=text,
pos=(-1.3, .95 - .05 * i),
fg=(1, 1, 0, 1),
align=TextNode.ALeft,
scale=.05)
def drawHere(self, task):
pos = self.fpscamera.getPos()
self.info.setText("Position: {0}, {1}, {2} at {3} by {4}".format(
int(pos.x * 100) / 100.,
int(pos.y * 100) / 100.,
int(pos.z) / 100., self.fpscamera.getHeading(),
self.fpscamera.getLookAngle()))
prevPos = self.prevPos
if not prevPos:
self.prevPos = pos
elif (pos - prevPos).length() > 1:
self.drawQuadTo(prevPos, pos, 2)
row = self.vertexWriter.getWriteRow()
numPrims = self.triStrips.getNumPrimitives()
if numPrims == 0:
primVerts = row
else:
primVerts = row - self.triStrips.getPrimitiveEnd(numPrims - 1)
if primVerts >= 4:
self.triStrips.closePrimitive()
if row >= 256:
print "Packing and starting anew"
newGeom = True
self.geom.unifyInPlace(row, False)
else:
newGeom = False
self.completePath()
if newGeom:
self.newVertexData()
self.newGeom()
if not newGeom:
self.triStrips.addConsecutiveVertices(row - 2, 2)
else:
self.drawQuadTo(prevPos, pos, 2)
self.leftColor[1] += 63
self.rightColor[2] += 37
self.prevPos = pos
return task.cont
def drawLineTo(self, pos, color):
self.vertexWriter.addData3f(pos.x, pos.y, pos.z)
# self.normalWriter.addData3f(0, 0, 1)
self.colorWriter.addData4i(color)
self.triStrips.addNextVertices(1)
def drawQuadTo(self, a, b, width):
""" a (to) b are vectors defining a line bisecting a new quad. """
into = (b - a)
if abs(into.x) + abs(into.y) < 1:
if not self.prevInto:
return
into = self.prevInto
print into
else:
into.normalize()
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
if self.vertexWriter.getWriteRow() == 0:
self.drawQuadRow(a, into, width)
self.drawQuadRow(b, into, width)
self.prevInto = into
def drawQuadRow(self, a, into, width):
""" a defines a point, with 'into' being the normalized direction. """
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
aLeft = Vec3(a.x - into.y * width, a.y + into.x * width, a.z)
aRight = Vec3(a.x + into.y * width, a.y - into.x * width, a.z)
row = self.vertexWriter.getWriteRow()
self.vertexWriter.addData3f(aLeft)
self.vertexWriter.addData3f(aRight)
# self.normalWriter.addData3f(Vec3(0, 0, 1))
# self.normalWriter.addData3f(Vec3(0, 0, 1))
self.colorWriter.addData4i(self.leftColor)
self.colorWriter.addData4i(self.rightColor)
self.triStrips.addConsecutiveVertices(row, 2)
def completePath(self):
self.geomNode.addGeom(self.geom)
if self.triStrips.getNumPrimitives() == 0:
return
floorMesh = CollisionFloorMesh()
tris = self.triStrips.decompose()
p = 0
vertexReader = GeomVertexReader(self.vertexData, 'vertex')
for i in range(tris.getNumPrimitives()):
v0 = tris.getPrimitiveStart(i)
ve = tris.getPrimitiveEnd(i)
if v0 < ve:
vertexReader.setRow(tris.getVertex(v0))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(tris.getVertex(v0 + 1))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(tris.getVertex(v0 + 2))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
floorMesh.addTriangle(p, p + 1, p + 2)
p += 3
self.floorCollNode.addSolid(floorMesh)
def updatePhysics(self, task):
pos = self.fpscamera.getPos()
self.info.setText("Position: {0}, {1}, {2}".format(
int(pos.x * 100) / 100.,
int(pos.y * 100) / 100.,
int(pos.z) / 100.))
return task.cont
def drawBody(nodePath,
vdata,
pos,
vecList,
radius=1,
keepDrawing=True,
numVertices=8):
circleGeom = Geom(vdata)
vertWriter = GeomVertexWriter(vdata, "vertex")
colorWriter = GeomVertexWriter(vdata, "color")
normalWriter = GeomVertexWriter(vdata, "normal")
drawReWriter = GeomVertexRewriter(vdata, "drawFlag")
texReWriter = GeomVertexRewriter(vdata, "texcoord")
startRow = vdata.getNumRows()
vertWriter.setRow(startRow)
colorWriter.setRow(startRow)
normalWriter.setRow(startRow)
sCoord = 0
if (startRow != 0):
texReWriter.setRow(startRow - numVertices)
sCoord = texReWriter.getData2f().getX() + 1
drawReWriter.setRow(startRow - numVertices)
if (drawReWriter.getData1f() == False):
sCoord -= 1
drawReWriter.setRow(startRow)
texReWriter.setRow(startRow)
angleSlice = 2 * math.pi / numVertices
currAngle = 0
#axisAdj=LMatrix4.rotateMat(45, axis)*LMatrix4.scaleMat(radius)*LMatrix4.translateMat(pos)
perp1 = vecList[1]
perp2 = vecList[2]
# vertex information is written here
for i in range(numVertices):
adjCircle = pos + \
(perp1 * math.cos(currAngle) + perp2 * math.sin(currAngle)) * \
radius
normal = perp1 * math.cos(currAngle) + perp2 * math.sin(currAngle)
normalWriter.addData3f(normal)
vertWriter.addData3f(adjCircle)
texReWriter.addData2f(sCoord, (i + 0.001) / (numVertices - 1))
colorWriter.addData4f(0.5, 0.5, 0.5, 1)
drawReWriter.addData1f(keepDrawing)
currAngle += angleSlice
if startRow == 0:
return
drawReader = GeomVertexReader(vdata, "drawFlag")
drawReader.setRow(startRow - numVertices)
# we cant draw quads directly so we use Tristrips
if drawReader.getData1i() != 0:
lines = GeomTristrips(Geom.UHStatic)
half = int(numVertices * 0.5)
for i in range(numVertices):
lines.addVertex(i + startRow)
if i < half:
lines.addVertex(i + startRow - half)
else:
lines.addVertex(i + startRow - half - numVertices)
lines.addVertex(startRow)
lines.addVertex(startRow - half)
lines.closePrimitive()
lines.decompose()
circleGeom.addPrimitive(lines)
circleGeomNode = GeomNode("Debug")
circleGeomNode.addGeom(circleGeom)
# I accidentally made the front-face face inwards. Make reverse makes the tree render properly and
# should cause any surprises to any poor programmer that tries to use
# this code
circleGeomNode.setAttrib(CullFaceAttrib.makeReverse(), 1)
global numPrimitives
numPrimitives += numVertices * 2
nodePath.attachNewNode(circleGeomNode)
def add_button(self, text, label_id, pos_x, pos_y, width=0.0, hight=0.1):
if width == 0.0:
for c in range(len(text) / 2):
width += 0.08
ls = LineSegs("lines")
ls.setColor(0, 1, 0, 1)
ls.drawTo(-width / 2, 0, hight / 2)
ls.drawTo(width / 2, 0, hight / 2)
ls.drawTo(width / 2, 0, -hight / 2)
ls.drawTo(-width / 2, 0, -hight / 2)
ls.drawTo(-width / 2, 0, hight / 2)
border = ls.create(False)
border.setTag('back_ground', '1')
array = GeomVertexArrayFormat()
array.addColumn("vertex", 4, Geom.NTFloat32, Geom.CPoint)
arr_format = GeomVertexFormat()
arr_format.addArray(array)
arr_format = GeomVertexFormat.registerFormat(arr_format)
vdata = GeomVertexData('fill', arr_format, Geom.UHStatic)
vdata.setNumRows(4)
vertex = GeomVertexWriter(vdata, 'vertex')
vertex.addData3f(-width / 2, 0, hight / 2)
vertex.addData3f(width / 2, 0, hight / 2)
vertex.addData3f(-width / 2, 0, -hight / 2)
vertex.addData3f(width / 2, 0, -hight / 2)
prim = GeomTristrips(Geom.UHStatic)
prim.addVertex(0)
prim.addVertex(1)
prim.addVertex(2)
prim.addVertex(3)
geom = Geom(vdata)
geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(geom)
nodePath = NodePath("button")
nodePath.attachNewNode(node)
nodePath.setPos(0, 0, 0)
nodePath.setTag('button', '1')
nodePath.setBin("unsorted", 0)
nodePath.setDepthTest(False)
nodePath.setColor(0, 0, 0, 1)
nodePath.attachNewNode(border)
nodePath1 = NodePath("button")
nodePath1.attachNewNode(node)
nodePath1.setPos(0, 0, 0)
nodePath1.setTag('button1', '1')
nodePath1.setBin("unsorted", 0)
nodePath1.setDepthTest(False)
nodePath1.setColor(0, 1, 0, 1)
nodePath1.attachNewNode(border)
button = DirectFrame(enableEdit=1,
text=text,
geom=nodePath,
text_scale=0.05,
text_fg=(0, 1, 0, 1),
borderWidth=(1, 1),
relief=None,
text_pos=(0, -0.01, 0),
textMayChange=1,
state=DGG.NORMAL,
parent=aspect2d)
button.setPos(pos_x, 0, pos_y)
button.bind(DGG.B1PRESS, button_click, [button])
button.bind(DGG.WITHIN, button_hover, [button])
button.bind(DGG.WITHOUT, button_no_hover, [button])
# button.resetFrameSize()
# self.button.bind(DGG.WITHIN, self.onMouseHoverInFunction, [button, some_value1])
defines.ENTITIES[defines.ENTITY_ID] = {
'CATEGORY': 'button',
'BUTTON': button,
'NODE': nodePath,
'LABEL': label_id,
'STATUS': 0
}
defines.ENTITY_ID += 1
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.seeNode = self.render.attachNewNode('see')
self.cam.reparentTo(self.seeNode)
self.cam.setPos(0, 0, 5)
self.fpscamera = fpscontroller.FpsController(self, self.seeNode)
self.fpscamera.setFlyMode(True)
self.fpscamera.setMouseLook(True)
self.prevPos = self.fpscamera.getPos()
self.prevInto = None
self.makeInstructions()
self.info = self.genLabelText("Position: <unknown>", 2)
self.initCollisions()
self.leftColor = LVecBase4i(224, 224, 64, 255)
self.rightColor = LVecBase4i(64, 224, 224, 255)
self.isDrawing = False
self.toggleDrawing()
self.accept("escape", sys.exit) #Escape quits
self.accept("enter", self.toggleDrawing)
def initCollisions(self):
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
self.cTrav.showCollisions(self.render)
# Initialize the Pusher collision handler.
self.pusher = CollisionHandlerFloor()
### player
# Create a collsion node for this object.
playerNode = CollisionNode('player')
playerNode.addSolid(CollisionSphere(0, 0, 0, 1))
# Attach the collision node to the object's model.
self.playerC = self.fpscamera.player.attachNewNode(playerNode)
# Set the object's collision node to render as visible.
self.playerC.show()
def toggleDrawing(self):
self.isDrawing = not self.isDrawing
if self.isDrawing:
self.instructionText.setText('Enter: Generate Tunnel from Movement')
self.fpscamera.setFlyMode(True)
self.prevPos = None
# self.cTrav.remosveCollider(self.playerC)
self.removeTask('updatePhysics')
self.addTask(self.drawHere, 'drawHere')
self.geomNode = GeomNode('geomNode')
self.geomNodePath = self.render.attachNewNode(self.geomNode)
self.geomNodePath.setTwoSided(True)
# apparently p3tinydisplay needs this
self.geomNodePath.setColorOff()
# Create a collision node for this object.
self.floorCollNode = CollisionNode('geom')
# Attach the collision node to the object's model.
floorC = self.geomNodePath.attachNewNode(self.floorCollNode)
# Set the object's collision node to render as visible.
floorC.show()
self.newVertexData()
self.newGeom()
else:
self.instructionText.setText('Enter: Record Movement for Tunnel')
self.removeTask('drawHere')
if self.prevPos:
#self.completePath()
self.completeTunnelPath()
self.fpscamera.setFlyMode(True)
self.drive.setPos(self.fpscamera.getPos())
self.cTrav.addCollider(self.playerC, self.pusher)
self.pusher.addCollider(self.playerC, self.fpscamera.player)
self.taskMgr.add(self.updatePhysics, 'updatePhysics')
def newVertexData(self):
fmt = GeomVertexFormat.getV3c4()
# fmt = GeomVertexFormat.getV3n3c4()
self.vertexData = GeomVertexData("path", fmt, Geom.UHStatic)
self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
# self.normalWriter = GeomVertexWriter(self.vertexData, 'normal')
self.colorWriter = GeomVertexWriter(self.vertexData, 'color')
def newGeom(self):
self.triStrips = GeomTristrips(Geom.UHDynamic)
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.triStrips)
def makeInstructions(self):
OnscreenText(text="Draw Path by Walking (WSAD/space/mouselook)",
style=1, fg=(1,1,0,1),
pos=(0.5,-0.95), scale = .07)
self.genLabelText("ESC: Quit", 0)
self.instructionText = self.genLabelText("", 1)
def genLabelText(self, text, i):
return OnscreenText(text = text, pos = (-1.3, .95-.05*i), fg=(1,1,0,1),
align = TextNode.ALeft, scale = .05)
def drawHere(self, task):
pos = self.fpscamera.getPos()
self.info.setText("Position: {0}, {1}, {2} at {3} by {4}".format(int(pos.x*100)/100., int(pos.y*100)/100., int(pos.z)/100.,
self.fpscamera.getHeading(), self.fpscamera.getLookAngle()))
prevPos = self.prevPos
if not prevPos:
self.prevPos = pos
elif (pos - prevPos).length() >= 1:
# self.extendPathQuad(prevPos, pos, 2)
self.extendPathTunnel(prevPos, pos, 3)
self.leftColor[1] += 63
self.rightColor[2] += 37
self.prevPos = pos
return task.cont
def extendPathQuad(self, prevPos, pos, width):
self.drawQuadTo(prevPos, pos, width)
row = self.vertexWriter.getWriteRow()
numPrims = self.triStrips.getNumPrimitives()
if numPrims == 0:
primVerts = row
else:
primVerts = row - self.triStrips.getPrimitiveEnd(numPrims-1)
if primVerts >= 4:
self.triStrips.closePrimitive()
if row >= 256:
print "Packing and starting anew"
newGeom = True
self.geom.unifyInPlace(row, False)
else:
newGeom = False
self.completeQuadPath()
if newGeom:
self.newVertexData()
self.newGeom()
if newGeom:
self.drawQuadTo(prevPos, pos, width)
else:
self.triStrips.addConsecutiveVertices(row - 2, 2)
def extendPathTunnel(self, prevPos, pos, width):
self.drawTunnelTo(prevPos, pos, width)
def drawLineTo(self, pos, color):
self.vertexWriter.addData3f(pos.x, pos.y, pos.z)
# self.normalWriter.addData3f(0, 0, 1)
self.colorWriter.addData4i(color)
self.triStrips.addNextVertices(1)
return 1
def drawQuadTo(self, a, b, width):
""" a (to) b are vectors defining a line bisecting a new quad. """
into = (b - a)
if abs(into.x) + abs(into.y) < 1:
# ensure that if we jump in place, we don't get a thin segment
if not self.prevInto:
return
into = self.prevInto
else:
into.normalize()
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
if self.vertexWriter.getWriteRow() == 0:
self.drawQuadRow(a, into, width)
verts = self.drawQuadRow(b, into, width)
self.prevInto = into
return verts
def drawQuadRow(self, a, into, width):
""" a defines a point, with 'into' being the normalized direction. """
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
aLeft = Vec3(a.x - into.y * width, a.y + into.x * width, a.z)
aRight = Vec3(a.x + into.y * width, a.y - into.x * width, a.z)
row = self.vertexWriter.getWriteRow()
self.vertexWriter.addData3f(aLeft)
self.vertexWriter.addData3f(aRight)
# self.normalWriter.addData3f(Vec3(0, 0, 1))
# self.normalWriter.addData3f(Vec3(0, 0, 1))
self.colorWriter.addData4i(self.leftColor)
self.colorWriter.addData4i(self.rightColor)
self.triStrips.addConsecutiveVertices(row, 2)
return 2
def drawTunnelTo(self, a, b, width):
""" a (to) b are vectors defining a line bisecting a new tunnel segment. """
into = (b - a)
if abs(into.x) + abs(into.y) < 1:
# ensure that if we jump in place, we don't get a thin segment
if not self.prevInto:
return
into = self.prevInto
else:
into.normalize()
# the perpendicular of (a,b) is (-b,a); we want the path to be "flat" in Z=space
if self.vertexWriter.getWriteRow() == 0:
self.drawTunnelBoundary(a, into, width)
row = self.vertexWriter.getWriteRow()
verts = self.drawTunnelBoundary(b, into, width)
totalVerts = self.drawTunnelRow(row, verts)
self.prevInto = into
return totalVerts
def drawTunnelBoundary(self, a, into, width):
""" a defines a point, with 'into' being the normalized direction. """
aLowLeft = Vec3(a.x - into.y * width, a.y + into.x * width, a.z)
aLowRight = Vec3(a.x + into.y * width, a.y - into.x * width, a.z)
aHighRight = Vec3(a.x + into.y * width, a.y - into.x * width, a.z + width * 3)
aHighLeft = Vec3(a.x - into.y * width, a.y + into.x * width, a.z + width * 3)
self.vertexWriter.addData3f(aLowLeft)
self.vertexWriter.addData3f(aLowRight)
self.vertexWriter.addData3f(aHighRight)
self.vertexWriter.addData3f(aHighLeft)
self.colorWriter.addData4i(self.leftColor)
self.colorWriter.addData4i(self.rightColor)
self.colorWriter.addData4i(self.leftColor)
self.colorWriter.addData4i(self.rightColor)
return 4
def drawTunnelRowX(self, row, verts):
# BOTTOM: bottom-left, new-bottom-left, bottom-right, new-bottom-right
self.triStrips.addConsecutiveVertices(row - verts + 0, 1)
self.triStrips.addConsecutiveVertices(row + 0, 1)
self.triStrips.addConsecutiveVertices(row - verts + 1, 1)
self.triStrips.addConsecutiveVertices(row + 1, 1)
self.triStrips.closePrimitive()
# RIGHT: (new-bottom-right) bottom-right, new-top-right, top-right
self.triStrips.addConsecutiveVertices(row + 1, 1)
self.triStrips.addConsecutiveVertices(row - verts + 1, 1)
self.triStrips.addConsecutiveVertices(row + 2, 1)
self.triStrips.addConsecutiveVertices(row - verts + 2, 1)
self.triStrips.closePrimitive()
# TOP: top-left, new top-right, new top-left
self.triStrips.addConsecutiveVertices(row - verts + 2, 1)
self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
self.triStrips.addConsecutiveVertices(row + 2, 1)
self.triStrips.addConsecutiveVertices(row + 3, 1)
self.triStrips.closePrimitive()
# LEFT: (new top-left) new bottom-left, top-left, bottom-left, new-bottom-left
self.triStrips.addConsecutiveVertices(row + 3, 1)
self.triStrips.addConsecutiveVertices(row + 0, 1)
self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
self.triStrips.addConsecutiveVertices(row - verts + 0, 1)
self.triStrips.closePrimitive()
return verts * 4
def drawTunnelRow(self, row, verts):
# # clockwise for the inside of the tunnel
# # TOP: new-top-left, top-left, new-top-right, top-right
# self.triStrips.addConsecutiveVertices(row + 3, 1)
# self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
# self.triStrips.addConsecutiveVertices(row + 2, 1)
# self.triStrips.addConsecutiveVertices(row - verts + 2, 1)
# # RIGHT: new-bottom-right, bottom-right
# self.triStrips.addConsecutiveVertices(row + 1, 1)
# self.triStrips.addConsecutiveVertices(row - verts + 1, 1)
# # BOTTOM: new-bottom-left, bottom-left
# self.triStrips.addConsecutiveVertices(row, 1)
# self.triStrips.addConsecutiveVertices(row - verts, 1)
# # LEFT: new top-left, top-left
# self.triStrips.addConsecutiveVertices(row + 3, 1)
# self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
# TOP: new-top-left, top-left, new-top-right, top-right
self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
self.triStrips.addConsecutiveVertices(row + 3, 1)
self.triStrips.addConsecutiveVertices(row - verts + 2, 1)
self.triStrips.addConsecutiveVertices(row + 2, 1)
# RIGHT: new-bottom-right, bottom-right
self.triStrips.addConsecutiveVertices(row - verts + 1, 1)
self.triStrips.addConsecutiveVertices(row + 1, 1)
# BOTTOM: new-bottom-left, bottom-left
self.triStrips.addConsecutiveVertices(row - verts, 1)
self.triStrips.addConsecutiveVertices(row, 1)
# LEFT: new top-left, top-left
self.triStrips.addConsecutiveVertices(row - verts + 3, 1)
self.triStrips.addConsecutiveVertices(row + 3, 1)
self.triStrips.closePrimitive()
return verts * 4
def completeQuadPath(self):
self.geomNode.addGeom(self.geom)
if self.triStrips.getNumPrimitives() == 0:
return
floorMesh = CollisionFloorMesh()
vertexReader = GeomVertexReader(self.vertexData, 'vertex')
tris = self.triStrips.decompose()
print "Decomposed prims:",tris.getNumPrimitives()
p = 0
for i in range(tris.getNumPrimitives()):
v0 = tris.getPrimitiveStart(i)
ve = tris.getPrimitiveEnd(i)
if v0 < ve:
vertexReader.setRow(tris.getVertex(v0))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(tris.getVertex(v0+1))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(tris.getVertex(v0+2))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
floorMesh.addTriangle(p, p+1, p+2)
p += 3
self.floorCollNode.addSolid(floorMesh)
def completeTunnelPath(self):
self.geomNode.addGeom(self.geom)
if self.triStrips.getNumPrimitives() == 0:
return
floorMesh = CollisionFloorMesh()
vertexReader = GeomVertexReader(self.vertexData, 'vertex')
print "Original prims:",self.triStrips.getNumPrimitives()
p = 0
for i in range(self.triStrips.getNumPrimitives()):
v0 = self.triStrips.getPrimitiveStart(i)
ve = self.triStrips.getPrimitiveEnd(i)
j = v0 + 4
# add the bottom triangles
vertexReader.setRow(self.triStrips.getVertex(j))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(self.triStrips.getVertex(j+1))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
vertexReader.setRow(self.triStrips.getVertex(j+2))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
floorMesh.addTriangle(p, p+1, p+2)
vertexReader.setRow(self.triStrips.getVertex(j+3))
floorMesh.addVertex(Point3(vertexReader.getData3f()))
floorMesh.addTriangle(p+1, p+3, p+2)
p += 4
# this adds every triangle, but is not appropriate for a closed path
# tris = self.triStrips.decompose()
# print "Decomposed prims:",tris.getNumPrimitives()
# p = 0
# for i in range(tris.getNumPrimitives()):
# v0 = tris.getPrimitiveStart(i)
# ve = tris.getPrimitiveEnd(i)
# if v0 < ve:
# vertexReader.setRow(tris.getVertex(v0))
# floorMesh.addVertex(Point3(vertexReader.getData3f()))
# vertexReader.setRow(tris.getVertex(v0+1))
# floorMesh.addVertex(Point3(vertexReader.getData3f()))
# vertexReader.setRow(tris.getVertex(v0+2))
# floorMesh.addVertex(Point3(vertexReader.getData3f()))
# floorMesh.addTriangle(p, p+1, p+2)
# p += 3
self.floorCollNode.addSolid(floorMesh)
def updatePhysics(self, task):
pos = self.fpscamera.getPos()
self.info.setText("Position: {0}, {1}, {2}".format(int(pos.x*100)/100., int(pos.y*100)/100., int(pos.z)/100.))
return task.cont
def pandaRender(self):
frameList = []
for node in self.compositeFrames.getiterator('composite-frame'):
if node.tag == "composite-frame" and node.attrib.get("id") == str(self.internalFrameIndex):
for frameCallNode in node:
for frameNode in self.frames.getiterator('frame'):
if frameNode.tag == "frame" and frameNode.attrib.get("id") == frameCallNode.attrib.get("id"):
offsetX = 0 if frameCallNode.attrib.get("offset-x") == None else float(frameCallNode.attrib.get("offset-x"))
offsetY = 0 if frameCallNode.attrib.get("offset-y") == None else float(frameCallNode.attrib.get("offset-y"))
tweenId = frameCallNode.attrib.get("tween")
frameInTween = 0 if frameCallNode.attrib.get("frame-in-tween") == None else int(frameCallNode.attrib.get("frame-in-tween"))
addWidth = 0 if frameNode.attrib.get("w") == None else float(frameNode.attrib.get("w"))
addHeight = 0 if frameNode.attrib.get("h") == None else float(frameNode.attrib.get("h"))
sInPixels = 0 if frameNode.attrib.get("s") == None else float(frameNode.attrib.get("s"))
tInPixels = 0 if frameNode.attrib.get("t") == None else float(frameNode.attrib.get("t"))
swInPixels = sInPixels + addWidth
thInPixels = tInPixels + addHeight
s = (sInPixels / self.baseWidth)
t = 1 - (tInPixels / self.baseHeight) # Complemented to deal with loading image upside down.
S = (swInPixels / self.baseWidth)
T = 1 - (thInPixels / self.baseHeight) # Complemented to deal with loading image upside down.
blend = "overwrite" if frameCallNode.attrib.get("blend") == None else frameCallNode.attrib.get("blend")
scaleX = 1 if frameCallNode.attrib.get("scale-x") == None else float(frameCallNode.attrib.get("scale-x"))
scaleY = 1 if frameCallNode.attrib.get("scale-y") == None else float(frameCallNode.attrib.get("scale-y"))
color = Color(1,1,1,1)
tweenHasColor = False
frameCallHasColor = False
frameCallColorName = frameCallNode.attrib.get("color-name")
if frameCallColorName != None:
# Get color at frame call as first resort.
frameCallHasColor = True
for colorNode in self.colors.getiterator('color'):
if colorNode.tag == 'color' and colorNode.attrib.get("name") == frameCallColorName:
R = 1 if colorNode.attrib.get("r") == None else float(colorNode.attrib.get("r"))
G = 1 if colorNode.attrib.get("g") == None else float(colorNode.attrib.get("g"))
B = 1 if colorNode.attrib.get("b") == None else float(colorNode.attrib.get("b"))
A = 1 if colorNode.attrib.get("a") == None else float(colorNode.attrib.get("a"))
color = Color(R, G, B, A)
break # leave for loop when we find the correct color
pass
if tweenId != None and tweenId != "0":
# Get color at tween frame as second resort.
thisTween = None
frameLength = 1
advancementFunction = "linear"
foundTween = False
pointList = []
colorList = []
for tweenNode in self.tweens.getiterator('motion-tween'):
if tweenNode.tag == "motion-tween" and tweenNode.attrib.get("id") == tweenId:
foundTween = True
frameLength = 1 if tweenNode.attrib.get("length-in-frames") == None else tweenNode.attrib.get("length-in-frames")
advancementFunction = "linear" if tweenNode.attrib.get("advancement-function") == None else tweenNode.attrib.get("advancement-function")
for pointOrColorNode in tweenNode.getiterator():
if pointOrColorNode.tag == "point":
pX = 0 if pointOrColorNode.attrib.get("x") == None else float(pointOrColorNode.attrib.get("x"))
pY = 0 if pointOrColorNode.attrib.get("y") == None else float(pointOrColorNode.attrib.get("y"))
pointList.append(Point(pX, pY, 0))
elif pointOrColorNode.tag == "color-state":
colorName = "white" if pointOrColorNode.attrib.get("name") == None else pointOrColorNode.attrib.get("name")
for colorNode in self.colors.getiterator('color'):
if colorNode.tag == 'color' and colorNode.attrib.get("name") == colorName:
R = 1 if colorNode.attrib.get("r") == None else float(colorNode.attrib.get("r"))
G = 1 if colorNode.attrib.get("g") == None else float(colorNode.attrib.get("g"))
B = 1 if colorNode.attrib.get("b") == None else float(colorNode.attrib.get("b"))
A = 1 if colorNode.attrib.get("a") == None else float(colorNode.attrib.get("a"))
colorList.append(Color(R, G, B, A))
break # leave for loop when we find the correct color reference
pass # Run through all child nodes of selected tween
break # Exit after finding correct tween
pass
if foundTween:
thisTween = Tween(frameLength, advancementFunction, pointList, colorList)
offset = thisTween.XYFromFrame(frameInTween);
offsetFromTweenX = int(offset.X);
offsetFromTweenY = int(offset.Y);
offsetX += int(offset.X);
offsetY += int(offset.Y);
if thisTween.hasColorComponent():
tweenHasColor = True;
if frameCallHasColor == False:
color = thisTween.colorFromFrame(frameInTween);
pass
if frameNode.attrib.get("color-name") != None and frameCallHasColor == False and tweenHasColor == False:
# Get color at frame definition as last resort.
for colorNode in colors.getiterator('color'):
if colorNode.tag == 'color' and colorNode.attrib.get("name") == frameNode.attrib.get("color-name"):
R = 1 if colorNode.attrib.get("r") == None else float(colorNode.attrib.get("r"))
G = 1 if colorNode.attrib.get("g") == None else float(colorNode.attrib.get("g"))
B = 1 if colorNode.attrib.get("b") == None else float(colorNode.attrib.get("b"))
A = 1 if colorNode.attrib.get("a") == None else float(colorNode.attrib.get("a"))
color = Color(R, G, B, A)
break # leave for loop when we find the correct color
pass
rotationZ = 0 if frameCallNode.attrib.get("rotation-z") == None else float(frameCallNode.attrib.get("rotation-z"))
frameList.append(Frame(Bound(offsetX, offsetY, addWidth, addHeight), s, t, S, T, blend, scaleX, scaleY, color, rotationZ))
pass
break # Leave once we've found the appropriate frame
# Prepare tracking list of consumed nodes.
self.clearNodesForDrawing()
# Make an identifier to tack onto primitive names in Panda3d's scene graph.
frameIndexForName = 1
# Loop through loaded frames that make up composite frame.
for loadedFrame in frameList:
# For debugging purposes, print the object.
if False:
loadedFrame.printAsString()
# Set up place to store primitive 3d object; note: requires vertex data made by GeomVertexData
squareMadeByTriangleStrips = GeomTristrips(Geom.UHDynamic)
# Set up place to hold 3d data and for the following coordinates:
# square's points (V3: x, y, z),
# the colors at each point of the square (c4: r, g, b, a), and
# for the UV texture coordinates at each point of the square (t2: S, T).
vertexData = GeomVertexData('square-'+str(frameIndexForName), GeomVertexFormat.getV3c4t2(), Geom.UHDynamic)
vertex = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
texcoord = GeomVertexWriter(vertexData, 'texcoord')
# Add the square's data
# Upper-Left corner of square
vertex.addData3f(-loadedFrame.bound.Width / 2.0, 0, -loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R,loadedFrame.color.G,loadedFrame.color.B,loadedFrame.color.A)
texcoord.addData2f(loadedFrame.s, loadedFrame.T)
# Upper-Right corner of square
vertex.addData3f(loadedFrame.bound.Width / 2.0, 0, -loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R,loadedFrame.color.G,loadedFrame.color.B,loadedFrame.color.A)
texcoord.addData2f(loadedFrame.S, loadedFrame.T)
# Lower-Left corner of square
vertex.addData3f(-loadedFrame.bound.Width / 2.0, 0, loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R,loadedFrame.color.G,loadedFrame.color.B,loadedFrame.color.A)
texcoord.addData2f(loadedFrame.s, loadedFrame.t)
# Lower-Right corner of square
vertex.addData3f(loadedFrame.bound.Width / 2.0, 0, loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R,loadedFrame.color.G,loadedFrame.color.B,loadedFrame.color.A)
texcoord.addData2f(loadedFrame.S, loadedFrame.t)
# Pass data to primitive
squareMadeByTriangleStrips.addNextVertices(4)
squareMadeByTriangleStrips.closePrimitive()
square = Geom(vertexData)
square.addPrimitive(squareMadeByTriangleStrips)
# Pass primtive to drawing node
drawPrimitiveNode=GeomNode('square-'+str(frameIndexForName))
drawPrimitiveNode.addGeom(square)
# Pass node to scene (effect camera)
nodePath = self.effectCameraNodePath.attachNewNode(drawPrimitiveNode)
# Linear dodge:
if loadedFrame.blendMode == "darken":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusFbufferColor, ColorBlendAttrib.OOneMinusIncomingColor))
pass
elif loadedFrame.blendMode == "multiply":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OFbufferColor, ColorBlendAttrib.OZero))
pass
elif loadedFrame.blendMode == "color-burn":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OZero, ColorBlendAttrib.OOneMinusIncomingColor))
pass
elif loadedFrame.blendMode == "linear-burn":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OZero, ColorBlendAttrib.OIncomingColor))
pass
elif loadedFrame.blendMode == "lighten":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MMax, ColorBlendAttrib.OIncomingColor, ColorBlendAttrib.OFbufferColor))
pass
elif loadedFrame.blendMode == "color-dodge":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOne))
pass
elif loadedFrame.blendMode == "linear-dodge":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOneMinusIncomingColor))
pass
else: # Overwrite:
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOneMinusIncomingAlpha))
pass
nodePath.setDepthTest(False)
# Apply texture
nodePath.setTexture(self.tex)
# Apply translation, then rotation, then scaling to node.
nodePath.setPos((loadedFrame.bound.X + loadedFrame.bound.Width / 2.0, 1, -loadedFrame.bound.Y - loadedFrame.bound.Height / 2.0))
nodePath.setR(loadedFrame.rotationZ)
nodePath.setScale(loadedFrame.scaleX, 1, loadedFrame.scaleY)
nodePath.setTwoSided(True)
self.consumedNodesList.append(nodePath)
frameIndexForName = frameIndexForName + 1
# Loop continues on through each frame called in the composite frame.
pass
