def getGeomData(geom=None):
"""
returns a dict : data = {"prims":[], "vertices" : [], "normals" : [], "texcoords" : []}
with the data found inside the Geom's GeomPrimitive
"""
if not geom:
return None
data = {"vertices" : [], "normals" : [], "texcoords" : [], "colors" : [], "tangents":[], "binormals":[], "lines":[], "triangles":[], "tristrips":[], "trifans":[]}
#prim = geom.getPrimitive(0)
#prims = {}
#print "before decompose : prim = %s" % (prim)
#prim = prim.decompose()
#print "after decompose : prim = %s" % (prim)
for gPrim in geom.getPrimitives():
for p in range(gPrim.getNumPrimitives()):
s = gPrim.getPrimitiveStart(p)
e = gPrim.getPrimitiveEnd(p)
vertexList = []
for i in range(s, e):
vi = gPrim.getVertex(i)
vertexList.append(vi)
if type(gPrim) is GeomLinestrips:
data["lines"].append(vertexList)
elif type(gPrim) is GeomTriangles:
data["triangles"].append(vertexList)
elif type(gPrim) is GeomTristrips:
data["tristrips"].append(vertexList)
elif type(gPrim) is GeomTrifans:
data["trifans"].append(vertexList)
#print "appended primitive number %s, type is %s" % (p, type(gPrim))
vdata = geom.getVertexData()
vreader = GeomVertexReader(vdata, 'vertex')
nreader = GeomVertexReader(vdata, 'normal')
treader = GeomVertexReader(vdata, 'texcoord')
creader = GeomVertexReader(vdata, 'color')
tanReader = GeomVertexReader(vdata, 'tangent')
binReader = GeomVertexReader(vdata, 'binormal')
while not vreader.isAtEnd():
v = vreader.getData3f()
n = nreader.getData3f()
t = treader.getData2f()
c = creader.getData4f()
tangent = tanReader.getData3f()
binormal = binReader.getData3f()
data["vertices"].append(v)
data["normals"].append(n)
data["texcoords"].append(t)
data["colors"].append(c)
data["tangents"].append(tangent)
data["binormals"].append(binormal)
return data
def normals(self):
vertex_reader = GeomVertexReader(self.vertex_data, 'normal')
vertices = list()
while not vertex_reader.isAtEnd():
v = vertex_reader.getData3f()
v = Vec3(v[0], v[2], v[1])
vertices.append(v)
return vertices
def processVertexData(vdata, mesh):
vertex = GeomVertexReader(vdata, 'vertex')
# texcoord = GeomVertexReader(vdata, 'texcoord')
while not vertex.isAtEnd():
v = vertex.getData3f()
# t = texcoord.getData2f()
# print "v = %s, t = %s" % (repr(v), repr(t))
print("v = %s" % (repr(v)))
mesh.add_vertex((v[0], v[1], v[2]))
def __read_Model(self, field):
data = []
vdata = self.node.getGeom(0).getVertexData()
reader = GeomVertexReader(vdata, field)
get_data, v_type = self.get_dict[field]
while not reader.isAtEnd():
datum = v_type(get_data(reader))
data.append(datum)
return data
def __read_Model(self, field):
data = []
vdata = self.node.getGeom(0).getVertexData()
reader = GeomVertexReader(vdata, field)
get_data, v_type = self.get_dict[field]
while not reader.isAtEnd():
datum = v_type(get_data(reader))
data.append(datum)
return data
def vertex_colors(self):
try:
vcol_reader = GeomVertexReader(self.model.findAllMatches('**/+GeomNode')[0].node().getGeom(0).getVertexData(), 'color')
vcols = list()
while not vcol_reader.isAtEnd():
vcols.append([e for e in vcol_reader.getData4f()])
return vcols
except:
print(f'{self.name}.model has no vertex colors')
return None
def generate(self):
'''(Re)generate the entire terrain erasing any current changes'''
factor = self.blockSize*self.chunkSize
#print "Factor:", factor
for terrain in self.terrains:
terrain.getRoot().removeNode()
self.terrains = []
# Breaking master heightmap into subimages
heightmaps = []
self.xchunks = (self.heightfield.getXSize()-1)/factor
self.ychunks = (self.heightfield.getYSize()-1)/factor
#print "X,Y chunks:", self.xchunks, self.ychunks
n = 0
for y in range(0, self.ychunks):
for x in range(0, self.xchunks):
heightmap = PNMImage(factor+1, factor+1)
heightmap.copySubImage(self.heightfield, 0, 0, xfrom = x*factor, yfrom = y*factor)
heightmaps.append(heightmap)
n += 1
# Generate GeoMipTerrains
n = 0
y = self.ychunks-1
x = 0
for heightmap in heightmaps:
terrain = GeoMipTerrain(str(n))
terrain.setHeightfield(heightmap)
terrain.setBruteforce(self.bruteForce)
terrain.setBlockSize(self.blockSize)
terrain.generate()
self.terrains.append(terrain)
root = terrain.getRoot()
root.reparentTo(self.root)
root.setPos(n%self.xchunks*factor, (y)*factor, 0)
# In order to texture span properly we need to reiterate through every vertex
# and redefine the uv coordinates based on our size, not the subGeoMipTerrain's
root = terrain.getRoot()
children = root.getChildren()
for child in children:
geomNode = child.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.modifyGeom(i)
vdata = geom.modifyVertexData()
texcoord = GeomVertexWriter(vdata, 'texcoord')
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
t = texcoord.setData2f((v[0]+ self.blockSize/2 + self.blockSize*x)/(self.xsize - 1),
(v[1] + self.blockSize/2 + self.blockSize*y)/(self.ysize - 1))
x += 1
if x >= self.xchunks:
x = 0
y -= 1
n += 1
def calculateProfiles(self):
vertexToPlane = {}
# init dict
for p in self.planedata:
vertexToPlane[p] = [[], []]
geomNodeCollection = self.trench.findAllMatches('**/+GeomNode')
print(geomNodeCollection)
# 0 will be the trench - change later
geomNode = geomNodeCollection[0].node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
state = geomNode.getGeomState(i)
vdata = geom.getVertexData()
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
# calculate distance to planes
for p in self.planedata:
if self.deltaInclude(v, p):
if v[1] not in vertexToPlane[p][
0]: # prevent double addition of x values
vertexToPlane[p][0].append(v[1])
vertexToPlane[p][1].append(v[2])
#print(vertexToPlane[1])
# filter xy coordinates
#new_x, new_y = self.deltaFilter()
i = 0
for p in self.planedata:
plt.figure(i)
# sort x coordinates
L = sorted(zip(vertexToPlane[p][0], vertexToPlane[p][1]))
new_x, new_y = zip(*L)
# signal process y values
yhat = savgol_filter(new_y, 21, 5) #81,5
# 1d interpolation
f = interp1d(new_x, yhat, 'quadratic')
i += 1
#print(new_x)
plt.plot(new_x, new_y, color='k', alpha=0.5, linewidth=0.8)
plt.plot(new_x, yhat, color='b', alpha=0.5, linewidth=0.8)
plt.plot(new_x, f(new_x), color='r', alpha=0.5, linewidth=2.0)
plt.legend(['original', 'savgol_filter', 'interpolated (cubic)'])
#plt.plot(new_x, new_y)
#plt.plot(new_x, f(new_x))
plt.show()
def processVertexData(self):
vreader = GeomVertexReader(self.vdata, 'vertex')
nvreader = GeomVertexReader(self.vdata, 'normal')
tvreader = GeomVertexReader(self.vdata, 'texcoord')
while not vreader.isAtEnd():
v = vreader.getData3f()
n = nvreader.getData3f()
t = tvreader.getData2f()
self.vertices.append(v)
self.normals.append(n)
self.texcoords.append(t)
def processVertexData(self): vreader = GeomVertexReader(self.vdata, 'vertex') nvreader = GeomVertexReader(self.vdata, 'normal') tvreader = GeomVertexReader(self.vdata, 'texcoord') while not vreader.isAtEnd(): v = vreader.getData3f() n = nvreader.getData3f() t = tvreader.getData2f() self.vertices.append(v) self.normals.append(n) self.texcoords.append(t)
def getGeomData(geomNode, scale=1):
"""
returns a dict : data = {"prims":[], "vertices" : [], "normals" : [], "texcoords" : []}
with the data found inside the GeomNode's Geom's GeomPrimitive
"""
if not geomNode:
return None
data = {"prims": [], "vertices": [], "normals": [], "texcoords": []}
if geomNode.getNumGeoms() != 1:
print "error : num geoms = %s" % (geomNode.getNumGeoms())
return None
geom = geomNode.getGeom(0)
prim = geom.getPrimitive(0)
prims = {}
#print "before decompose : prim = %s" % (prim)
prim = prim.decompose()
#print "after decompose : prim = %s" % (prim)
for p in range(prim.getNumPrimitives()):
s = prim.getPrimitiveStart(p)
e = prim.getPrimitiveEnd(p)
vertexList = []
#print "adding vertices from %s to %s" % (s, e)
for i in range(s, e):
'''
vi = prim.getVertex(i)
vreader.setRow(vi)
v = vreader.getData3f()
v = VBase3(v[0]*scale, v[1]*scale, v[2]*scale)
vertexList.append(v)
'''
vi = prim.getVertex(i)
vertexList.append(vi)
prims[p] = vertexList
data["prims"].append(vertexList)
vdata = geom.getVertexData()
vreader = GeomVertexReader(vdata, 'vertex')
nvreader = GeomVertexReader(vdata, 'normal')
tvreader = GeomVertexReader(vdata, 'texcoord')
while not vreader.isAtEnd():
v = vreader.getData3f()
n = nvreader.getData3f()
t = tvreader.getData2f()
data["vertices"].append(v)
data["normals"].append(n)
data["texcoords"].append(t)
return data
def getGeomData(geomNode, scale=1):
"""
returns a dict : data = {"prims":[], "vertices" : [], "normals" : [], "texcoords" : []}
with the data found inside the GeomNode's Geom's GeomPrimitive
"""
if not geomNode:
return None
data = {"prims":[], "vertices" : [], "normals" : [], "texcoords" : []}
if geomNode.getNumGeoms()!=1:
print "error : num geoms = %s" % (geomNode.getNumGeoms())
return None
geom = geomNode.getGeom(0)
prim = geom.getPrimitive(0)
prims = {}
#print "before decompose : prim = %s" % (prim)
prim = prim.decompose()
#print "after decompose : prim = %s" % (prim)
for p in range(prim.getNumPrimitives()):
s = prim.getPrimitiveStart(p)
e = prim.getPrimitiveEnd(p)
vertexList = []
#print "adding vertices from %s to %s" % (s, e)
for i in range(s, e):
'''
vi = prim.getVertex(i)
vreader.setRow(vi)
v = vreader.getData3f()
v = VBase3(v[0]*scale, v[1]*scale, v[2]*scale)
vertexList.append(v)
'''
vi = prim.getVertex(i)
vertexList.append(vi)
prims[p]=vertexList
data["prims"].append(vertexList)
vdata = geom.getVertexData()
vreader = GeomVertexReader(vdata, 'vertex')
nvreader = GeomVertexReader(vdata, 'normal')
tvreader = GeomVertexReader(vdata, 'texcoord')
while not vreader.isAtEnd():
v = vreader.getData3f()
n = nvreader.getData3f()
t = tvreader.getData2f()
data["vertices"].append(v)
data["normals"].append(n)
data["texcoords"].append(t)
return data
def _read_vertices(self, mod, path):
"""Read the model vertices and return their positions.
Args:
mod (panda3d.core.NodePath): Model to read vertices from.
path (str): Model filename.
Returns:
dict:
Dict with two lists of points: "wide" - most
part of the block, and "narrow" - smaller
part of the block with big paddings on
every side.
"""
v_reader = GeomVertexReader(
mod.findAllMatches("**/+GeomNode")[0].node().getGeom(0).getVertexData(),
"vertex",
)
surf_vertices = {"wide": [], "narrow": []}
while not v_reader.isAtEnd():
pos = v_reader.getData3()
if pos.is_nan():
continue
if (
# don't remember coordinates of vertices
# on which rails will be set
abs(pos.getX()) < 3.99
and abs(pos.getY()) < 3.99
and not ("turn" in path and abs(pos.getZ()) < 0.0001)
and not ("fork" in path and abs(pos.getZ()) < 0.02)
and not ("surface4" in path and pos.getZ() > 0.08)
and not ("surface5" in path and (pos.getZ() > 0.03 or pos.getZ() < 0))
# don't remember vertices of station and city models
and not ("station" in path and abs(pos.getY()) < 2.1)
and not (
"surface8" in path
and pos.getX() > -1.5
and pos.getX() < 0.25
and pos.getY() > -3.5
and pos.getY() < -1.75
)
and not ("city" in path and abs(pos.getY()) < 2.1)
):
surf_vertices["wide"].append(pos)
if abs(pos.getX()) < 3 and abs(pos.getY()) < 3:
surf_vertices["narrow"].append(pos)
return surf_vertices
def getVertices(self,node,gnode):
geomNode = gnode.node()
ts = node.getTransform()
m = ts.getMat().getUpper3()
p = ts.getMat().getRow3(3)
points=[]
geom = geomNode.getGeoms()[0]
vdata = geom.getVertexData()
reader = GeomVertexReader(vdata, 'vertex')
while not reader.isAtEnd():
v = reader.getData3f()
v = m.xform(v) + p
points.append(Point3(v))
return numpy.array(points,dtype=numpy.float32)
def createOdeEnv(self, model):
geomNodeCollection = model.findAllMatches('**/+GeomNode')
for nodePath in geomNodeCollection:
geomNode = nodePath.node()
#print "\n\nGeomNode: ", geomNode.getName()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
#state = geomNode.getGeomState(i)
T = geomNode.getTransform()
#print " - ", T
pos = T.getPos()
if T.hasComponents():
Q = T.getQuat()
S = T.getScale()
vdata = geom.getVertexData()
vertex = GeomVertexReader(vdata, 'vertex')
#mins and maxes for MBB
minX = 1e10
maxX = -1e10
minY = 1e10
maxY = -1e10
minZ = 1e10
maxZ = -1e10
while not vertex.isAtEnd():
v = vertex.getData3f()
minX = min(minX,v[0])
minY = min(minY,v[1])
minZ = min(minZ,v[2])
maxX = max(maxX,v[0])
maxY = max(maxY,v[1])
maxZ = max(maxZ,v[2])
#print "v = %s" % (repr(v))
#print "X:(%f->%f) Y(%f->%f) Z(%f->%f)" % (minX, maxX, minY, maxY, minZ, maxZ)
minX *= S[0]
maxX *= S[0]
minY *= S[1]
maxY *= S[1]
minZ *= S[2]
maxZ *= S[2]
#print "X:(%f->%f) Y(%f->%f) Z(%f->%f)" % (minX, maxX, minY, maxY, minZ, maxZ)
box = OdeBoxGeom(self.space, maxX-minX, maxY-minY, maxZ-minZ)
box.setPosition(pos)
box.setQuaternion(Q)
self.odeBoxes.append(box)
else:
print "Error Transform does not have components - skipping"
def get3DPointsFromModel(model):
geomNodes = model.findAllMatches('**/+GeomNode')
pts = []
for nodePath in geomNodes:
nodePts = []
geomNode = nodePath.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
vdata = geom.getVertexData()
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
nodePts.append([v.x, v.y, v.z])
pts.append(nodePts)
return np.array(pts)
def registerObject(self, obj):
""" Registers a new dynamic object, this will store an index for every
vertex, which can be used to read and store last position data in order
to compute the velocity. This method also assigns the standard animated
shader to the node """
self.debug("Registering dynamic object")
# Find all GeomNodes
for node in obj.findAllMatches("**/+GeomNode"):
geomNode = node.node()
geomCount = geomNode.getNumGeoms()
# Find all Geoms
for i in xrange(geomCount):
# Modify vertex data
geom = geomNode.modifyGeom(i)
geomVertexData = geom.modifyVertexData()
# Add a new column named "dovindex" to the vertex data
formatArray = GeomVertexArrayFormat()
formatArray.addColumn(InternalName.make("dovindex"), 1,
GeomEnums.NTUint32, GeomEnums.CIndex)
newArrayFormat = GeomVertexFormat(geomVertexData.getFormat())
newArrayFormat.addArray(formatArray)
newArrayFormat = GeomVertexFormat.registerFormat(
newArrayFormat)
# Convert the old vertex data and assign the new vertex data
convertedVertexData = geomVertexData.convertTo(newArrayFormat)
geom.setVertexData(convertedVertexData)
# Write the per-vertex indices the dovindex column
newVertexData = geom.modifyVertexData()
vtxReader = GeomVertexReader(newVertexData, "vertex")
indexWriter = GeomVertexWriter(newVertexData, "dovindex")
while not vtxReader.isAtEnd():
data = vtxReader.getData3f()
indexWriter.setData1i(self.currentIndex)
self.currentIndex += 1
if self.currentIndex > self.maxVertexCount:
self.error("Max dynamic vertex count of",
self.maxVertexCount, "reached!")
def __read_Model(self, field):
get_dict = {
'vertex':(GeomVertexReader.getData3f, LPoint3f),
'normal':(GeomVertexReader.getData3f, LVector3f),
'color':(GeomVertexReader.getData4f, LVector4f),
'texcoord':(GeomVertexReader.getData2f, LVector2f),
'info':(GeomVertexReader.getData4f, list),
'ref':(GeomVertexReader.getData3f, LPoint3f),
'nbr':(GeomVertexReader.getData4f, list)}
data = []
vdata = self.NP.node().getGeom(0).getVertexData()
reader = GeomVertexReader(vdata, field)
get_data, v_type = get_dict[field]
while not reader.isAtEnd():
datum = v_type(get_data(reader))
data.append(datum)
return data
def registerObject(self, obj):
""" Registers a new dynamic object, this will store an index for every
vertex, which can be used to read and store last position data in order
to compute the velocity. This method also assigns the standard animated
shader to the node """
self.debug("Registering dynamic object")
# Find all GeomNodes
for node in obj.findAllMatches("**/+GeomNode"):
geomNode = node.node()
geomCount = geomNode.getNumGeoms()
# Find all Geoms
for i in xrange(geomCount):
# Modify vertex data
geom = geomNode.modifyGeom(i)
geomVertexData = geom.modifyVertexData()
# Add a new column named "dovindex" to the vertex data
formatArray = GeomVertexArrayFormat()
formatArray.addColumn(InternalName.make("dovindex"), 1, GeomEnums.NTUint32, GeomEnums.CIndex)
newArrayFormat = GeomVertexFormat(geomVertexData.getFormat())
newArrayFormat.addArray(formatArray)
newArrayFormat = GeomVertexFormat.registerFormat(newArrayFormat)
# Convert the old vertex data and assign the new vertex data
convertedVertexData = geomVertexData.convertTo(newArrayFormat)
geom.setVertexData(convertedVertexData)
# Write the per-vertex indices the dovindex column
newVertexData = geom.modifyVertexData()
vtxReader = GeomVertexReader(newVertexData, "vertex")
indexWriter = GeomVertexWriter(newVertexData, "dovindex")
while not vtxReader.isAtEnd():
data = vtxReader.getData3f()
indexWriter.setData1i(self.currentIndex)
self.currentIndex += 1
if self.currentIndex > self.maxVertexCount:
self.error("Max dynamic vertex count of", self.maxVertexCount, "reached!")
def deriveModelVertices(modelFilename):
newVisualCar = loader.loadModel(modelFilename)
geomNodeCollection = newVisualCar.findAllMatches('**/+GeomNode')
simpleVertices=[]
for nodePath in geomNodeCollection:
geomNode = nodePath.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
vdata = geom.getVertexData()
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v=vertex.getData3f()
vertexModelX,vertexModelY,vertexModelZ=v
simpleVertices.append([vertexModelX,vertexModelY,vertexModelZ])
self.unmodifiedVertexData=simpleVertices
def deriveModelVertices(modelFilename):
newVisualCar = loader.loadModel(modelFilename)
geomNodeCollection = newVisualCar.findAllMatches('**/+GeomNode')
simpleVertices = []
for nodePath in geomNodeCollection:
geomNode = nodePath.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
vdata = geom.getVertexData()
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
vertexModelX, vertexModelY, vertexModelZ = v
simpleVertices.append(
[vertexModelX, vertexModelY, vertexModelZ])
self.unmodifiedVertexData = simpleVertices
def generate(self):
'''(Re)generate the entire terrain erasing any current changes'''
factor = self.blockSize * self.chunkSize
#print "Factor:", factor
for terrain in self.terrains:
terrain.getRoot().removeNode()
self.terrains = []
# Breaking master heightmap into subimages
heightmaps = []
self.xchunks = (self.heightfield.getXSize() - 1) / factor
self.ychunks = (self.heightfield.getYSize() - 1) / factor
#print "X,Y chunks:", self.xchunks, self.ychunks
n = 0
for y in range(0, self.ychunks):
for x in range(0, self.xchunks):
heightmap = PNMImage(factor + 1, factor + 1)
heightmap.copySubImage(self.heightfield,
0,
0,
xfrom=x * factor,
yfrom=y * factor)
heightmaps.append(heightmap)
n += 1
# Generate GeoMipTerrains
n = 0
y = self.ychunks - 1
x = 0
for heightmap in heightmaps:
terrain = GeoMipTerrain(str(n))
terrain.setHeightfield(heightmap)
terrain.setBruteforce(self.bruteForce)
terrain.setBlockSize(self.blockSize)
terrain.generate()
self.terrains.append(terrain)
root = terrain.getRoot()
root.reparentTo(self.root)
root.setPos(n % self.xchunks * factor, (y) * factor, 0)
# In order to texture span properly we need to reiterate through every vertex
# and redefine the uv coordinates based on our size, not the subGeoMipTerrain's
root = terrain.getRoot()
children = root.getChildren()
for child in children:
geomNode = child.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.modifyGeom(i)
vdata = geom.modifyVertexData()
texcoord = GeomVertexWriter(vdata, 'texcoord')
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
t = texcoord.setData2f(
(v[0] + self.blockSize / 2 + self.blockSize * x) /
(self.xsize - 1),
(v[1] + self.blockSize / 2 + self.blockSize * y) /
(self.ysize - 1))
x += 1
if x >= self.xchunks:
x = 0
y -= 1
n += 1
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
def uvs(self):
vertex_reader = GeomVertexReader(self.vertex_data, 'texcoord')
vertices = list()
while not vertex_reader.isAtEnd():
vertices.append([e for e in vertex_reader.getData2f()])
return vertices
def getGeomData(geom=None):
"""
returns a dict : data = {"prims":[], "vertices" : [], "normals" : [], "texcoords" : []}
with the data found inside the Geom's GeomPrimitive
"""
if not geom:
return None
data = {
"vertices": [],
"normals": [],
"texcoords": [],
"colors": [],
"tangents": [],
"binormals": [],
"lines": [],
"triangles": [],
"tristrips": [],
"trifans": []
}
#prim = geom.getPrimitive(0)
#prims = {}
#print "before decompose : prim = %s" % (prim)
#prim = prim.decompose()
#print "after decompose : prim = %s" % (prim)
for gPrim in geom.getPrimitives():
for p in range(gPrim.getNumPrimitives()):
s = gPrim.getPrimitiveStart(p)
e = gPrim.getPrimitiveEnd(p)
vertexList = []
for i in range(s, e):
vi = gPrim.getVertex(i)
vertexList.append(vi)
if type(gPrim) is GeomLinestrips:
data["lines"].append(vertexList)
elif type(gPrim) is GeomTriangles:
data["triangles"].append(vertexList)
elif type(gPrim) is GeomTristrips:
data["tristrips"].append(vertexList)
elif type(gPrim) is GeomTrifans:
data["trifans"].append(vertexList)
#print "appended primitive number %s, type is %s" % (p, type(gPrim))
vdata = geom.getVertexData()
vreader = GeomVertexReader(vdata, 'vertex')
nreader = GeomVertexReader(vdata, 'normal')
treader = GeomVertexReader(vdata, 'texcoord')
creader = GeomVertexReader(vdata, 'color')
tanReader = GeomVertexReader(vdata, 'tangent')
binReader = GeomVertexReader(vdata, 'binormal')
while not vreader.isAtEnd():
v = vreader.getData3f()
n = nreader.getData3f()
t = treader.getData2f()
c = creader.getData4f()
tangent = tanReader.getData3f()
binormal = binReader.getData3f()
data["vertices"].append(v)
data["normals"].append(n)
data["texcoords"].append(t)
data["colors"].append(c)
data["tangents"].append(tangent)
data["binormals"].append(binormal)
return data
def draw_shape(angles, width, radius):
res = 10
if radius == 0:
point = GeomNode('gnode')
vdata = GeomVertexData('occ', GeomVertexFormat.getV3(), Geom.UHStatic)
vdata.setNumRows(1)
vertex = GeomVertexWriter(vdata, 'vertex')
vertex.addData3f(0, 0, 0)
geom = Geom(vdata)
g = GeomPoints(Geom.UHStatic)
g.addVertex(0)
geom.addPrimitive(g)
point.addGeom(geom)
return point, point
#first, sort angles in ascending order
#if negative is given, translate to range of 2pi
for i in range(len(angles)):
if angles[i] < 0: angles[i] = 360 + angles[i]
angles.sort()
angles = [math.radians(a) for a in angles]
angles.append(angles[0]) #read first angle to account for wrapping around
#function = 'w/sin(theta)'
vdata = GeomVertexData('occ', GeomVertexFormat.getV3(), Geom.UHStatic)
vdata.setNumRows(1)
vertex = GeomVertexWriter(vdata, 'vertex')
numverts = [3] * (len(angles) - 1
) #center, and two points on function lines
for i in range(len(angles) - 1):
#find center point
#L = [None,None]
#sign = [-1,1]
#for p in range(2):
# theta1 = angles[i+p] - sign[p]*math.pi/2
# theta2 = angles[i+p] + sign[p]*math.pi/4
# x1 = width*math.cos(theta1)
# y1 = width*math.sin(theta1)
# r = math.sqrt(2*width**2)
# x2 = r*math.cos(theta2)
# y2 = r*math.sin(theta2)
# L[p] = line([x1,y1], [x2,y2])
#R = intersection(L[0],L[1])
#if R is False:
# R = [x1,y1] #if parallel, shift both lines down by y_width
#vertex.addData3f(R[0],R[1],1)
difang = (angles[i + 1] - angles[i]) / 2
l = width / math.sin(difang)
avgang = (angles[i] + angles[i + 1]) / 2
x0 = l * math.cos(avgang)
y0 = l * math.sin(avgang)
vertex.addData3f(x0, y0, 1)
newang1 = angles[i] + (math.pi / 2 - math.acos(width / radius))
x = radius * math.cos(newang1)
y = radius * math.sin(newang1)
vertex.addData3f(x, y, 1)
newang2 = angles[i + 1] - (math.pi / 2 - math.acos(width / radius))
for angle in arc(newang1, newang2, res):
vertex.addData3f(radius * math.cos(math.radians(angle)),
radius * math.sin(math.radians(angle)), 1)
numverts[i] = numverts[i] + 1
x = radius * math.cos(newang2)
y = radius * math.sin(newang2)
vertex.addData3f(x, y, 1)
#copy all data to the bottom, moving it down to z = -1
vertread = GeomVertexReader(vdata, 'vertex')
while not vertread.isAtEnd():
v = vertread.getData3f()
vertex.addData3f(v[0], v[1], -1)
#draw
geom = Geom(vdata)
#draw top
for i in range(len(angles) - 1):
for j in range(numverts[i] - 2):
ind = sum(numverts[0:i]) + j
g = GeomTriangles(Geom.UHStatic)
g.add_vertices(ind - j, ind + 1, ind + 2)
geom.addPrimitive(g)
#draw bottom
for i in range(len(angles) - 1):
for j in range(numverts[i] - 2):
ind = sum(numverts) + sum(numverts[0:i]) + j
g = GeomTriangles(Geom.UHStatic)
g.add_vertices(ind - j, ind + 2, ind + 1)
geom.addPrimitive(g)
#draw edges
for i in range(len(angles) - 1):
for j in range(numverts[i] - 1):
ind = sum(numverts[0:i]) + j
g = GeomTriangles(Geom.UHStatic)
g.add_vertices(ind, ind + sum(numverts), ind + 1)
g.add_vertices(ind + sum(numverts), ind + 1 + sum(numverts),
ind + 1)
geom.addPrimitive(g)
g = GeomTriangles(Geom.UHStatic)
ind = sum(numverts[0:i])
indx = sum(numverts[0:i + 1])
g.add_vertices(indx - 1, indx + sum(numverts) - 1, ind)
g.add_vertices(indx + sum(numverts) - 1, sum(numverts) + ind, ind)
geom.addPrimitive(g)
#outline object
lines = Geom(vdata)
l = GeomLines(Geom.UHStatic)
for i in range(len(angles) - 1):
for j in range(numverts[i] - 1):
ind = sum(numverts[0:i]) + j
l.add_vertices(ind, ind + 1)
l.add_vertices(sum(numverts) + ind, sum(numverts) + ind + 1)
ind = sum(numverts[0:i])
indx = sum(numverts[0:i + 1])
l.add_vertices(ind, indx - 1)
l.add_vertices(sum(numverts) + ind, sum(numverts) + indx - 1)
l.add_vertices(ind + 1, sum(numverts) + ind + 1)
l.add_vertices(indx - 1, sum(numverts) + indx - 1)
lines.addPrimitive(l)
node = GeomNode('gnode')
node.addGeom(geom)
nodeL = GeomNode('gnode')
nodeL.addGeom(lines)
return node, nodeL
def generateNode(self):
self.destroy()
self.node = NodePath('gameobjectnode')
self.node.setTwoSided(True)
self.node.reparentTo(self.parent.node)
if self.properties['avoidable'] == True:
self.node.setTag("avoidable", 'true')
else:
self.node.setTag("avoidable", 'false')
#setting scripting part
self.node.setTag("onWalked", self.onWalked)
self.node.setTag("onPicked", self.onPicked)
#set unique id
self.node.setTag("id", self.properties['id'])
tex = loader.loadTexture(resourceManager.getResource(self.properties['url'])+'.png')
tex.setWrapV(Texture.WM_clamp)
tex.setWrapU(Texture.WM_clamp)
#this is true pixel art
#change to FTLinear for linear interpolation between pixel colors
tex.setMagfilter(Texture.FTNearest)
tex.setMinfilter(Texture.FTNearest)
xorig = tex.getOrigFileXSize() / self.baseDimension
yorig = tex.getOrigFileYSize() / self.baseDimension
xscaled = (tex.getOrigFileXSize() / self.baseDimension) * self.properties['scale']
yscaled = (tex.getOrigFileYSize() / self.baseDimension) * self.properties['scale']
self.node.setTag("xscaled", str(xscaled))
self.node.setTag("yscaled", str(yscaled))
cm = CardMaker("tileobject")
cm.setFrame(0,xorig,0,yorig)
ts = TextureStage('ts')
ts.setMode(TextureStage.MDecal)
# distinguish between 3d collisions (for objects with an height and sensible self.properties['inclination'])
# and 2d collisions for plain sprites
if self.properties['walkable'] == 'false':
if self.properties['collisionmode'] == "3d":
#must handle differently objects which are small and big
if xscaled < 1:
self.collisionTube = CollisionBox(LPoint3f(0.5 - xscaled/2 - self.properties['offsetwidth'],0,0),LPoint3f(0.5 + xscaled/2 + self.properties['offsetwidth'],0.1,0.3 + self.properties['offsetheight']))
if xscaled >= 1:
self.collisionTube = CollisionBox(LPoint3f(0 - self.properties['offsetwidth'],0,0),LPoint3f(xscaled + self.properties['offsetwidth'],0.1,0.3 + self.properties['offsetheight']))
self.collisionNode = CollisionNode('objectSphere')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
self.collisionNodeNp.setX(self.properties['offsethorizontal'])
self.collisionNodeNp.setZ(self.properties['offsetvertical'])
self.collisionNodeNp.setX(self.collisionNodeNp.getX()+self.properties['offsetcollisionh'])
self.collisionNodeNp.setZ(self.collisionNodeNp.getZ()+self.properties['offsetcollisionv']+0.1)
if main.editormode:
self.collisionNodeNp.show()
elif self.properties['collisionmode'] == "2d":
#must handle differently objects which are small and big
if xscaled < 1:
self.collisionTube = CollisionBox(LPoint3f(0.5 - xscaled/2 - self.properties['offsetwidth'],0,0),LPoint3f(0.5 + xscaled/2 + self.properties['offsetwidth'],yscaled + self.properties['offsetheight'],0.3))
if xscaled >= 1:
self.collisionTube = CollisionBox(LPoint3f(0 - self.properties['offsetwidth'],0,0),LPoint3f(xscaled + self.properties['offsetwidth'],yscaled + self.properties['offsetheight'],0.3))
self.collisionNode = CollisionNode('objectSphere')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
self.collisionNodeNp.setP(-(270-int(self.properties['inclination'])))
self.collisionNodeNp.setX(self.properties['offsethorizontal'])
self.collisionNodeNp.setZ(self.properties['offsetvertical'])
self.collisionNodeNp.setX(self.collisionNodeNp.getX()+self.properties['offsetcollisionh'])
self.collisionNodeNp.setZ(self.collisionNodeNp.getZ()+self.properties['offsetcollisionv']+0.1)
if main.editormode:
self.collisionNodeNp.show()
geomnode = NodePath(cm.generate())
if geomnode.node().isGeomNode():
vdata = geomnode.node().modifyGeom(0).modifyVertexData()
writer = GeomVertexWriter(vdata, 'vertex')
reader = GeomVertexReader(vdata, 'vertex')
'''
this part apply rotation flattening to the perspective view
by modifying directly structure vertices
'''
i = 0 #counter
while not reader.isAtEnd():
v = reader.getData3f()
x = v[0]
y = v[1]
z = v[2]
newx = x
newy = y
newz = z
if self.properties['rotation'] == -90.0:
if i == 0:
newx = math.fabs(math.cos(math.radians(self.properties['inclination']))) * z
newz = 0
ssen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * z
sparsen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * ssen
spercos = math.fabs(math.cos(math.radians(self.properties['inclination']))) * ssen
newy -= spercos
newz += sparsen
if i == 2:
newx += math.fabs(math.cos(math.radians(self.properties['inclination']))) * z
newz = 0
ssen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * z
sparsen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * ssen
spercos = math.fabs(math.cos(math.radians(self.properties['inclination']))) * ssen
newy -= spercos
newz += sparsen
writer.setData3f(newx, newy, newz)
i += 1 #increase vertex counter
if xscaled >= 1:
geomnode.setX(0)
if xscaled < 1:
geomnode.setX(0.5 - xscaled/2)
geomnode.setScale(self.properties['scale'])
geomnode.setX(geomnode.getX()+self.properties['offsethorizontal'])
geomnode.setZ(geomnode.getZ()+self.properties['offsetvertical'])
geomnode.setY(-self.properties['elevation'])
geomnode.setP(int(self.properties['inclination'])-360)
geomnode.setTexture(tex)
geomnode.setTransparency(TransparencyAttrib.MAlpha)
geomnode.reparentTo(self.node)
self.node.setR(self.properties['rotation'])
def createModelClone(self, modelFilename):
newVisualCar = loader.loadModel(modelFilename)
geomNodeCollection = newVisualCar.findAllMatches('**/+GeomNode')
simpleTris = []
self.unmodifiedVertexData = []
for nodePath in geomNodeCollection:
geomNode = nodePath.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
vdata = geom.getVertexData()
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
vertexModelX, vertexModelY, vertexModelZ = v
self.unmodifiedVertexData.append(
[vertexModelX, vertexModelY, vertexModelZ])
for primitiveIndex in range(geom.getNumPrimitives()):
prim = geom.getPrimitive(primitiveIndex)
prim = prim.decompose()
for p in range(prim.getNumPrimitives()):
s = prim.getPrimitiveStart(p)
e = prim.getPrimitiveEnd(p)
singleTriData = []
for i in range(s, e):
vertex.setRow(prim.getVertex(s))
vi = prim.getVertex(i)
singleTriData.append(vi)
simpleTris.append(singleTriData)
simpleVertices = self.unmodifiedVertexData
format = GeomVertexFormat.getV3()
vdata = GeomVertexData('shadow', format, Geom.UHDynamic)
self.pandaVertexData = vdata
vertex = GeomVertexWriter(vdata, 'vertex')
for vertexIndex in range(len(simpleVertices)):
simpleVertex = simpleVertices[vertexIndex]
vertex.addData3f(0, 0, 0)
tris = GeomTriangles(Geom.UHStatic)
for index in range(len(simpleTris)):
simpleTri = simpleTris[index]
tris.addVertex(simpleTri[0])
tris.addVertex(simpleTri[1])
tris.addVertex(simpleTri[2])
tris.closePrimitive()
shadow = Geom(vdata)
shadow.addPrimitive(tris)
snode = GeomNode('shadow')
snode.addGeom(shadow)
self.snode = snode
def __init__(self, mainReference):
self.mainRef = mainReference
# fog experiment
myFog = Fog("Mist")
myFog.setColor(0.6, 0.6, 0.6)
myFog.setExpDensity(0.0007)
render.setFog(myFog)
# loading H_Block
self.H_Block = loader.loadModel("../../models/H_Block/H_Block")
self.H_Block.reparentTo(self.mainRef.render)
# loading H_Block's colision mesh
self.H_Block_col = loader.loadModel("../../models/H_Block/H_Block_collision")
self.H_Block_col.ls()
# creating triangle meshes for all static nodes
self.hBlockRoomGeom = self.H_Block_col.getChild(0).getNode(0).getGeom(0)
self.hBlockBulletMesh = BulletTriangleMesh()
self.hBlockBulletMesh.addGeom(self.hBlockRoomGeom)
self.hBlockBulletShape = BulletTriangleMeshShape(self.hBlockBulletMesh, dynamic=False)
self.bulletHBlockNode = BulletRigidBodyNode('hBlockNode')
self.bulletHBlockNode.addShape(self.hBlockBulletShape)
self.mainRef.world.attachRigidBody(self.bulletHBlockNode)
self.mainRef.render.attachNewNode(self.bulletHBlockNode).setCollideMask(BitMask32.allOn())
# arrays containing all regions and portals dividing those regions
self.convexRegions = []
self.portals = []
self.convexRegionsGeometry = loader.loadModel("../../models/H_Block/ConvexRegions2")
self.portalsGeometry = loader.loadModel("../../models/H_Block/Portals2")
# self.portalsGeometry.reparentTo(self.mainRef.render)
# Regions
self.convexRegions.append( Region(0) ) # Just making the access to convexRegions easier
for convexRegion in self.convexRegionsGeometry.getChild(0).getChildren():
regionNode = convexRegion.getNode(0)
regionID = int( regionNode.getTag("prop") )
self.convexRegions.append( Region(regionID) )
# Get vertices that define the convex region
vertexReader = GeomVertexReader(regionNode.getGeom(0).getVertexData(), InternalName.getVertex())
while( not(vertexReader.isAtEnd() ) ):
data = vertexReader.getData3()
X = data.getX()
Y = data.getY()
Z = data.getZ()
self.convexRegions[-1].vertices.append(Vec3(X,Y,Z))
self.convexRegions = sorted(self.convexRegions, key=lambda convexRegion: convexRegion.regionID)
# Debug
# for cr in self.convexRegions:
# print cr.regionID
# Portals
for portal in self.portalsGeometry.getChild(0).getChildren():
portalNode = portal.getNode(0)
# Get vertices that define the portal
frontiers = []
vertexReader = GeomVertexReader(portalNode.getGeom(0).getVertexData(), InternalName.getVertex())
for i in range(2): # We got 2 vertices per portal
data = vertexReader.getData3()
X = data.getX()
Y = data.getY()
frontiers.append(Vec2(X,Y))
connectedRegionsIDs = map(int, portalNode.getTag("prop").split(','))
self.portals.append( Portal(connectedRegionsIDs, frontiers) )
self.convexRegions[ connectedRegionsIDs[0] ].portalEntrancesList.append( PortalEntrance( self.portals[-1], connectedRegionsIDs[1] ) )
self.convexRegions[ connectedRegionsIDs[1] ].portalEntrancesList.append( PortalEntrance( self.portals[-1], connectedRegionsIDs[0] ) )
def createModelClone(self,modelFilename):
newVisualCar = loader.loadModel(modelFilename)
geomNodeCollection = newVisualCar.findAllMatches('**/+GeomNode')
simpleTris=[]
self.unmodifiedVertexData=[]
for nodePath in geomNodeCollection:
geomNode = nodePath.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
vdata = geom.getVertexData()
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v=vertex.getData3f()
vertexModelX,vertexModelY,vertexModelZ=v
self.unmodifiedVertexData.append([vertexModelX,vertexModelY,vertexModelZ])
for primitiveIndex in range(geom.getNumPrimitives()):
prim=geom.getPrimitive(primitiveIndex)
prim=prim.decompose()
for p in range(prim.getNumPrimitives()):
s = prim.getPrimitiveStart(p)
e = prim.getPrimitiveEnd(p)
singleTriData=[]
for i in range(s, e):
vertex.setRow(prim.getVertex(s))
vi = prim.getVertex(i)
singleTriData.append(vi)
simpleTris.append(singleTriData)
simpleVertices=self.unmodifiedVertexData
format=GeomVertexFormat.getV3()
vdata=GeomVertexData('shadow', format, Geom.UHDynamic)
self.pandaVertexData=vdata
vertex=GeomVertexWriter(vdata, 'vertex')
for vertexIndex in range(len(simpleVertices)):
simpleVertex=simpleVertices[vertexIndex]
vertex.addData3f(0,0,0)
tris=GeomTriangles(Geom.UHStatic)
for index in range(len(simpleTris)):
simpleTri=simpleTris[index]
tris.addVertex(simpleTri[0])
tris.addVertex(simpleTri[1])
tris.addVertex(simpleTri[2])
tris.closePrimitive()
shadow=Geom(vdata)
shadow.addPrimitive(tris)
snode=GeomNode('shadow')
snode.addGeom(shadow)
self.snode=snode
