def _make_fullscreen_tri(self):
""" Creates the oversized triangle used for rendering """
vformat = GeomVertexFormat.get_v3()
vdata = GeomVertexData("vertices", vformat, Geom.UH_static)
vdata.set_num_rows(3)
vwriter = GeomVertexWriter(vdata, "vertex")
vwriter.add_data3f(-1, 0, -1)
vwriter.add_data3f(3, 0, -1)
vwriter.add_data3f(-1, 0, 3)
gtris = GeomTriangles(Geom.UH_static)
gtris.add_next_vertices(3)
geom = Geom(vdata)
geom.add_primitive(gtris)
geom_node = GeomNode("gn")
geom_node.add_geom(geom)
geom_node.set_final(True)
geom_node.set_bounds(OmniBoundingVolume())
tri = NodePath(geom_node)
tri.set_depth_test(False)
tri.set_depth_write(False)
tri.set_attrib(TransparencyAttrib.make(TransparencyAttrib.M_none), 10000)
tri.set_color(Vec4(1))
tri.set_bin("unsorted", 10)
tri.reparent_to(self._node)
self._tri = tri
class PointMaker():
def __init__(self, name):
self.name = name
self.new()
def new(self):
self.point = 0
self.vdata = GeomVertexData(
self.name, GeomVertexFormat.get_v3c4(), Geom.UHStatic)
self.vdata.set_num_rows(2)
self.vertex = GeomVertexWriter(self.vdata, 'vertex')
self.color = GeomVertexWriter(self.vdata, 'color')
self.prim = GeomPoints(Geom.UHStatic)
def add(self, pos=(0,0,0), color=(1,1,1,1)):
self.vertex.add_data3(pos[0],pos[1],pos[2]+0.02)
self.color.add_data4(color)
self.prim.add_vertex(self.point)
self.point += 1
def wrap_up(self):
self.prim.close_primitive()
geom = Geom(self.vdata)
geom.add_primitive(self.prim)
node = GeomNode('point')
node.add_geom(geom)
return NodePath(node)
def _make_fullscreen_tri(self):
""" Creates the oversized triangle used for rendering """
vformat = GeomVertexFormat.get_v3()
vdata = GeomVertexData("vertices", vformat, Geom.UH_static)
vdata.set_num_rows(3)
vwriter = GeomVertexWriter(vdata, "vertex")
vwriter.add_data3f(-1, 0, -1)
vwriter.add_data3f(3, 0, -1)
vwriter.add_data3f(-1, 0, 3)
gtris = GeomTriangles(Geom.UH_static)
gtris.add_next_vertices(3)
geom = Geom(vdata)
geom.add_primitive(gtris)
geom_node = GeomNode("gn")
geom_node.add_geom(geom)
geom_node.set_final(True)
geom_node.set_bounds(OmniBoundingVolume())
tri = NodePath(geom_node)
tri.set_depth_test(False)
tri.set_depth_write(False)
tri.set_attrib(TransparencyAttrib.make(TransparencyAttrib.M_none), 10000)
tri.set_color(Vec4(1))
tri.set_bin("unsorted", 10)
tri.reparent_to(self._node)
self._tri = tri
def _create_geom(self):
color = ConfigVariableColor('grid-color', DEFAULT_GRID_COLOR)
radius = floor(self.size / (2 * self.spacing))
diameter = (2 * radius + 1)
start = -radius * self.spacing
vertex_format = GeomVertexFormat.get_v3c4()
vertex_data = GeomVertexData('grid', vertex_format, Geom.UH_static)
vertex_data.set_num_rows(diameter * 4)
vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
color_writer = GeomVertexWriter(vertex_data, 'color')
for i, j in product(range(diameter), repeat=2):
vertex_writer.add_data3f(start + i * self.spacing,
start + j * self.spacing, 0.0)
alpha = GRID_ALPHA - GRID_ALPHA * (
Vector(i - radius, j - radius).norm() / radius)
color_writer.add_data4f(color[0], color[1], color[2], alpha)
primitive = GeomLinestrips(Geom.UH_static)
for vertex in vertex_indexes(diameter):
primitive.add_vertex(vertex)
primitive.close_primitive()
self.geom = Geom(vertex_data)
self.geom.add_primitive(primitive)
def geom_node():
array = GeomVertexArrayFormat()
array.add_column("vertex", 3, Geom.NT_float32, Geom.C_point)
array.add_column("normal", 3, Geom.NT_float32, Geom.C_normal)
array.add_column("color", 3, Geom.NT_float32, Geom.C_color)
array.add_column("texcoord", 3, Geom.NT_float32, Geom.C_texcoord)
format = GeomVertexFormat()
format.add_array(array)
format = GeomVertexFormat.register_format(format)
vdata = GeomVertexData("test", format, Geom.UH_static)
vdata.set_num_rows(4)
vertex = GeomVertexWriter(vdata, 'vertex')
normal = GeomVertexWriter(vdata, 'normal')
color = GeomVertexWriter(vdata, 'color')
texcoord = GeomVertexWriter(vdata, 'texcoord')
vertex.add_data3f(1, 0, 0)
normal.add_data3f(0, 0, 1)
color.add_data4f(0, 0, 1, 1)
texcoord.add_data2f(1, 0)
vertex.add_data3f(1, 1, 0)
normal.add_data3f(0, 1, 1)
color.add_data4f(1, 0, 1, 1)
texcoord.add_data2f(1, 1)
geom = Geom(vdata)
node = GeomNode('gnode')
node.add_geom(geom)
return node
def mesh(vertices, normals, colours, triangles):
# TODO: Make this name meaningful in some way
name = 'test'
v3n3c4 = GeomVertexFormat.get_v3n3c4()
data = GeomVertexData(name, v3n3c4, Geom.UHStatic)
data.set_num_rows(len(vertices))
vertex_writer = GeomVertexWriter(data, 'vertex')
normal_writer = GeomVertexWriter(data, 'normal')
colour_writer = GeomVertexWriter(data, 'color')
for vertex in vertices:
vertex_writer.add_data3(*vertex)
for normal in normals:
normal_writer.add_data3(*normal)
for colour in colours:
colour_writer.add_data4(*colour)
prim = GeomTriangles(Geom.UHStatic)
for triangle in triangles:
prim.add_vertices(*triangle)
geom = Geom(data)
geom.add_primitive(prim)
node = GeomNode(name)
node.add_geom(geom)
return node
def get_p3d_geom_node(self, name='UnnamedGeom'):
# type: (Optional[str]) -> GeomNode
"""Returns a Panda3D GeomNode object"""
vertex_data = GeomVertexData(name, GeomVertexFormat.get_v3c4(),
Geom.UH_static)
total_triangles = len(self.__triangles__)
# Every triangle gets its unique set of vertices for flat shading
num_rows = total_triangles * 3
vertex_data.set_num_rows(num_rows)
vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
color_writer = GeomVertexWriter(vertex_data, 'color')
for i in range(total_triangles):
triangle = self.vertices[self.triangles[i]]
vertex_writer.add_data3f(*triangle[0])
vertex_writer.add_data3f(*triangle[1])
vertex_writer.add_data3f(*triangle[2])
triangle_color = self.colors[self.triangles[i]].sum(axis=0) / 3
for _ in [0, 0, 0]:
color_writer.add_data4f(*triangle_color)
geom = Geom(vertex_data)
for i in range(total_triangles):
triangle = GeomTriangles(Geom.UH_static)
first = i * 3
triangle.add_vertex(first)
triangle.add_vertex(first + 1)
triangle.add_vertex(first + 2)
geom.add_primitive(triangle)
node = GeomNode(name)
node.add_geom(geom)
return node
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 _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 _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
class VertexArray(object):
def __init__(self, name='Unnamed Shape'):
self._name = name
self._vert_data = GeomVertexData(
self._name,
GeomVertexFormat.get_v3n3c4t2(),
Geom.UH_static
)
self._vert_writer = GeomVertexWriter(self._vert_data, 'vertex')
self._norm_writer = GeomVertexWriter(self._vert_data, 'normal')
self._color_writer = GeomVertexWriter(self._vert_data, 'color')
self._tex_writer = GeomVertexWriter(self._vert_data, 'texcoord')
self._prim = GeomTriangles(Geom.UH_static)
self._v_id = 0
def set_num_rows(self, num_rows):
self._vert_data.set_num_rows(num_rows)
def add_row(self, point, normal, color, tex):
self._vert_writer.add_data3(point)
self._norm_writer.add_data3(normal)
self._color_writer.add_data4(color)
self._tex_writer.add_data2(tex)
self._v_id += 1
return self._v_id - 1
def add_triangle(self, va, vb, vc):
self._prim.add_vertices(va, vb, vc)
def get_node(self):
geom = Geom(self._vert_data)
geom.add_primitive(self._prim)
node = GeomNode(self._name)
node.add_geom(geom)
return node
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
class SquareMesh():
name: Final[str]
mesh: Final[Geom]
depth: Final[float]
__vertex_data_format: GeomVertexFormat
__vertex_data: GeomVertexData
__triangles: GeomTriangles
__triangle_data: GeomVertexArrayData
__vertex: GeomVertexWriter
__normal: GeomVertexWriter
__texcoord: GeomVertexWriter
def __init__(self, width: int = 1, height: int = 1, depth: Real = 0.1, name: str = 'SquareMesh') -> None:
self.name = name
self.depth = depth
self.__vertex_data_format = GeomVertexFormat. getV3n3t2()
self.__vertex_data = GeomVertexData(name, self.__vertex_data_format, Geom.UHStatic)
self.__vertex_data.set_num_rows(4)
self.mesh = Geom(self.__vertex_data)
self.__triangles = GeomTriangles(Geom.UHStatic)
self.__triangle_data = self.__triangles.modifyVertices()
self.__vertex = GeomVertexWriter(self.__vertex_data, 'vertex')
self.__normal = GeomVertexWriter(self.__vertex_data, 'normal')
self.__texcoord = GeomVertexWriter(self.__vertex_data, 'texcoord')
self.__face_count = 0
def make(x1, y1, z1, x2, y2, z2, tex) -> None:
if x1 == x2:
self.__vertex.add_data3f(x1, y1, z1)
self.__vertex.add_data3f(x2, y2, z1)
self.__vertex.add_data3f(x2, y2, z2)
self.__vertex.add_data3f(x1, y1, z2)
self.__normal.add_data3(normalise(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
self.__normal.add_data3(normalise(2 * x2 - 1, 2 * y2 - 1, 2 * z1 - 1))
self.__normal.add_data3(normalise(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
self.__normal.add_data3(normalise(2 * x1 - 1, 2 * y1 - 1, 2 * z2 - 1))
else:
self.__vertex.add_data3f(x1, y1, z1)
self.__vertex.add_data3f(x2, y1, z1)
self.__vertex.add_data3f(x2, y2, z2)
self.__vertex.add_data3f(x1, y2, z2)
self.__normal.add_data3(normalise(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
self.__normal.add_data3(normalise(2 * x2 - 1, 2 * y1 - 1, 2 * z1 - 1))
self.__normal.add_data3(normalise(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
self.__normal.add_data3(normalise(2 * x1 - 1, 2 * y2 - 1, 2 * z2 - 1))
for data in tex:
self.__texcoord.addData2f(*data)
vertex_id = self.__face_count * 4
self.__triangles.addVertices(vertex_id, vertex_id + 1, vertex_id + 3)
self.__triangles.addVertices(vertex_id + 1, vertex_id + 2, vertex_id + 3)
self.__face_count += 1
if self.depth == 0:
make(0, 0, 0, width, height, 0, [(1.0, 1.0), (0.0, 1.0), (0.0, 0.0), (1.0, 0.0)])
else:
make(0, height, -self.depth, 0, 0, 0, ((0.0, 1.0), (0.0, 0.0), (0.0, 0.0), (0.0, 1.0))) # SIDE
make(0, 0, -self.depth, width, 0, 0, ((0.0, 0.0), (1.0, 0.0), (1.0, 0.0), (0.0, 0.0))) # SIDE
make(width, height, -self.depth, 0, height, 0, ((1.0, 1.0), (0.0, 1.0), (0.0, 1.0), (1.0, 1.0))) # SIDE
make(width, 0, -self.depth, width, height, 0, ((1.0, 0.0), (1.0, 1.0), (1.0, 1.0), (1.0, 0.0))) # SIDE
make(width, height, 0, 0, 0, 0, ((1.0, 1.0), (0.0, 1.0), (0.0, 0.0), (1.0, 0.0))) # TOP
make(0, height, -self.depth, width, 0, -self.depth, ((0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0))) # BOTTOM
self.__triangles.close_primitive()
self.mesh.add_primitive(self.__triangles)
@property
def geom_node(self) -> str:
return 'geom_node'
@geom_node.getter
def geom_node(self) -> GeomNode:
node = GeomNode(self.name)
node.addGeom(self.mesh)
return node
