def init_node_path(self): if self.node_path: self.node_path.remove() vdata = GeomVertexData('name_me', self.format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') primitive = GeomTristrips(Geom.UHStatic) film_size = base.cam.node().getLens().getFilmSize() x = film_size.getX() / 2.0 z = x * 0.75 vertex.addData3f(-x, 10000, z) vertex.addData3f(x, 10000, z) vertex.addData3f(-x, 10000, -z) vertex.addData3f(x, 10000, -z) color.addData4f(*[x / 255.0 for x in self.color1] + [1.0]) color.addData4f(*[x / 255.0 for x in self.color1] + [1.0]) color.addData4f(*[x / 255.0 for x in self.color2] + [1.0]) color.addData4f(*[x / 255.0 for x in self.color2] + [1.0]) primitive.addNextVertices(4) primitive.closePrimitive() geom = Geom(vdata) geom.addPrimitive(primitive) node = GeomNode('gnode') node.addGeom(geom) self.node_path = base.camera.attachNewNode(node)
def draw(self): format=GeomVertexFormat.getV3n3cpt2() vdata=GeomVertexData('square', format, Geom.UHDynamic) vertex=GeomVertexWriter(vdata, 'vertex') normal=GeomVertexWriter(vdata, 'normal') color=GeomVertexWriter(vdata, 'color') circle=Geom(vdata) # Create vertices vertex.addData3f(self.pos) color.addData4f(self.color) for v in range(self._EDGES): x = self.pos.getX() + (self.size * math.cos((2*math.pi/self._EDGES)*v)) y = self.pos.getY() + (self.size * math.sin((2*math.pi/self._EDGES)*v)) z = self.pos.getZ() vertex.addData3f(x, y, z) color.addData4f(self.color) # Create triangles for t in range(self._EDGES): tri = GeomTriangles(Geom.UHDynamic) tri.addVertex(0) tri.addVertex(t+1) if (t+2) > self._EDGES: tri.addVertex(1) else: tri.addVertex(t+2) tri.closePrimitive() circle.addPrimitive(tri) gn = GeomNode('Circle') gn.addGeom(circle) np = NodePath(gn) np.setHpr(0, 90, 0) return np
def init_node_path_line(self, light_number): if self.node_path_line: self.node_path_line.remove() vdata = GeomVertexData('name_me', self.format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') primitive = GeomLines(Geom.UHStatic) vertex.addData3f(*coords_to_panda(0, 0, 0)) vertex.addData3f(*coords_to_panda(*self.direction.coords)) if light_number == 0: line_color = (0.0, 1.0, 1.0, 1.0) elif light_number == 1: line_color = (1.0, 0.0, 1.0, 1.0) elif light_number == 2: line_color = (1.0, 1.0, 0.0, 1.0) color.addData4f(*line_color) color.addData4f(*line_color) primitive.addNextVertices(2) primitive.closePrimitive() geom = Geom(vdata) geom.addPrimitive(primitive) node = GeomNode('gnode') node.addGeom(geom) self.node_path_line = self.parent.node_path_ui.attachNewNode(node) self.node_path_line.setScale(1000) self.node_path_line.setPos(100, 100, 0) self.show_line(self.parent.parent.lights_edit_window.IsShown())
def drawSquare(self, x1,y1,z1, x2,y2,z2): format=GeomVertexFormat.getV3n3cpt2() vdata=GeomVertexData('square', format, Geom.UHStatic) vertex=GeomVertexWriter(vdata, 'vertex') normal=GeomVertexWriter(vdata, 'normal') color=GeomVertexWriter(vdata, 'color') texcoord=GeomVertexWriter(vdata, 'texcoord') #make sure we draw the sqaure in the right plane #if x1!=x2: vertex.addData3f(x1, y1, z1) vertex.addData3f(x2, y1, z1) vertex.addData3f(x2, y2, z2) vertex.addData3f(x1, y2, z2) normal.addData3f(self.myNormalize(Vec3(2*x1-1, 2*y1-1, 2*z1-1))) normal.addData3f(self.myNormalize(Vec3(2*x2-1, 2*y1-1, 2*z1-1))) normal.addData3f(self.myNormalize(Vec3(2*x2-1, 2*y2-1, 2*z2-1))) normal.addData3f(self.myNormalize(Vec3(2*x1-1, 2*y2-1, 2*z2-1))) #adding different colors to the vertex for visibility color.addData4f(0.0,0.5,0.0,0.5) color.addData4f(0.0,0.5,0.0,0.5) color.addData4f(0.0,0.5,0.0,0.5) color.addData4f(0.0,0.5,0.0,0.5) texcoord.addData2f(0.0, 1.0) texcoord.addData2f(0.0, 0.0) texcoord.addData2f(1.0, 0.0) texcoord.addData2f(1.0, 1.0) #quads arent directly supported by the Geom interface #you might be interested in the CardMaker class if you are #interested in rectangle though tri1=GeomTriangles(Geom.UHStatic) tri2=GeomTriangles(Geom.UHStatic) tri1.addVertex(0) tri1.addVertex(1) tri1.addVertex(3) tri2.addConsecutiveVertices(1,3) tri1.closePrimitive() tri2.closePrimitive() square=Geom(vdata) square.addPrimitive(tri1) square.addPrimitive(tri2) #square.setIntoCollideMask(BitMask32.bit(1)) squareNP = NodePath(GeomNode('square gnode')) squareNP.node().addGeom(square) squareNP.setTransparency(1) squareNP.setAlphaScale(.5) squareNP.setTwoSided(True) squareNP.setCollideMask(BitMask32.bit(1)) return squareNP
def _create_vertex_data(self): """Creates and fills the vertex data store.""" format = GeomVertexFormat.getV3c4() vdata = GeomVertexData('cloud', format, Geom.UHDynamic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') for point, value in self._points.iteritems(): vertex.addData3f(point[0], point[1], value) color.addData4f(*self._color) self._vdata = vdata
def _create_vertex_data(self): """Creates and fills the vertex data store.""" format = GeomVertexFormat.getV3c4() vdata = GeomVertexData('cloud', format, Geom.UHDynamic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') for index, point in enumerate(self._points): vertex.addData3f(*point[0:3]) if self._colors != None: color.addData4f(*self._colors[index]) else: color.addData4f(*self._color) self._vdata = vdata
def init_node_path(self): if self.node_path: self.node_path.remove() vdata = GeomVertexData('name_me', self.format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') primitive = GeomTristrips(Geom.UHStatic) vertex.addData3f(-2.0, -2.0, -2.0) vertex.addData3f(2.0, -2.0, -2.0) vertex.addData3f(0, 2.0, -2.0) vertex.addData3f(0, 0, 2.0) vertex.addData3f(-2.0, -2.0, -2.0) vertex.addData3f(0, 0, 2.0) vertex.addData3f(2.0, -2.0, -2.0) vertex.addData3f(0, 0, 2.0) vertex.addData3f(0, 2.0, -2.0) color_tuple = (1.0, 1.0, 1.0) if self.point == 'A': color_tuple = (1.0, 0.0, 0.0) elif self.point == 'B': color_tuple = (0.0, 1.0, 0.0) elif self.point == 'C': color_tuple = (0.0, 0.0, 1.0) elif self.point == 'D': color_tuple = (1.0, 1.0, 0.0) color.addData4f(*color_tuple + (1.0,)) color.addData4f(*color_tuple + (1.0,)) color.addData4f(*color_tuple + (1.0,)) color.addData4f(*color_tuple + (1.0,)) color.addData4f(*color_tuple + (1.0,)) color.addData4f(*color_tuple + (1.0,)) color.addData4f(*color_tuple + (1.0,)) color.addData4f(*color_tuple + (1.0,)) color.addData4f(*color_tuple + (1.0,)) primitive.addNextVertices(9) primitive.closePrimitive() geom = Geom(vdata) geom.addPrimitive(primitive) node = GeomNode('gnode') node.addGeom(geom) self.node_path = self.parent.parent.node_path_ui.attachNewNode(node) self.node_path.setP(180) self.node_path.setPos(*coords_to_panda(*self.coords))
def makeCircle(vdata, numVertices=40,offset=Vec3(0,0,0), direction=1): circleGeom=Geom(vdata) vertWriter=GeomVertexWriter(vdata, "vertex") normalWriter=GeomVertexWriter(vdata, "normal") colorWriter=GeomVertexWriter(vdata, "color") uvWriter=GeomVertexWriter(vdata, "texcoord") drawWriter=GeomVertexWriter(vdata, "drawFlag") #make sure we start at the end of the GeomVertexData so we dont overwrite anything #that might be there already startRow=vdata.getNumRows() vertWriter.setRow(startRow) colorWriter.setRow(startRow) uvWriter.setRow(startRow) normalWriter.setRow(startRow) drawWriter.setRow(startRow) angle=2*math.pi/numVertices currAngle=angle for i in range(numVertices): position=Vec3(math.cos(currAngle)+offset.getX(), math.sin(currAngle)+offset.getY(),offset.getZ()) vertWriter.addData3f(position) uvWriter.addData2f(position.getX()/2.0+0.5,position.getY()/2.0+0.5) colorWriter.addData4f(1.0, 1.0, 1.0, 1.0) position.setZ(position.getZ()*direction) position.normalize() normalWriter.addData3f(position) #at default Opengl only draws "front faces" (all shapes whose vertices are arranged CCW). We #need direction so we can specify which side we want to be the front face currAngle+=angle*direction circle=GeomTrifans(Geom.UHStatic) circle.addConsecutiveVertices(startRow, numVertices) circle.closePrimitive() circleGeom.addPrimitive(circle) return circleGeom
def init_node_path(self): if self.node_path: self.node_path.remove() vdata = GeomVertexData('name_me', self.format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') primitive = GeomLines(Geom.UHStatic) vertex.addData3f(*coords_to_panda(*self.vector)) vertex.addData3f(*coords_to_panda(*[-x for x in self.vector])) color.addData4f((1.0, 0.0, 0.0, 1.0,)) color.addData4f((0.0, 0.0, 1.0, 1.0,)) primitive.addNextVertices(2) primitive.closePrimitive() geom = Geom(vdata) geom.addPrimitive(primitive) node = GeomNode('gnode') node.addGeom(geom) self.node_path = self.parent.parent.node_path_ui.attachNewNode(node) self.node_path.setScale(20) self.node_path.setPos(*coords_to_panda(*self.coords))
def _create_vertex_data(self): """Creates and fills the vertex data store.""" format = GeomVertexFormat.getV3n3cp() vdata = GeomVertexData("surface", format, Geom.UHDynamic) tri = GeomTriangles(Geom.UHDynamic) vertex = GeomVertexWriter(vdata, "vertex") normal = GeomVertexWriter(vdata, "normal") color = GeomVertexWriter(vdata, "color") for triangle in self._halfedge_mesh.faces: for v in triangle.iter_vertices(): vertex.addData3f(*v.coordinates) normal.addData3f(*v.normal) color.addData4f(*self._color) tri.addNextVertices(1) self._vdata = vdata tri.closePrimitive() self._geom_primitives = [tri]
def _create_vertex_data(self): """Creates and fills the vertex data store.""" format = GeomVertexFormat.getV3n3cp() vdata = GeomVertexData('plane', format, Geom.UHDynamic) vertex = GeomVertexWriter(vdata, 'vertex') normal = GeomVertexWriter(vdata, 'normal') color = GeomVertexWriter(vdata, 'color') for x in xrange(self._width): for y in xrange(self._height): cur_index = x * self._height + y vertex.addData3f(*self._points[cur_index][0:3]) if self._normals: normal.addData3f(*self._normals[cur_index]) else: normal.addData3f(0, 0, 1) color.addData4f(*self._color) self._vdata = vdata
def init_node_path(self): if self.node_path: self.node_path.remove() vdata = GeomVertexData('name_me', self.format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') primitive = GeomLines(Geom.UHStatic) vertex.addData3f(*coords_to_panda(0, 0, 0)) vertex.addData3f(*coords_to_panda(1000, 0, 0)) vertex.addData3f(*coords_to_panda(0, 0, 0)) vertex.addData3f(*coords_to_panda(0, -1000, 0)) vertex.addData3f(*coords_to_panda(0, 0, 0)) vertex.addData3f(*coords_to_panda(0, 0, 1000)) color.addData4f(1.0, 0.0, 0.0, 1.0) color.addData4f(1.0, 0.0, 0.0, 1.0) color.addData4f(0.0, 1.0, 0.0, 1.0) color.addData4f(0.0, 1.0, 0.0, 1.0) color.addData4f(0.0, 0.0, 1.0, 1.0) color.addData4f(0.0, 0.0, 1.0, 1.0) primitive.addNextVertices(6) primitive.closePrimitive() geom = Geom(vdata) geom.addPrimitive(primitive) node = GeomNode('gnode') node.addGeom(geom) self.node_path = self.parent.node_path_ui.attachNewNode(node)
def draw(self): format = GeomVertexFormat.getV3n3cpt2() vdata = GeomVertexData('square', format, Geom.UHDynamic) vertex = GeomVertexWriter(vdata, 'vertex') normal = GeomVertexWriter(vdata, 'normal') color = GeomVertexWriter(vdata, 'color') circle = Geom(vdata) # Create vertices vertex.addData3f(self.pos) color.addData4f(self.color) for v in range(self._EDGES): x = self.pos.getX() + (self.size * math.cos( (2 * math.pi / self._EDGES) * v)) y = self.pos.getY() + (self.size * math.sin( (2 * math.pi / self._EDGES) * v)) z = self.pos.getZ() vertex.addData3f(x, y, z) color.addData4f(self.color) # Create triangles for t in range(self._EDGES): tri = GeomTriangles(Geom.UHDynamic) tri.addVertex(0) tri.addVertex(t + 1) if (t + 2) > self._EDGES: tri.addVertex(1) else: tri.addVertex(t + 2) tri.closePrimitive() circle.addPrimitive(tri) gn = GeomNode('Circle') gn.addGeom(circle) np = NodePath(gn) np.setHpr(0, 90, 0) return np
def create_table_geom(): format = GeomVertexFormat.getV3n3c4t2() # GeomVertexData. vdata = GeomVertexData('table_vertex', format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') normal = GeomVertexWriter(vdata, 'normal') color = GeomVertexWriter(vdata, 'color') texcoord = GeomVertexWriter(vdata, 'texcoord') vertex.addData3f(xmax, ymin, 0) normal.addData3f(0, 0, 1) color.addData4f(0, 0, 1, 1) texcoord.addData2f(1, 0) vertex.addData3f(xmax, ymax, 0) normal.addData3f(0, 0, 1) color.addData4f(0, 0, 1, 1) texcoord.addData2f(1, 1) vertex.addData3f(xmin, ymax, 0) normal.addData3f(0, 0, 1) color.addData4f(0, 0, 1, 1) texcoord.addData2f(0, 1) vertex.addData3f(xmin, ymin, 0) normal.addData3f(0, 0, 1) color.addData4f(0, 0, 1, 1) texcoord.addData2f(0, 0) prim = GeomTriangles(Geom.UHStatic) prim.addVertex(0) prim.addVertex(1) prim.addVertex(2) prim.closePrimitive() prim.addVertex(0) prim.addVertex(2) prim.addVertex(3) prim.closePrimitive() geom = Geom(vdata) geom.addPrimitive(prim) return geom
def init_node_path(self): if self.node_path: self.node_path.remove() polygon = self.source vdata = GeomVertexData('name_me', self.format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') normal = GeomVertexWriter(vdata, 'normal') color = GeomVertexWriter(vdata, 'color') texcoord = GeomVertexWriter(vdata, 'texcoord') primitive = GeomTristrips(Geom.UHStatic) vertex.addData3f(*coords_to_panda(*polygon.A.point.coords)) vertex.addData3f(*coords_to_panda(*polygon.B.point.coords)) vertex.addData3f(*coords_to_panda(*polygon.C.point.coords)) if hasattr(polygon, 'D'): vertex.addData3f(*coords_to_panda(*polygon.D.point.coords)) else: vertex.addData3f(*coords_to_panda(*polygon.C.point.coords)) if polygon.A.normal: normal.addData3f(*coords_to_panda(*polygon.A.normal.coords)) normal.addData3f(*coords_to_panda(*polygon.B.normal.coords)) normal.addData3f(*coords_to_panda(*polygon.C.normal.coords)) if hasattr(polygon, 'D'): normal.addData3f(*coords_to_panda(*polygon.D.normal.coords)) if polygon.A.normal: gray = 1.0 else: gray = 0.0 self.old_color = (gray, gray, gray, 1.0) color.addData4f(gray, gray, gray, 1.0) color.addData4f(gray, gray, gray, 1.0) color.addData4f(gray, gray, gray, 1.0) if hasattr(polygon, 'D'): color.addData4f(gray, gray, gray, 1.0) if polygon.A.texcoord: pal = ((polygon.texture_palette + 1) * 256) texcoord_A = uv_to_panda2(polygon, pal, *polygon.A.texcoord.coords) texcoord_B = uv_to_panda2(polygon, pal, *polygon.B.texcoord.coords) texcoord_C = uv_to_panda2(polygon, pal, *polygon.C.texcoord.coords) texcoord.addData2f(*texcoord_A) texcoord.addData2f(*texcoord_B) texcoord.addData2f(*texcoord_C) if hasattr(polygon, 'D'): texcoord_D = uv_to_panda2(polygon, pal, *polygon.D.texcoord.coords) texcoord.addData2f(*texcoord_D) primitive.addNextVertices(4) primitive.closePrimitive() geom = Geom(vdata) geom.addPrimitive(primitive) node = GeomNode('gnode') node.addGeom(geom) self.node_path = self.parent.node_path_mesh.attachNewNode(node)
def init_node_path(self): if self.node_path: self.node_path.remove() vdata = GeomVertexData('name_me', self.format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') primitive = GeomTristrips(Geom.UHStatic) y = self.height * 12 + self.depth * 12 + 1 try: (slope, rotation) = slope_types[self.slope_type] except KeyError: print 'Unknown slope type:', self.slope_type (slope, rotation) = (flat, 0) if self.slope_height == 0: (slope, rotation) = (flat, 0) scale_y = self.slope_height * 12 vertex.addData3f(*coords_to_panda(-14.0, -slope['sw'] * scale_y, -14.0)) vertex.addData3f(*coords_to_panda(-14.0, -slope['nw'] * scale_y, 14.0)) vertex.addData3f(*coords_to_panda(14.0, -slope['ne'] * scale_y, 14.0)) vertex.addData3f(*coords_to_panda(14.0, -slope['se'] * scale_y, -14.0)) vertex.addData3f(*coords_to_panda(-14.0, -slope['sw'] * scale_y, -14.0)) tile_color = (0.5, 0.5, 1.0) if self.cant_walk: tile_color = (1.0, 0.5, 0.5) if self.cant_cursor: tile_color = (0.5, 0.0, 0.0) if (self.x + self.z) % 2 == 0: tile_color = tuple([x * 0.8 for x in tile_color]) self.tile_color = tile_color color.addData4f(*tile_color + (1.0,)) color.addData4f(*tile_color + (1.0,)) color.addData4f(*tile_color + (1.0,)) color.addData4f(*tile_color + (1.0,)) color.addData4f(*tile_color + (1.0,)) primitive.addNextVertices(5) primitive.closePrimitive() geom = Geom(vdata) geom.addPrimitive(primitive) node = GeomNode('gnode') node.addGeom(geom) self.node_path = self.parent.node_path.attachNewNode(node) self.node_path.setH(rotation) can_stand_height = 0 if not self.cant_cursor: can_stand_height = 1 self.node_path.setPos(*coords_to_panda(self.x * 28 + 14, -((self.height + self.depth) * 12 + 1 + can_stand_height), self.z * 28 + 14)) self.node_path.setTag('terrain_xyz', '%u,%u,%u' % (self.x, self.y, self.z))
class NavMesh(object): notify = directNotify.newCategory("NavMesh") def __init__(self, filepath=None, filename=None): if filename is not None: self._initFromFilename(filepath, filename) def initFromPolyData(self, polyToVerts, vertToPolys, polyToAngles, vertexCoords, environmentHash): ''' Initialize the mesh from a set of polygons. polyToVerts: Dictionary mapping a polygon ID to a set of N vertex IDs vertToPolys: Dictionary mapping a vertex ID to a set of poly IDs (of every poly that includes it) polyToAngles: Dictionary mapping a polygon ID to a set of N angles (in vertex order) vertexCoords: Dictionary mapping a vertex ID to the coordinates of the vertex in worldspace environmentHash: Hash value derived from the same collision geometry as the other arguments. See AreaMapper.getEnvironmentHash(). ''' self.polyToVerts = polyToVerts self.vertToPolys = vertToPolys self.polyToAngles = polyToAngles self.vertexCoords = vertexCoords self.environmentHash = environmentHash self.connectionLookup = {} self.connections = [] self._discoverInitialConnectivity() self.optimizeMesh() def visualize(self, parentNodePath, highlightVerts=[], pathVerts=[], visitedVerts=[]): ''' XXX Should move this into a product-specific class. ''' gFormat = GeomVertexFormat.getV3cp() self.visVertexData = GeomVertexData("OMGVERTEXDATA2", gFormat, Geom.UHDynamic) self.visVertexWriter = GeomVertexWriter(self.visVertexData, "vertex") self.visVertexColorWriter = GeomVertexWriter(self.visVertexData, "color") vertToWriterIndex = {} currIndex = 0 for v in self.vertexCoords.keys(): vertToWriterIndex[v] = currIndex x = self.vertexCoords[v][0] y = self.vertexCoords[v][1] z = self.vertexCoords[v][2] self.visVertexWriter.addData3f(x, y, z + 0.5) if v in highlightVerts: self.visVertexColorWriter.addData4f(1.0, 0.0, 0.0, 1.0) elif v in visitedVerts: self.visVertexColorWriter.addData4f(0.0, 0.0, 1.0, 1.0) else: self.visVertexColorWriter.addData4f(1.0, 1.0, 0.0, 1.0) currIndex += 1 pathOffsetIntoIndex = currIndex for v in pathVerts: self.visVertexWriter.addData3f(v[0], v[1], v[2] + 0.5) self.visVertexColorWriter.addData4f(0.0, 1.0, 0.0, 1.0) currIndex += 1 lines = GeomLinestrips(Geom.UHStatic) for p in self.polyToVerts.keys(): for v in self.polyToVerts[p]: lines.addVertex(vertToWriterIndex[v]) lines.addVertex(vertToWriterIndex[self.polyToVerts[p][0]]) lines.closePrimitive() if len(pathVerts) > 0: for i in xrange(len(pathVerts)): lines.addVertex(pathOffsetIntoIndex + i) lines.closePrimitive() self.visGeom = Geom(self.visVertexData) self.visGeom.addPrimitive(lines) self.visGN = GeomNode("NavMeshVis") self.visGN.addGeom(self.visGeom) self.visNodePath = parentNodePath.attachNewNode(self.visGN) self.visNodePath.setTwoSided(True) def _discoverInitialConnectivity(self): print "Building initial connectivity graph..." for pId in self.polyToVerts.keys(): verts = self.polyToVerts[pId] numVerts = len(verts) candidates = [] neighborPolys = [] for v in verts: candidates += [ p for p in self.vertToPolys[v] if (p not in candidates) and (p != pId) ] for vNum in xrange(numVerts): neighbor = [p for p in candidates if ((verts[vNum] in self.polyToVerts[p]) and \ (verts[(vNum+1)%numVerts] in self.polyToVerts[p]))] if len(neighbor) == 0: neighborPolys.append(None) elif len(neighbor) == 1: neighborPolys.append(neighbor[0]) else: raise "Two neighbors found for the same edge?!?!" self.connectionLookup[pId] = neighborPolys # --------- Begin stitching code --------- def _attemptToMergePolys(self, polyA, polyB): newVerts = [] newAngles = [] newConnections = [] vertsA = self.polyToVerts[polyA] vertsB = self.polyToVerts[polyB] lenA = len(vertsA) lenB = len(vertsB) anglesA = self.polyToAngles[polyA] anglesB = self.polyToAngles[polyB] sharedVerts = [v for v in vertsA if (v in vertsB)] locA = 0 while vertsA[locA] not in sharedVerts: locA += 1 while vertsA[locA] in sharedVerts: locA = (locA - 1) % lenA locA = (locA + 1) % lenA CCWmost = vertsA[locA] CCWmostLocA = locA while vertsA[locA] in sharedVerts: locA = (locA + 1) % lenA locA = (locA - 1) % lenA CWmost = vertsA[locA] CWmostLocA = locA # Convexity Check. # Verify that removing the edge preserves convexity and bail out if not. locA = 0 locB = 0 while vertsA[locA] != CCWmost: locA += 1 while vertsB[locB] != CCWmost: locB += 1 CCWmostAngleSum = anglesA[locA] + anglesB[locB] CCWmostLocB = locB if CCWmostAngleSum > 180: return False locA = 0 locB = 0 while vertsA[locA] != CWmost: locA += 1 while vertsB[locB] != CWmost: locB += 1 CWmostAngleSum = anglesA[locA] + anglesB[locB] if CWmostAngleSum > 180: return False # We've found the CW-most vert of the shared edge. # Now walk A clockwise until we hit the CCW-most vert of the shared edge. newVerts.append(CWmost) newAngles.append(CWmostAngleSum) newConnections.append(self.connectionLookup[polyA][locA]) locA = (locA + 1) % lenA while vertsA[locA] != CCWmost: newVerts.append(vertsA[locA]) newAngles.append(anglesA[locA]) newConnections.append(self.connectionLookup[polyA][locA]) locA = (locA + 1) % lenA # Now we've hit the CCW-most vert of the shared edge. # Walk B clockwise until we get back to the CW-most vert of the shared edge. locB = CCWmostLocB newVerts.append(CCWmost) newAngles.append(CCWmostAngleSum) neighbor = self.connectionLookup[polyB][locB] newConnections.append(neighbor) if neighbor is not None: for i in xrange(len(self.connectionLookup[neighbor])): if self.connectionLookup[neighbor][i] == polyB: self.connectionLookup[neighbor][i] = polyA locB = (locB + 1) % lenB while vertsB[locB] != CWmost: newVerts.append(vertsB[locB]) newAngles.append(anglesB[locB]) neighbor = self.connectionLookup[polyB][locB] newConnections.append(neighbor) if neighbor is not None: for i in xrange(len(self.connectionLookup[neighbor])): if self.connectionLookup[neighbor][i] == polyB: self.connectionLookup[neighbor][i] = polyA locB = (locB + 1) % lenB # We've added every vertex, its proper angle, and connectivity info # to the new polygon. Now replace A with the new guy and remove B. self.polyToVerts[polyA] = newVerts self.polyToAngles[polyA] = newAngles self.connectionLookup[polyA] = newConnections # Make sure we have vertex->poly pointers for all the new verts we added to A. for v in newVerts: if polyA not in self.vertToPolys[v]: self.vertToPolys[v].append(polyA) # Clean up all of B's old vertices. for v in vertsB: self.vertToPolys[v].remove(polyB) if len(self.vertToPolys[v]) == 0: # No one's using this vertex anymore, remove it del self.vertToPolys[v] del self.vertexCoords[v] del self.polyToVerts[polyB] del self.polyToAngles[polyB] del self.connectionLookup[polyB] return True def _attemptToGrowPoly(self, pId): for neighbor in self.connectionLookup.get(pId, []): if (neighbor is not None) and self._attemptToMergePolys( pId, neighbor): return True return False def _growEachPolyOnce(self): grewAtLeastOne = False for pId in self.connectionLookup.keys(): if self._attemptToGrowPoly(pId): grewAtLeastOne = True return grewAtLeastOne def optimizeMesh(self): ''' Takes a mesh that is already functionally complete and optimizes it for better performance. Reduces poly count and cuts out redundant vertices. Also compacts the polygon IDs into a contiguous range from 0 to N. No need to do the same for vertex IDs yet. ''' '''print "Stitching polygons: %s -> " % (len(self.polyToVerts)), orig = len(self.polyToVerts) numPasses = 1 while self._growEachPolyOnce(): print "%s -> " % (len(self.polyToVerts)), numPasses += 1 print "Done!\nPoly count reduced to %0.1f%% of original." % (len(self.polyToVerts)/float(orig)*100.0)''' self._pruneExtraVerts() self._compactPolyIds() self.numNodes = len(self.connections) biggest = 0 biggestPoly = -1 for p in self.polyToVerts: if len(self.polyToVerts[p]) > biggest: biggest = len(self.polyToVerts[p]) biggestPoly = p print "Most verts in a single poly: ", biggest assert biggest < 256 def _cleanPoly(self, polyId): verts = self.polyToVerts[polyId] angles = self.polyToAngles[polyId] neighbors = self.connectionLookup[polyId] numVerts = len(verts) newVerts = [] newAngles = [] newNeighbors = [] for i in xrange(numVerts): if (angles[i] != 180) or \ (len(self.vertToPolys.get(verts[i],[])) > 2) or \ (neighbors[i] != neighbors[(i-1)%numVerts]): # Keep vertex newVerts.append(verts[i]) newAngles.append(angles[i]) newNeighbors.append(neighbors[i]) else: # Remove vertex, this will happen twice so pop it self.vertToPolys.pop(verts[i], None) self.vertexCoords.pop(verts[i], None) if len(verts) != len(newVerts): self.polyToVerts[polyId] = newVerts self.polyToAngles[polyId] = newAngles self.connectionLookup[polyId] = newNeighbors assert len(newVerts) < 256 def _pruneExtraVerts(self): print "Pruning extra vertices..." print "Starting verts: %s" % len(self.vertToPolys) for polyId in self.connectionLookup.keys(): self._cleanPoly(polyId) print "Ending verts: %s" % len(self.vertToPolys) def _compactPolyIds(self): polyList = self.polyToVerts.keys() polyList.sort() oldToNewId = {None: None} newPolyToVerts = {} newPolyToAngles = {} self.connections = [] currId = 0 for oldId in polyList: oldToNewId[oldId] = currId self.connections.append([]) currId += 1 for oldId in polyList: newPolyToVerts[oldToNewId[oldId]] = self.polyToVerts[oldId] newPolyToAngles[oldToNewId[oldId]] = self.polyToAngles[oldId] #self.connections[oldToNewId[oldId]] = [] for edgeNum in xrange(len(self.connectionLookup[oldId])): self.connections[oldToNewId[oldId]].append( oldToNewId[self.connectionLookup[oldId][edgeNum]]) self.polyToVerts = newPolyToVerts self.polyToAngles = newPolyToAngles del self.connectionLookup # --------- Begin pathfinding code --------- def _findCentroid(self, polyId): verts = self.polyToVerts[polyId] numVerts = len(verts) x = 0 y = 0 z = 0 for v in verts: x += self.vertexCoords[v][0] y += self.vertexCoords[v][1] z += self.vertexCoords[v][2] x /= numVerts y /= numVerts z /= numVerts return (x, y, z) ## def _estimateDistanceBetweenPolys(self, polyA, polyB): ## centroidA = self._findCentroid(polyA) ## centroidB = self._findCentroid(polyB) ## dx = centroidA[0] - centroidB[0] ## dy = centroidA[1] - centroidB[1] ## dz = centroidA[2] - centroidB[2] ## return math.sqrt(dx*dx + dy*dy + dz*dz) def _walkToNeighbor(self, currPoly, neighborPoly): currVerts = self.polyToVerts[currPoly] neighborVerts = self.polyToVerts[neighborPoly] lenCurr = len(currVerts) sharedVerts = [v for v in currVerts if (v in neighborVerts)] loc = 0 while currVerts[loc] not in sharedVerts: loc += 1 while currVerts[loc] in sharedVerts: loc = (loc - 1) % lenCurr loc = (loc + 1) % lenCurr CCWmost = currVerts[loc] CCWmostLoc = loc while currVerts[loc] in sharedVerts: loc = (loc + 1) % lenCurr loc = (loc - 1) % lenCurr CWmost = currVerts[loc] CCWmostCoords = self.vertexCoords[CCWmost] CWmostCoords = self.vertexCoords[CWmost] # For now, walk to the midpoint of the connecting edge departingEdge = CCWmostLoc # Don't need this with goal->start search neighborsEdge = 0 while self.connections[neighborPoly][neighborsEdge] != currPoly: neighborsEdge += 1 return (neighborsEdge, ((CWmostCoords[0] + CCWmostCoords[0]) / 2.0, (CWmostCoords[1] + CCWmostCoords[1]) / 2.0, (CWmostCoords[2] + CCWmostCoords[2]) / 2.0)) ## def _remakePath(self,walkBack,currNode): ## if currNode in walkBack: ## p = self._remakePath(walkBack,walkBack[currNode]) ## return p + [currNode,] ## return [currNode,] ## def findRoute(self, startNode, goalNode): ## ''' ## So much love for A*. ## ''' ## nodeToF = {} ## nodeToG = {} ## nodeToH = {} ## walkBack = {} ## #nodeToEntryPoint = {} ## self.nodeToEntryPoint[startNode] = self._findCentroid(startNode) ## nodeToG[startNode] = 0 ## nodeToH[startNode] = self._estimateDistanceBetweenPolys(startNode,goalNode) ## nodeToF[startNode] = nodeToG[startNode] + nodeToH[startNode] ## closedSet = {} ## openSet = {} ## openQueue = PriQueue() # Priority = F score ## openSet[startNode] = 1 ## openQueue.push((nodeToF[startNode],startNode)) ## goalPoint = self._findCentroid(goalNode) ## while len(openSet) > 0: ## f,currNode = openQueue.pop(0) ## del openSet[currNode] ## self.aStarWasHere[currNode] = 1 ## if currNode == goalNode: ## return self._remakePath(walkBack,currNode) ## closedSet[currNode] = 1 ## currPoint = self.nodeToEntryPoint[currNode] ## for neighbor in self.connections[currNode]: ## if (neighbor is not None) and (neighbor not in closedSet): ## departingEdge,newEntryPoint = self._walkToNeighbor(currNode,currPoint,neighbor) ## newG = nodeToG[currNode] + math.sqrt((newEntryPoint[0] - currPoint[0])**2 + \ ## (newEntryPoint[1] - currPoint[1])**2 + \ ## (newEntryPoint[2] - currPoint[2])**2) ## gotHereFasterThanBefore = False ## if neighbor not in openSet: ## openSet[neighbor] = 1 ## gotHereFasterThanBefore = True ## elif newG < nodeToG[neighbor]: ## openQueue.remove((nodeToF[neighbor],neighbor)) ## gotHereFasterThanBefore = True ## if gotHereFasterThanBefore: ## walkBack[neighbor] = currNode ## self.nodeToEntryPoint[neighbor] = newEntryPoint ## nodeToH[neighbor] = math.sqrt((goalPoint[0] - newEntryPoint[0])**2 + \ ## (goalPoint[1] - newEntryPoint[1])**2 + \ ## (goalPoint[2] - newEntryPoint[2])**2) ## nodeToG[neighbor] = newG ## nodeToF[neighbor] = nodeToG[neighbor] + nodeToH[neighbor] ## openQueue.push((nodeToF[neighbor],neighbor)) ## raise "No path found! D:" def _findAllRoutesToGoal(self, goalNode): ''' Find the shortest path from ALL start nodes to the given goal node. (Djikstra) After running, self.pathData[startNode][goalNode] == outgoing edge from startNode to the next node for the given value of goalNode and ALL values of startNode. ''' nodeToG = {} walkBack = {} nodeDeparturePoint = {} nodeDeparturePoint[goalNode] = self._findCentroid(goalNode) nodeToG[goalNode] = 0 closedSet = {} openSet = {} openQueue = PriQueue() openSet[goalNode] = 1 openQueue.push((nodeToG[goalNode], goalNode)) walkBack[goalNode] = (0, goalNode) while len(openSet) > 0: f, currNode = openQueue.pop(0) del openSet[currNode] closedSet[currNode] = 1 currPoint = nodeDeparturePoint[currNode] for neighbor in self.connections[currNode]: if (neighbor is not None) and (neighbor not in closedSet): neighborsEdge, newPoint = self._walkToNeighbor( currNode, neighbor) newG = nodeToG[currNode] + math.sqrt((newPoint[0] - currPoint[0])**2 + \ (newPoint[1] - currPoint[1])**2 + \ (newPoint[2] - currPoint[2])**2) gotHereFasterThanBefore = False if neighbor not in openSet: openSet[neighbor] = 1 gotHereFasterThanBefore = True elif newG < nodeToG[neighbor]: openQueue.remove((nodeToG[neighbor], neighbor)) gotHereFasterThanBefore = True if gotHereFasterThanBefore: walkBack[neighbor] = (neighborsEdge, currNode) nodeDeparturePoint[neighbor] = newPoint nodeToG[neighbor] = newG openQueue.push((nodeToG[neighbor], neighbor)) for startNode in xrange(len(self.connections)): departingEdge = walkBack[startNode][0] assert self.pathData[startNode][goalNode] is None self.pathData[startNode][goalNode] = departingEdge def generatePathData(self, rowRange=None): ''' Entry point for path preprocessing. Solves all pairs shortest path for this mesh. Stores the result in self.pathData. SLOW. Expect 8-10 minutes on Port Royal alone. Currently runs Djikstra on every possible start node. There are faster approaches for APSP, but... ''' if rowRange is None: rowRange = (0, self.numNodes) self.initPathData() for goalNode in xrange(rowRange[0], rowRange[1]): self._findAllRoutesToGoal(goalNode) def createPathTable(self): ''' Takes a 2D array self.pathData and changes it in place. Each row is changed into a run-length encoded string. Then, feeds the data into a new PathTable instance. ''' for row in self.pathData: for val in row: if val == None: raise "Incomplete path data!" shortestPathLookup = self.pathData self.pathData = [] # Run-Length Encode the whole thing! for start in xrange(self.numNodes): row = [] lastVal = None nodesInRow = 0 for goal in xrange(self.numNodes): val = shortestPathLookup[start][goal] if val != lastVal: row.append([goal, val]) lastVal = val nodesInRow += 1 else: nodesInRow += 1 assert nodesInRow == self.numNodes stringsRow = [] # Convert row to a bytestring to save space for item in row: assert item[0] < 65536 assert item[1] < 256 stringsRow.append( chr(item[0] / 256) + chr(item[0] % 256) + chr(item[1])) assert len(stringsRow[-1]) == 3 rowString = string.join(stringsRow, "") self.pathData.append(rowString) self.pathTable = PathTable(self.pathData, self.connections) def printPathData(self): ''' Outputs the pickled path table to stdout. ''' import sys sys.stdout.write(pickle.dumps(self.pathData, protocol=0)) def initPathData(self): self.pathData = [] for i in xrange(self.numNodes): self.pathData.append([ None, ] * self.numNodes) def addPaths(self, partialData): for i in xrange(len(partialData)): for j in xrange(len(partialData[i])): if partialData[i][j] is not None: assert self.pathData[i][j] is None self.pathData[i][j] = partialData[i][j] ## def pathTableLookup(self, startNode, goalNode): ## ''' ## Look up the equivalent of pathData[goalNode][startNode] in our run-length encoded data. ## ''' ## if startNode >= self.numNodes or goalNode >= self.numNodes: ## raise "Invalid node ID. Must be less than self.numNodes (%s)." % self.numNodes ## str = self.pathData[startNode] ## pos = 0 ## while (pos < len(str)) and (256*ord(str[pos]) + ord(str[pos+1]) <= goalNode): ## #print pos, ": ",256*ord(str[pos]) + ord(str[pos+1]) ## pos += 3 ## pos -= 3 ## return ord(str[pos+2]) def findRoute(self, startNode, goalNode): ''' Returns the node-by-node route from startNode to goalNode. ''' return self.pathTable.findRoute(startNode, goalNode) def makeNodeLocator(self, environment): meshNode = CollisionNode("NavMeshNodeLocator") meshNode.setFromCollideMask(BitMask32.allOff()) meshNode.setIntoCollideMask(OTPGlobals.PathFindingBitmask) self.polyHashToPID = {} for pId in self.polyToAngles: vertCount = 0 corners = [] for angle in self.polyToAngles[pId]: if angle != 180: # It's a corner corners.append(vertCount) vertCount += 1 # XXX this code only works for square nodes at present # Unfortunately we can only make triangle or square CollisionPolygons on the fly assert len(corners) == 4 #import pdb #pdb.set_trace() verts = [] for vert in corners: verts.append( (self.vertexCoords[self.polyToVerts[pId][vert]][0], self.vertexCoords[self.polyToVerts[pId][vert]][1], 0)) #import pdb #pdb.set_trace() poly = CollisionPolygon(verts[0], verts[1], verts[2], verts[3]) assert poly not in self.polyHashToPID self.polyHashToPID[poly] = pId meshNode.addSolid(poly) ray = CollisionRay() ray.setDirection(0, 0, -1) ray.setOrigin(0, 0, 0) rayNode = CollisionNode("NavMeshRay") rayNode.setFromCollideMask(OTPGlobals.PathFindingBitmask) rayNode.setIntoCollideMask(BitMask32.allOff()) rayNode.addSolid(ray) self.meshNodePath = environment.attachNewNode(meshNode) self.rayNodePath = environment.attachNewNode(rayNode) self.meshNodePath.setTwoSided(True) self.chq = CollisionHandlerQueue() self.traverser = CollisionTraverser() self.traverser.addCollider(self.rayNodePath, self.chq) def findNodeFromPos(self, environment, x, y): self.rayNodePath.setPos(environment, x, y, 50000) self.chq.clearEntries() self.traverser.traverse(self.meshNodePath) if self.chq.getNumEntries() != 1: self.notify.warning("No node found at position: %s, %s in %s" % (x, y, environment)) return 0 e = self.chq.getEntry(0) assert e.hasInto() if not e.hasInto(): self.notify.warning("No into found for collision %s" % (e)) pId = self.polyHashToPID[e.getInto()] return pId # --------- Begin long-term storage code --------- def writeToFile(self, filename, storePathTable=True): ''' Output the contents of this mesh to the file specified. Saving to a file lets us avoid doing expensive precomputation every time a mesh instance is required. ''' if self.environmentHash is None: raise "Attempted write to file without valid environment hash!" if storePathTable and not self.pathData: raise "Attempted to write empty pathData. Call NavMesh.generatePathTable() first!" f = open(filename, 'wb') if storePathTable: pickle.dump([ self.environmentHash, self.polyToVerts, self.polyToAngles, self.vertexCoords, self.connections, self.pathData ], f, protocol=2) f.close() self.pathData = None else: pickle.dump([ self.environmentHash, self.polyToVerts, self.polyToAngles, self.vertexCoords, self.connections, None ], f, protocol=2) f.close() print "Successfully wrote to file %s." % filename def _initFromString(self, str): contents = pickle.loads(str) self.environmentHash = contents[0] self.polyToVerts = contents[1] self.polyToAngles = contents[2] self.vertexCoords = contents[3] self.connections = contents[4] self.pathData = contents[5] if self.pathData is not None: self.pathTable = PathTable(self.pathData, self.connections) self.pathData = None self.numNodes = len(self.connections) def _initFromFilename(self, filepath, filename): vfs = VirtualFileSystem.getGlobalPtr() filename = Filename(filename) searchPath = DSearchPath() #searchPath.appendDirectory(Filename('.')) #searchPath.appendDirectory(Filename('etc')) #searchPath.appendDirectory(Filename.fromOsSpecific(os.path.expandvars('~'))) #searchPath.appendDirectory(Filename.fromOsSpecific(os.path.expandvars('$HOME'))) searchPath.appendDirectory( Filename.fromOsSpecific(os.path.expandvars(filepath))) found = vfs.resolveFilename(filename, searchPath) if not found: raise IOError, "File not found!" str = vfs.readFile(filename, 1) self._initFromString(str) def checkHash(self, envHash): ''' "Does this mesh represent the environment I think it does?" If this check fails, the mesh is out of date (or being used with the wrong environment). In either case, whoever generated this instance should discard it and create a new mesh from scratch. ''' return envHash == self.environmentHash
def draw_body(self, position, vector_list, radius = 1, keep_drawing = True, num_vertices = 8): circle_geom = Geom(self.vdata) vertex_writer = GeomVertexWriter(self.vdata, "vertex") color_writer = GeomVertexWriter(self.vdata, "color") normal_writer = GeomVertexWriter(self.vdata, "normal") draw_rewriter = GeomVertexRewriter(self.vdata, "drawFlag") tex_rewriter = GeomVertexRewriter(self.vdata, "texcoord") start_row = self.vdata.getNumRows() vertex_writer.setRow(start_row) color_writer.setRow(start_row) normal_writer.setRow(start_row) sCoord = 0 if start_row != 0: tex_rewriter.setRow(start_row - num_vertices) sCoord = tex_rewriter.getData2f().getX() + 1 draw_rewriter.setRow(start_row - num_vertices) if draw_rewriter.getData1f() == False: sCoord -= 1 draw_rewriter.setRow(start_row) tex_rewriter.setRow(start_row) angle_slice = 2 * math.pi / num_vertices current_angle = 0 perp1 = vector_list[1] perp2 = vector_list[2] # write vertex information for i in range(num_vertices): adjacent_circle = position + (perp1 * math.cos(current_angle) + perp2 * math.sin(current_angle)) * radius normal = perp1 * math.cos(current_angle) + perp2 * math.sin(current_angle) normal_writer.addData3f(normal) vertex_writer.addData3f(adjacent_circle) tex_rewriter.addData2f(sCoord, (i + 0.001) / (num_vertices - 1)) color_writer.addData4f(0.5, 0.5, 0.5, 1.0) draw_rewriter.addData1f(keep_drawing) current_angle += angle_slice draw_reader = GeomVertexReader(self.vdata, "drawFlag") draw_reader.setRow(start_row - num_vertices) # we can't draw quads directly so use Tristrips if start_row != 0 and draw_reader.getData1f() != False: lines = GeomTristrips(Geom.UHStatic) half = int(num_vertices * 0.5) for i in range(num_vertices): lines.addVertex(i + start_row) if i < half: lines.addVertex(i + start_row - half) else: lines.addVertex(i + start_row - half - num_vertices) lines.addVertex(start_row) lines.addVertex(start_row - half) lines.closePrimitive() lines.decompose() circle_geom.addPrimitive(lines) circle_geom_node = GeomNode("Debug") circle_geom_node.addGeom(circle_geom) circle_geom_node.setAttrib(CullFaceAttrib.makeReverse(), 1) self.get_model().attachNewNode(circle_geom_node)
def make_layer(self, i, a, b): # get data data = self.subdata[a][b] # set color + alpha of vertex texture def ap(n): alpha = 0 if i == n: alpha = 1.0 return alpha def tp(n): list = [0, 0, 0, 0] if i == n: list = [1, 1, 1, 0.75] return list # set vertex data vdata = GeomVertexData('plane', GeomVertexFormat.getV3n3c4t2(), Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') normal = GeomVertexWriter(vdata, 'normal') color = GeomVertexWriter(vdata, 'color') uv = GeomVertexWriter(vdata, 'texcoord') # set vertices number = 0 for x in range(0, len(data) - 1): for y in range(0, len(data[x]) - 1): # get vertex data v1 = Vec3(x, y, data[x][y]['h']) c1 = data[x][y]['c'] t1 = data[x][y]['texnum'] v2 = Vec3(x+1, y, data[x+1][y]['h']) c2 = data[x+1][y]['c'] t2 = data[x+1][y]['texnum'] v3 = Vec3(x+1, y+1, data[x+1][y+1]['h']) c3 = data[x+1][y+1]['c'] t3 = data[x+1][y+1]['texnum'] v4 = Vec3(x, y+1, data[x][y+1]['h']) c4 = data[x][y+1]['c'] t4 = data[x][y+1]['texnum'] n=(0, 0, 1) # normal # assign vertex colors + alpha a1, a2, a3, a4 = ap(t1), ap(t2), ap(t3), ap(t4) t1, t2, t3, t4 = tp(t1), tp(t2), tp(t3), tp(t4) if v1[2]==0: t1 = [data[x][y]['c'][0], data[x][y]['c'][1], data[x][y]['c'][2], a1] if v2[2]==0: t2 = [data[x+1][y]['c'][0], data[x+1][y]['c'][1], data[x+1][y]['c'][2], a2] if v3[2]==0: t3 = [data[x+1][y+1]['c'][0], data[x+1][y+1]['c'][1], data[x+1][y+1]['c'][2], a3] if v4[2]==0: t4 = [data[x][y+1]['c'][0], data[x][y+1]['c'][1], data[x][y+1]['c'][2], a4] if a1 == 0 and a2 == 0 and a3 == 0 and a4 == 0: continue # add vertices vertex.addData3f(v1) normal.addData3f(*n) color.addData4f(*t1) uv.addData2f(0,0) vertex.addData3f(v2) normal.addData3f(*n) color.addData4f(*t2) uv.addData2f(1,0) vertex.addData3f(v3) normal.addData3f(*n) color.addData4f(*t3) uv.addData2f(1,1) vertex.addData3f(v1) normal.addData3f(*n) color.addData4f(*t1) uv.addData2f(0,0) vertex.addData3f(v3) normal.addData3f(*n) color.addData4f(*t3) uv.addData2f(1,1) vertex.addData3f(v4) normal.addData3f(*n) color.addData4f(*t4) uv.addData2f(0,1) number = number + 2 # add triangles prim = GeomTriangles(Geom.UHStatic) for n in range(number): prim.addVertices((n * 3) + 2, (n * 3) + 0, (n * 3) + 1) prim.closePrimitive() # make geom geom = Geom(vdata) geom.addPrimitive(prim) # make geom node node = GeomNode("layer" + str(i) + "_" + str(a) + "_" + str(b)) node.addGeom(geom) # make mesh nodePath mesh = NodePath(node) # load and assign texture txfile = self.tiles[i]['tex'] tx = base.loader.loadTexture(txfile) tx.setMinfilter(Texture.FTLinearMipmapLinear) mesh.setDepthTest(DepthTestAttrib.MLessEqual) mesh.setDepthWrite(False) mesh.setTransparency(True) mesh.setTexture(tx) # set render order mesh.setBin("", 1) # locate mesh mesh.setPos(self.divsep * (a * int(len(self.data[a]) / self.div)), self.divsep * (b * int(len(self.data[b]) / self.div)), 0.001) # reparent mesh mesh.reparentTo(self.root) # return mesh return mesh
def make_base(self, a, b): # get data data = self.subdata[a][b] # set vertex data vdata = GeomVertexData('plane', GeomVertexFormat.getV3n3c4t2(), Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') normal = GeomVertexWriter(vdata, 'normal') color = GeomVertexWriter(vdata, 'color') uv = GeomVertexWriter(vdata, 'texcoord') # set vertices number = 0 for x in range(0, len(data) - 1): for y in range(0, len(data[x]) - 1): # get vertex data v1 = Vec3(x, y, data[x][y]['h']) v2 = Vec3(x + 1, y, data[x+1][y]['h']) v3 = Vec3(x + 1, y + 1, data[x+1][y+1]['h']) v4 = Vec3(x, y + 1, data[x][y+1]['h']) n = (0, 0, 1) # normal # assign vertex colors + alpha option = 1 # black if option == 1: c = 0 c1 = [c, c, c, 1] c2 = [c, c, c, 1] c3 = [c, c, c, 1] c4 = [c, c, c, 1] # option2: color vertices if option == 2: alpha = 1.0 c1 = [data[x][y]['c'][0], data[x][y]['c'][1], data[x][y]['c'][2], alpha] c2 = [data[x+1][y]['c'][0], data[x+1][y]['c'][1], data[x+1][y]['c'][2], alpha] c3 = [data[x+1][y+1]['c'][0], data[x+1][y+1]['c'][1], data[x+1][y+1]['c'][2], alpha] c4 = [data[x][y+1]['c'][0], data[x][y+1]['c'][1], data[x][y+1]['c'][2], alpha] if option == 3: c1 = self.color_vertex(v1) c2 = self.color_vertex(v2) c3 = self.color_vertex(v3) c4 = self.color_vertex(v4) vertex.addData3f(v1) normal.addData3f(*n) color.addData4f(*c1) uv.addData2f(0,0) vertex.addData3f(v2) normal.addData3f(*n) color.addData4f(*c2) uv.addData2f(1,0) vertex.addData3f(v3) normal.addData3f(*n) color.addData4f(*c3) uv.addData2f(1,1) vertex.addData3f(v1) normal.addData3f(*n) color.addData4f(*c1) uv.addData2f(0,0) vertex.addData3f(v3) normal.addData3f(*n) color.addData4f(*c3) uv.addData2f(1,1) vertex.addData3f(v4) normal.addData3f(*n) color.addData4f(*c4) uv.addData2f(0,1) # # add vertex h # vertex.addData3f(v1) # # normal.addData3f(*n) # vertex.addData3f(v2) # # normal.addData3f(*n) # vertex.addData3f(v3) # # normal.addData3f(*n) # vertex.addData3f(v1) # # normal.addData3f(*n) # vertex.addData3f(v3) # # normal.addData3f(*n) # vertex.addData3f(v4) # # normal.addData3f(*n) # # add vertex color # color.addData4f(*c1) # color.addData4f(*c2) # color.addData4f(*c3) # color.addData4f(*c1) # color.addData4f(*c3) # color.addData4f(*c4) # iterate number = number + 2 # add triangles prim = GeomTriangles(Geom.UHStatic) for n in range(number): prim.addVertices((n * 3) + 2, (n * 3) + 0, (n * 3) + 1) prim.closePrimitive() # make geom geom = Geom(vdata) geom.addPrimitive(prim) # make geom node node = GeomNode("base" + "_" + str(a) + "_" + str(b)) node.addGeom(geom) # make mesh nodePath mesh = NodePath(node) # set render order mesh.setBin("", 1) # locate mesh mesh.setPos(self.divsep * (a * int(len(self.data[a]) / self.div)), self.divsep * (b * int(len(self.data[b]) / self.div)), 0) # reparent mesh mesh.reparentTo(self.root) # return mesh return mesh
def _create_vertex_data(self): """Creates and fills the vertex data store.""" format = GeomVertexFormat.getV3n3cp() vdata = GeomVertexData('surface', format, Geom.UHDynamic) tri = GeomTriangles(Geom.UHDynamic) vertex = GeomVertexWriter(vdata, 'vertex') normal = GeomVertexWriter(vdata, 'normal') color = GeomVertexWriter(vdata, 'color') vertmap = [(0, 1), (1, 2), (2, 3), (3, 0), (4, 5), (5, 6), (6, 7), (7, 4), (0, 4), (1, 5), (2, 6), (3, 7)] def generate_index(x, y, z): return x + \ y * (self._surface.mls_subdivisions+2) + \ z * (self._surface.mls_subdivisions+2)**2 numbering_scheme = [ (0, 0, 1), (1, 0, 1), (1, 0, 0), (0, 0, 0), (0, 1, 1), (1, 1, 1), (1, 1, 0), (0, 1, 0)] vertices = zeros((12,), dtype='3f') vertex_normals = zeros((12,), dtype='3f') # walk the cubes for x_index in range(self._surface.mls_subdivisions+1): for y_index in range(self._surface.mls_subdivisions+1): for z_index in range(self._surface.mls_subdivisions+1): #points = map(lambda offsets: self._surface.mls_points[generate_index(array([x_index, y_index, z_index]) + offsets)], numbering_scheme) points = [ self._surface.mls_points[generate_index(x_index + 0, y_index + 0, z_index + 1)], self._surface.mls_points[generate_index(x_index + 1, y_index + 0, z_index + 1)], self._surface.mls_points[generate_index(x_index + 1, y_index + 0, z_index + 0)], self._surface.mls_points[generate_index(x_index + 0, y_index + 0, z_index + 0)], self._surface.mls_points[generate_index(x_index + 0, y_index + 1, z_index + 1)], self._surface.mls_points[generate_index(x_index + 1, y_index + 1, z_index + 1)], self._surface.mls_points[generate_index(x_index + 1, y_index + 1, z_index + 0)], self._surface.mls_points[generate_index(x_index + 0, y_index + 1, z_index + 0)], ] values = [ self._surface.mls_distances[generate_index(x_index + 0, y_index + 0, z_index + 1)], self._surface.mls_distances[generate_index(x_index + 1, y_index + 0, z_index + 1)], self._surface.mls_distances[generate_index(x_index + 1, y_index + 0, z_index + 0)], self._surface.mls_distances[generate_index(x_index + 0, y_index + 0, z_index + 0)], self._surface.mls_distances[generate_index(x_index + 0, y_index + 1, z_index + 1)], self._surface.mls_distances[generate_index(x_index + 1, y_index + 1, z_index + 1)], self._surface.mls_distances[generate_index(x_index + 1, y_index + 1, z_index + 0)], self._surface.mls_distances[generate_index(x_index + 0, y_index + 1, z_index + 0)], ] #values = map(lambda offsets: self._surface.mls_distances[generate_index(array([x_index, y_index, z_index]) + offsets)], numbering_scheme) cubeindex = self._get_cubeindex(values) for n in range(12): if self.edge_table[cubeindex] & (2**n): t_v, t_n = self._interpolate(points[vertmap[n][0]], points[vertmap[n][1]], values[vertmap[n][0]], values[vertmap[n][1]]) vertices[n] = t_v vertex_normals[n] = t_n/norm(t_n) else: vertices[n] = 0 vertex_normals[n] = 0 triangles = [] i = 0 while self.triangle_table[cubeindex][i] != -1: triangles.append([self.triangle_table[cubeindex][i], self.triangle_table[cubeindex][i+1], self.triangle_table[cubeindex][i+2]]) i += 3 for triangle in triangles: vertex.addData3f(*vertices[triangle[0]]) vertex.addData3f(*vertices[triangle[1]]) vertex.addData3f(*vertices[triangle[2]]) normal.addData3f(*vertex_normals[triangle[0]]) normal.addData3f(*vertex_normals[triangle[1]]) normal.addData3f(*vertex_normals[triangle[2]]) #color.addData4f(self._color[0], self._color[1], self._color[2], self._color[3]) #color.addData4f(self._color[0], self._color[1], self._color[2], self._color[3]) #color.addData4f(self._color[0], self._color[1], self._color[2], self._color[3]) color.addData4f(*self._color) color.addData4f(*self._color) color.addData4f(*self._color) tri.addNextVertices(3) self._vdata = vdata tri.closePrimitive() self._geom_primitives = [tri, ]
def generate_sphere(name, radius, resolution): """ Generates a sphere with the provided resolution. @type name: string @param name: Name of this sphere. @type radius: number @param radius: Radius of sphere in kilometers. @type resolution: number @param resolution: Resolution of sphere (minimum 2) @rtype: GeomNode @return: A GeomNode with the given sphere. """ if resolution < 2: raise ValueError, "resolution must be >= 2" horizBands = resolution*2 vertBands = horizBands*2 vertexFormat = GeomVertexFormat.getV3n3c4t2() vdata = GeomVertexData('%s_vdata' % name, vertexFormat, Geom.UHDynamic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') normal = GeomVertexWriter(vdata, 'normal') texcoord = GeomVertexWriter(vdata, 'texcoord') vertDelta = omath.TWOPI / vertBands horizDelta = omath.TWOPI / horizBands numVertices = 0 for i in range(vertBands+1): lowTheta = i * vertDelta highTheta = (i+1) * vertDelta cosLowTheta = math.cos(lowTheta) sinLowTheta = math.sin(lowTheta) cosHighTheta = math.cos(highTheta) sinHighTheta = math.sin(highTheta) for j in range(horizBands): horizTheta = j * horizDelta cosHorizTheta = math.cos(horizTheta) sinHorizTheta = math.sin(horizTheta) ex = cosLowTheta*cosHorizTheta ey = sinLowTheta ez = cosLowTheta*sinHorizTheta vertex.addData3f(ex*radius, ey*radius, ez*radius) normal.addData3f(ex, ey, ez) color.addData4f(.75, .75, .75, 1) texcoord.addData2f(i / vertBands, j / horizBands) ex = cosHighTheta*cosHorizTheta ey = sinHighTheta ez = cosHighTheta*sinHorizTheta vertex.addData3f(ex*radius, ey*radius, ez*radius) normal.addData3f(ex, ey, ez) color.addData4f(.75, .75, .75, 1) texcoord.addData2f(i / vertBands, j / horizBands) numVertices += 2 prim = GeomTristrips(Geom.UHStatic) prim.addConsecutiveVertices(0, numVertices) prim.closePrimitive() geom = Geom(vdata) geom.addPrimitive(prim) geomNode = GeomNode(name) geomNode.addGeom(geom) return GeomScaler(geomNode)
def draw(self): format = GeomVertexFormat.getV3n3cpt2() vdata = GeomVertexData('square', format, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') normal = GeomVertexWriter(vdata, 'normal') color = GeomVertexWriter(vdata, 'color') texcoord = GeomVertexWriter(vdata, 'texcoord') #make sure we draw the sqaure in the right plane #if x1!=x2: vertex.addData3f(self.x1, self.y1, self.z1) vertex.addData3f(self.x2, self.y1, self.z1) vertex.addData3f(self.x2, self.y2, self.z2) vertex.addData3f(self.x1, self.y2, self.z2) normal.addData3f( Vec3(2 * self.x1 - 1, 2 * self.y1 - 1, 2 * self.z1 - 1).normalize()) normal.addData3f( Vec3(2 * self.x2 - 1, 2 * self.y1 - 1, 2 * self.z1 - 1).normalize()) normal.addData3f( Vec3(2 * self.x2 - 1, 2 * self.y2 - 1, 2 * self.z2 - 1).normalize()) normal.addData3f( Vec3(2 * self.x1 - 1, 2 * self.y2 - 1, 2 * self.z2 - 1).normalize()) #adding different colors to the vertex for visibility color.addData4f(self.r, self.g, self.b, self.a) color.addData4f(self.r, self.g, self.b, self.a) color.addData4f(self.r, self.g, self.b, self.a) color.addData4f(self.r, self.g, self.b, self.a) texcoord.addData2f(0.0, 1.0) texcoord.addData2f(0.0, 0.0) texcoord.addData2f(1.0, 0.0) texcoord.addData2f(1.0, 1.0) #quads arent directly supported by the Geom interface #you might be interested in the CardMaker class if you are #interested in rectangle though tri1 = GeomTriangles(Geom.UHStatic) tri2 = GeomTriangles(Geom.UHStatic) tri1.addVertex(0) tri1.addVertex(1) tri1.addVertex(3) tri2.addConsecutiveVertices(1, 3) tri1.closePrimitive() tri2.closePrimitive() square = Geom(vdata) square.addPrimitive(tri1) square.addPrimitive(tri2) #square.setIntoCollideMask(BitMask32.bit(1)) self.squareNP = NodePath(GeomNode('square gnode')) self.squareNP.node().addGeom(square) self.squareNP.setTransparency(1) self.squareNP.setAlphaScale(.5) self.squareNP.setTwoSided(True) #squareNP.setCollideMask(BitMask32.bit(1)) self.squareNP.reparentTo(self.parent) return self.squareNP
def drawBody(nodePath, vdata, pos, vecList, radius=1, keepDrawing=True,numVertices=8): circleGeom=Geom(vdata) vertWriter=GeomVertexWriter(vdata, "vertex") colorWriter=GeomVertexWriter(vdata, "color") normalWriter=GeomVertexWriter(vdata, "normal") drawReWriter=GeomVertexRewriter(vdata, "drawFlag") texReWriter=GeomVertexRewriter(vdata, "texcoord") startRow=vdata.getNumRows() vertWriter.setRow(startRow) colorWriter.setRow(startRow) normalWriter.setRow(startRow) sCoord=0 if (startRow!=0): texReWriter.setRow(startRow-numVertices) sCoord=texReWriter.getData2f().getX()+1 drawReWriter.setRow(startRow-numVertices) if(drawReWriter.getData1f()==False): sCoord-=1 drawReWriter.setRow(startRow) texReWriter.setRow(startRow) angleSlice=2*math.pi/numVertices currAngle=0 #axisAdj=Mat4.rotateMat(45, axis)*Mat4.scaleMat(radius)*Mat4.translateMat(pos) perp1=vecList[1] perp2=vecList[2] #vertex information is written here for i in range(numVertices): adjCircle=pos+(perp1*math.cos(currAngle)+perp2*math.sin(currAngle))*radius normal=perp1*math.cos(currAngle)+perp2*math.sin(currAngle) normalWriter.addData3f(normal) vertWriter.addData3f(adjCircle) texReWriter.addData2f(sCoord,(i+0.001)/(numVertices-1)) colorWriter.addData4f(0.5,0.5,0.5,1) drawReWriter.addData1f(keepDrawing) currAngle+=angleSlice drawReader=GeomVertexReader(vdata, "drawFlag") drawReader.setRow(startRow-numVertices) #we cant draw quads directly so we use Tristrips if (startRow!=0) & (drawReader.getData1f()!=False): lines=GeomTristrips(Geom.UHStatic) half=int(numVertices*0.5) for i in range(numVertices): lines.addVertex(i+startRow) if i< half: lines.addVertex(i+startRow-half) else: lines.addVertex(i+startRow-half-numVertices) lines.addVertex(startRow) lines.addVertex(startRow-half) lines.closePrimitive() lines.decompose() circleGeom.addPrimitive(lines) circleGeomNode=GeomNode("Debug") circleGeomNode.addGeom(circleGeom) #I accidentally made the front-face face inwards. Make reverse makes the tree render properly and #should cause any surprises to any poor programmer that tries to use this code circleGeomNode.setAttrib(CullFaceAttrib.makeReverse(),1) global numPrimitives numPrimitives+=numVertices*2 nodePath.attachNewNode(circleGeomNode)