def generateVertices(self):
self.vertexBuffer.setNumRows(len(self.vertices))
vwriter = GeomVertexWriter(self.vertexBuffer, "vertex")
cwriter = GeomVertexWriter(self.vertexBuffer, "color")
for i in range(len(self.vertices)):
vwriter.setData3f(self.vertices[i])
cwriter.setData4f(self.color)
Geometry.generateVertices(self)
class PointCloudVertexBuffer(object):
def __init__(self, point_cloud_size):
format = GeomVertexFormat.getV3c4t2()
vdata = GeomVertexData('point', format, Geom.UHDynamic)
self._pos_writer = GeomVertexWriter(vdata, 'vertex')
self._color_writer = GeomVertexWriter(vdata, 'color')
self._tex_writer = GeomVertexWriter(vdata, 'texcoord')
self._point_cloud_size = point_cloud_size
self._prev_point_cloud_size = 0
assert point_cloud_size > 0
vdata.setNumRows(point_cloud_size * 6)
self._tex_writer.set_row(0)
set_texture(self._tex_writer, point_cloud_size)
pnts = GeomTriangles(Geom.UHStatic)
pnts.addConsecutiveVertices(0, 3 * 2 * point_cloud_size)
pnts.closePrimitive()
points_geom = Geom(vdata)
points_geom.addPrimitive(pnts)
snode = GeomNode('points')
snode.addGeom(points_geom)
dir_name = osp.dirname(__file__)
# print(osp.join(dir_name, 'pnts_vs.glsl'))
vs_shader = osp.join(dir_name, 'pnts_vs.glsl')
fs_shader = osp.join(dir_name, 'pnts_fs.glsl')
myShader = Shader.load(
Shader.SL_GLSL,
vertex=Filename.fromOsSpecific(vs_shader).getFullpath(),
fragment=Filename.fromOsSpecific(fs_shader).getFullpath())
assert myShader is not None
self.points_node = base.render.attachNewNode(snode)
self.points_node.setPos(0., 0., 0.)
self.points_node.set_shader(myShader)
self.points_node.set_shader_input(
"view_size", (base.win.getXSize(), base.win.getYSize()))
self.points_node.node().setBounds(
BoundingBox((-1000., -1000., -1000.), (1000., 1000., 1000.)))
self.points_node.setTransparency(TransparencyAttrib.MAlpha)
def assign_points(self, point_cloud, color):
assert color.shape[1] == 4
assert color.shape[0] == point_cloud.shape[0]
load_point_cloud(self._pos_writer, self._color_writer,
point_cloud.astype(np.float64),
color.astype(np.float64), self._point_cloud_size,
self._prev_point_cloud_size)
self._prev_point_cloud_size = point_cloud.shape[0]
def clear_pc(self):
self._color_writer.set_row(0)
for i in range(self._point_cloud_size * 6):
self._color_writer.setData4f(1., 1., 1., 0.)
def rain(self, task):
# animate level
self.flood()
# Animate Rain
speed = 1.0
vertex = GeomVertexRewriter(self.rain_vdata, 'vertex')
color = GeomVertexWriter(self.rain_vdata, 'color')
moving = np.random.choice([0, 1],
size=(self.n_points, self.n_points),
p=[999 / 1000, 1. / 1000])
moved = 0
for j in range(self.n_points):
for i in range(self.n_points):
# rain
v = vertex.getData3f()
# start falling
if v[2] == self.n_points:
if moving[j][i] == 1 and self.raining == True:
self.rz[j][i] -= speed
vertex.setData3f(v[0], v[1], self.rz[j][i])
color.setData4f(0.3, 0.3, 1, 1)
moved += 1
else:
vertex.setData3f(v[0], v[1], v[2])
color.setData4f(0.3, 0.3, 1, 0)
# keep falling
elif self.rz[j][i] > self.lz[j][i]:
if self.rz[j][i] - speed > self.lz[j][i]:
self.rz[j][i] -= speed
else:
self.rz[j][i] = self.lz[j][i]
vertex.setData3f(v[0], v[1], self.rz[j][i])
if self.rz[j][i] > self.wz[j][i]:
color.setData4f(0.3, 0.3, 1, 1)
else:
color.setData4f(0.3, 0.3, 1, 0)
moved += 1
# stop falling
else:
# handle rolling drops
v = list(map(int, v))
moved += self.rolling_drops(v, vertex, color, moved, i, j)
if moved == 0:
self.flooding = False
return task.done
return task.cont
def generateVertices(self):
self.vertexBuffer.setNumRows(4)
vwriter = GeomVertexWriter(self.vertexBuffer, "vertex")
cwriter = GeomVertexWriter(self.vertexBuffer, "color")
vwriter.setData3f(self.mins.x, 0, self.mins.z)
cwriter.setData4f(self.color)
vwriter.setData3f(self.mins.x, 0, self.maxs.z)
cwriter.setData4f(self.color)
vwriter.setData3f(self.maxs.x, 0, self.maxs.z)
cwriter.setData4f(self.color)
vwriter.setData3f(self.maxs.x, 0, self.mins.z)
cwriter.setData4f(self.color)
Geometry.generateVertices(self)
def generateVertices(self):
if self.handleType == HandleType.Square:
self.vertexBuffer.setNumRows(len(self.handleOrigins) * 8)
vwriter = GeomVertexWriter(self.vertexBuffer, "vertex")
cwriter = GeomVertexWriter(self.vertexBuffer, "color")
radius = self.radius / self.zoom
add = radius * 0.08
for origin in self.handleOrigins:
ul = Point3(origin.x - radius, 0, origin.z - radius)
lr = Point3(origin.x + radius + add, 0,
origin.z + radius + add)
# Border
vwriter.setData3f(ul.x, 0.1, ul.z)
cwriter.setData4f(self.Black)
vwriter.setData3f(lr.x, 0.1, ul.z)
cwriter.setData4f(self.Black)
vwriter.setData3f(lr.x, 0.1, lr.z)
cwriter.setData4f(self.Black)
vwriter.setData3f(ul.x, 0.1, lr.z)
cwriter.setData4f(self.Black)
ul.x += add
ul.z += add
lr.x -= add
lr.z -= add
vwriter.setData3f(ul.x, 0, ul.z)
cwriter.setData4f(self.White)
vwriter.setData3f(lr.x, 0, ul.z)
cwriter.setData4f(self.White)
vwriter.setData3f(lr.x, 0, lr.z)
cwriter.setData4f(self.White)
vwriter.setData3f(ul.x, 0, lr.z)
cwriter.setData4f(self.White)
Geometry.generateVertices(self)
def __init__(self):
super().__init__()
self.model = 'radiosity_test'
# self.texture = 'project_browser_bg'
self.scale *= 4
player = FirstPersonController()
# self.vertices_colored = 0
#
geomNodeCollection = self.model.findAllMatches('**/+GeomNode')
for nodePath in geomNodeCollection:
geomNode = nodePath.node()
for i in range(geomNode.getNumGeoms()):
# geom = geomNode.getGeom(i) # read
geom = geomNode.modifyGeom(i)
# vdata = geom.getVertexData()
vdata = geom.modifyVertexData()
vertex = GeomVertexReader(vdata, 'vertex')
vert_color = GeomVertexReader(vdata, 'color')
print(vert_color)
normal = GeomVertexReader(vdata, 'normal')
new_color = GeomVertexWriter(vdata, 'color')
verts = list()
while not vertex.isAtEnd():
v = vertex.getData3f()
verts.append(v)
n = normal.getData3f()
try:
c = vert_color.getData4f()
if c == color.yellow:
light_position = v
# light_normal = n
except:
pass
print(len(verts))
vertex = GeomVertexReader(vdata, 'vertex')
# print(vertex)
while not vertex.isAtEnd():
v = vertex.getData3f()
n = normal.getData3f()
try:
c = vert_color.getData4f()
if c != color.yellow:
# if n[0] > .5:
dist = distance(light_position, v)
new_color.setData4f(color.color(0, 0, 1-dist/2))
# new_color.setData4f(color.rgba(n[0], n[1], n[2]))
# break_outer = False
# temp_point = v
# for i in range(1):
# if break_outer:
# break
#
# temp_point = (temp_point[0] + n[0], temp_point[1] + n[1], temp_point[2] + n[2])
# # if distance(temp_point, light_position) < i * i * .2:
# # new_color.setData4f(color.color(60, 1, i/10 , 1))
# # break
# for p in verts:
# dist = distance(temp_point, p)
# if dist < .01:
# print('hit self')
# continue
# elif dist < .5:
# print('hit after', i)
# break
# break_outer = True
# print('ignore')
except:
pass
