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 processPrimitive(prim, vdata):
vertex = GeomVertexReader(vdata, 'vertex')
prim = prim.decompose()
for p in range(prim.getNumPrimitives()):
s = prim.getPrimitiveStart(p)
e = prim.getPrimitiveEnd(p)
last = None
roadBuilder.addPrim()
for i in range(s, e):
vi = prim.getVertex(i)
vertex.setRow(vi)
v = vertex.getData3()
if last is not None:
self.road_segments.append([last, v])
roadBuilder.addSegment(last, v)
last = v
def __init__(self, entity, mesh=None, center=(0,0,0)):
super().__init__()
center = Vec3(center)
if mesh == None and entity.model:
mesh = entity.model
# print('''auto generating mesh collider from entity's mesh''')
self.node_path = entity.attachNewNode(CollisionNode('CollisionNode'))
self.collision_polygons = []
if isinstance(mesh, Mesh):
if mesh.triangles:
triangles = mesh.triangles
if not isinstance(mesh.triangles[0], tuple):
triangles = [triangles[i:i + 3] for i in range(0, len(triangles), 3)] # group into groups of three
for tri in triangles:
if len(tri) == 3:
poly = CollisionPolygon(
Vec3(mesh.vertices[tri[2]]),
Vec3(mesh.vertices[tri[1]]),
Vec3(mesh.vertices[tri[0]]),
)
self.collision_polygons.append(poly)
elif len(tri) == 4:
poly = CollisionPolygon(
Vec3(mesh.vertices[tri[3]]),
Vec3(mesh.vertices[tri[2]]),
Vec3(mesh.vertices[tri[1]]),
Vec3(mesh.vertices[tri[0]]))
self.collision_polygons.append(poly)
elif mesh.mode == 'triangle': # no triangle list, so take 3 and 3 vertices
for i in range(0, len(mesh.vertices), 3):
poly = CollisionPolygon(
Vec3(mesh.vertices[i+2]),
Vec3(mesh.vertices[i+1]),
Vec3(mesh.vertices[i]),
)
self.collision_polygons.append(poly)
else:
print('error: mesh collider does not support', mesh.mode, 'mode')
return None
elif isinstance(mesh, NodePath):
from panda3d.core import GeomVertexReader
verts = []
geomNodeCollection = mesh.findAllMatches('**/+GeomNode')
for nodePath in geomNodeCollection:
geomNode = nodePath.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
vdata = geom.getVertexData()
for i in range(geom.getNumPrimitives()):
prim = geom.getPrimitive(i)
vertex_reader = GeomVertexReader(vdata, 'vertex')
prim = prim.decompose()
for p in range(prim.getNumPrimitives()):
s = prim.getPrimitiveStart(p)
e = prim.getPrimitiveEnd(p)
for i in range(s, e):
vi = prim.getVertex(i)
vertex_reader.setRow(vi)
verts.append(vertex_reader.getData3())
for i in range(0, len(verts)-3, 3):
p = CollisionPolygon(Vec3(verts[i+2]), Vec3(verts[i+1]), Vec3(verts[i]))
self.collision_polygons.append(p)
node = self.node_path.node()
for poly in self.collision_polygons:
node.addSolid(poly)
self.visible = False
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 __init__(self, entity, mesh=None, center=(0,0,0)):
super().__init__()
center = Vec3(center)
if mesh == None and entity.model:
mesh = entity.model
# print('''auto generating mesh collider from entity's mesh''')
# from ursina import Mesh # this part is obsolete if I use the old obj loading
# if not isinstance(mesh, Mesh):
# from ursina import mesh_importer
# mesh = eval(mesh_importer.obj_to_ursinamesh(name=mesh.name, save_to_file=False))
# flipped_verts = [v*Vec3(-1,1,1) for v in mesh.vertices] # have to flip it on x axis for some reason
# mesh.vertices = flipped_verts
self.node_path = entity.attachNewNode(CollisionNode('CollisionNode'))
self.node = self.node_path.node()
self.collision_polygons = list()
if isinstance(mesh, Mesh):
if mesh.triangles:
for tri in mesh.triangles:
if len(tri) == 3:
poly = CollisionPolygon(
Vec3(mesh.vertices[tri[2]]),
Vec3(mesh.vertices[tri[1]]),
Vec3(mesh.vertices[tri[0]]),
)
self.collision_polygons.append(poly)
elif len(tri) == 4:
poly = CollisionPolygon(
Vec3(mesh.vertices[tri[2]]),
Vec3(mesh.vertices[tri[1]]),
Vec3(mesh.vertices[tri[0]]))
self.collision_polygons.append(poly)
poly = CollisionPolygon(
Vec3(mesh.vertices[tri[0]]),
Vec3(mesh.vertices[tri[3]]),
Vec3(mesh.vertices[tri[2]]))
self.collision_polygons.append(poly)
elif mesh.mode == 'triangle':
for i in range(0, len(mesh.vertices), 3):
poly = CollisionPolygon(
Vec3(mesh.vertices[i+2]),
Vec3(mesh.vertices[i+1]),
Vec3(mesh.vertices[i]),
)
self.collision_polygons.append(poly)
else:
print('error: mesh collider does not support', mesh.mode, 'mode')
return None
elif isinstance(mesh, NodePath):
from panda3d.core import GeomVertexReader
verts = []
geomNodeCollection = mesh.findAllMatches('**/+GeomNode')
for nodePath in geomNodeCollection:
geomNode = nodePath.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
vdata = geom.getVertexData()
for i in range(geom.getNumPrimitives()):
prim = geom.getPrimitive(i)
vertex_reader = GeomVertexReader(vdata, 'vertex')
prim = prim.decompose()
for p in range(prim.getNumPrimitives()):
s = prim.getPrimitiveStart(p)
e = prim.getPrimitiveEnd(p)
for i in range(s, e):
vi = prim.getVertex(i)
vertex_reader.setRow(vi)
verts.append(vertex_reader.getData3())
for i in range(0, len(verts)-3, 3):
p = CollisionPolygon(Vec3(verts[i+2]), Vec3(verts[i+1]), Vec3(verts[i]))
self.collision_polygons.append(p)
for poly in self.collision_polygons:
self.node.addSolid(poly)
self.visible = False
