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 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
class VertexDataWriter(object):
def __init__(self, vdata):
self.count = 0
self.vertex = GeomVertexWriter(vdata, 'vertex')
self.normal = GeomVertexWriter(vdata, 'normal')
self.color = GeomVertexWriter(vdata, 'color')
self.texcoord = GeomVertexWriter(vdata, 'texcoord')
def add_vertex(self, point, normal, color, texcoord):
self.vertex.add_data3f(point)
self.normal.add_data3f(normal)
self.color.add_data4f(*color)
self.texcoord.add_data2f(*texcoord)
self.count += 1
class VertexDataWriter (object):
def __init__(self, vdata):
self.count = 0
self.vertex = GeomVertexWriter(vdata, 'vertex')
self.normal = GeomVertexWriter(vdata, 'normal')
self.color = GeomVertexWriter(vdata, 'color')
self.texcoord = GeomVertexWriter(vdata, 'texcoord')
def add_vertex(self, point, normal, color, texcoord):
self.vertex.add_data3f(point)
self.normal.add_data3f(normal)
self.color.add_data4f(*color)
self.texcoord.add_data2f(*texcoord)
self.count += 1
class Grid(ShowBase):
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 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 _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
