def __init__(self, name, format = GeomVertexFormat.getV3()): self.views = [] self.vertexBuffer = GeomVertexData(name + "-vdata", format, GeomEnums.UHDynamic) self.np = NodePath(name) self.np.node().setBounds(OmniBoundingVolume()) self.np.node().setFinal(1)
def _CreateOneSynapse(self, presynCell, synapsesType): presynCell.setPresynapticFocus() # highlight presynaptic cells form = GeomVertexFormat.getV3() vdata = GeomVertexData("SynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f(presynCell.getNode().getPos(self._node)) vertex.addData3f(0, 0, 0) prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("Synapse_" + str(synapsesType)) node.addGeom(geom) nodePath = self._node.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if presynCell.active: nodePath.setColor(COL_DISTAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_DISTAL_SYNAPSES_INACTIVE)
def makeRotationGeomNode(): vdata = GeomVertexData('rotHandleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') radius = 0.7 width = 0.08 res = 30 innerRad = radius - width for i in xrange(res): theta = i*(2*pi/res) v.addData3f(innerRad*sin(theta), innerRad*cos(theta), width/2.0) v.addData3f(innerRad*sin(theta), innerRad*cos(theta), -width/2.0) v.addData3f(radius*sin(theta), radius*cos(theta), width/2.0) v.addData3f(radius*sin(theta), radius*cos(theta), -width/2.0) circle = Geom(vdata) # Make prims for the faces of the torus faces = [GeomTristrips(Geom.UHStatic) for i in xrange(4)] for i in xrange(res): i = i*4 faces[0].addVertices(i + 1, i) faces[1].addVertices(i + 2, i + 1) faces[2].addVertices(i + 3, i + 2) faces[3].addVertices(i, i + 3) for i in xrange(4): faces[i].addVertices((i + 1) % 4, i) faces[i].closePrimitive() circle.addPrimitive(faces[i]) node = GeomNode('geomnode') node.addGeom(circle) return node
def _CreateOneSynapse(self, presynCell, synapsesType): form = GeomVertexFormat.getV3() vdata = GeomVertexData("SynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f(presynCell.getNode().getPos(self.__node)) vertex.addData3f(0, 0, 0) # vertex.addData3f(self.__node.getPos()) # printLog("inputObj:"+str(i)+"bits:"+str(y)) # printLog(inputObj[i].inputBits[y].getNode().getPos(self.__node)) prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("Synapse_" + str(synapsesType)) node.addGeom(geom) nodePath = self.__cellsNodePath.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if presynCell.active: nodePath.setColor(COL_PROXIMAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_PROXIMAL_SYNAPSES_INACTIVE)
def addMeshConvexRB(self,vertices, faces,ghost=False,**kw): #step 1) create GeomVertexData and add vertex information format=GeomVertexFormat.getV3() vdata=GeomVertexData("vertices", format, Geom.UHStatic) vertexWriter=GeomVertexWriter(vdata, "vertex") [vertexWriter.addData3f(v[0],v[1],v[2]) for v in vertices] #step 2) make primitives and assign vertices to them tris=GeomTriangles(Geom.UHStatic) [self.setGeomFaces(tris,face) for face in faces] #step 3) make a Geom object to hold the primitives geom=Geom(vdata) geom.addPrimitive(tris) #step 4) create the bullet mesh and node mesh = BulletTriangleMesh() mesh.addGeom(geom) shape = BulletConvexHullShape(mesh, dynamic=not ghost)# if ghost : inodenp = self.worldNP.attachNewNode(BulletGhostNode('Mesh')) else : inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh')) inodenp.node().addShape(shape) # inodenp.setPos(0, 0, 0.1) self.setRB(inodenp,**kw) inodenp.setCollideMask(BitMask32.allOn()) self.world.attachRigidBody(inodenp.node()) return inodenp
def __init__(self, whl_pos, whl_radius, car_h): GameObject.__init__(self) self.radius = whl_radius v_f = GeomVertexFormat.getV3() vdata = GeomVertexData('skid', v_f, Geom.UHDynamic) prim = GeomTriangles(Geom.UHStatic) self.vtx_cnt = 1 self.last_pos = whl_pos geom = Geom(vdata) geom.add_primitive(prim) self.node = GeomNode('gnode') self.node.add_geom(geom) nodepath = self.eng.gfx.root.attach_node(self.node) nodepath.set_transparency(True) nodepath.set_depth_offset(1) nodepath.node.set_two_sided(True) # for self-shadowing issues self.__set_material(nodepath) nodepath.p3dnode.set_bounds(OmniBoundingVolume()) self.add_vertices(whl_radius, car_h) self.add_vertices(whl_radius, car_h) def alpha(time, n_p): if not n_p.is_empty: n_p.node.set_shader_input('alpha', time) # this if seems necessary since, if there are skidmarks and you # exit from the race (e.g. back to the menu), then alpha is being # called from the interval manager even if the interval manager # correctly says that there are 0 intervals. self.remove_seq = Sequence( Wait(8), LerpFunc(alpha, 8, .5, 0, 'easeInOut', [nodepath]), Func(nodepath.remove_node)) self.remove_seq.start()
def makeRotationGeomNode(): vdata = GeomVertexData('rotHandleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') radius = 0.7 width = 0.08 res = 30 innerRad = radius - width for i in xrange(res): theta = i * (2 * pi / res) v.addData3f(innerRad * sin(theta), innerRad * cos(theta), width / 2.0) v.addData3f(innerRad * sin(theta), innerRad * cos(theta), -width / 2.0) v.addData3f(radius * sin(theta), radius * cos(theta), width / 2.0) v.addData3f(radius * sin(theta), radius * cos(theta), -width / 2.0) circle = Geom(vdata) # Make prims for the faces of the torus faces = [GeomTristrips(Geom.UHStatic) for i in xrange(4)] for i in xrange(res): i = i * 4 faces[0].addVertices(i + 1, i) faces[1].addVertices(i + 2, i + 1) faces[2].addVertices(i + 3, i + 2) faces[3].addVertices(i, i + 3) for i in xrange(4): faces[i].addVertices((i + 1) % 4, i) faces[i].closePrimitive() circle.addPrimitive(faces[i]) node = GeomNode('geomnode') node.addGeom(circle) return node
def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') radius = 1.0 top = LPoint3d(0, 0, radius * 1.25) north_pole = LPoint3d(0, 0, radius) south_pole = LPoint3d(0, 0, -radius) bottom = LPoint3d(0, 0, -radius * 1.25) self.vertexWriter.addData3f(*top) self.vertexWriter.addData3f(*north_pole) self.vertexWriter.addData3f(*south_pole) self.vertexWriter.addData3f(*bottom) self.lines = GeomLines(Geom.UHStatic) self.lines.addVertex(0) self.lines.addVertex(1) self.lines.addVertex(2) self.lines.addVertex(3) self.lines.closePrimitive() self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-axis') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.axis_thickness) self.instance.setColor(self.parent.get_orbit_color()) self.instance.setAntialias(AntialiasAttrib.MMultisample) self.instance.reparentTo(self.context.annotation)
def makeSprite(name, texture, scale, add = False): from panda3d.core import (GeomVertexFormat, GeomVertexData, GeomEnums, InternalName, GeomVertexWriter, GeomPoints, Geom, GeomNode, NodePath, TextureStage, TexGenAttrib, BoundingSphere) format = GeomVertexFormat.getV3() data = GeomVertexData(name + "_data", format, GeomEnums.UHStatic) writer = GeomVertexWriter(data, InternalName.getVertex()) writer.addData3f((0, 0, 0)) primitive = GeomPoints(GeomEnums.UHStatic) primitive.addVertex(0) primitive.closePrimitive() geom = Geom(data) geom.addPrimitive(primitive) geomNode = GeomNode(name) geomNode.addGeom(geom) np = NodePath(geomNode) np.setLightOff(1) np.setMaterialOff(1) np.setRenderModePerspective(True) ts = TextureStage('sprite') if add: ts.setMode(TextureStage.MAdd) np.setTexture(ts, texture) np.setTexGen(ts, TexGenAttrib.MPointSprite) np.setDepthWrite(False) np.setDepthOffset(1) np.setTransparency(True) np.node().setBounds(BoundingSphere((0, 0, 0), 1)) np.node().setFinal(True) np.flattenStrong() np.setScale(scale) return np
def __init__(self, wheel_pos, radius, heading): self.radius = radius v_f = GeomVertexFormat.getV3() self.vdata = GeomVertexData('skid', v_f, Geom.UHDynamic) self.vdata.setNumRows(1) self.vertex = GeomVertexWriter(self.vdata, 'vertex') self.prim = GeomTriangles(Geom.UHStatic) self.cnt = 1 self.last_pos = wheel_pos geom = Geom(self.vdata) geom.addPrimitive(self.prim) node = GeomNode('gnode') node.addGeom(geom) nodePath = render.attachNewNode(node) nodePath.setTransparency(True) nodePath.setDepthOffset(1) self.__set_material(nodePath) nodePath.node().setBounds(OmniBoundingVolume()) self.add_vertices(radius, heading) self.add_vertices(radius, heading) self.remove_seq = Sequence( Wait(8), LerpFunc(nodePath.setAlphaScale, 8, 1, 0, 'easeInOut'), Func(nodePath.remove_node)) self.remove_seq.start()
def Cube(size=1.0, geom_name="CubeMaker", gvd_name="Data", gvw_name="vertex"): from panda3d.core import ( Vec3, GeomVertexFormat, GeomVertexData, GeomVertexWriter, GeomTriangles, Geom, GeomNode, NodePath, GeomPoints, loadPrcFileData, ) format = GeomVertexFormat.getV3() data = GeomVertexData(gvd_name, format, Geom.UHStatic) vertices = GeomVertexWriter(data, gvw_name) size = float(size) / 2.0 vertices.addData3f(-size, -size, -size) vertices.addData3f(+size, -size, -size) vertices.addData3f(-size, +size, -size) vertices.addData3f(+size, +size, -size) vertices.addData3f(-size, -size, +size) vertices.addData3f(+size, -size, +size) vertices.addData3f(-size, +size, +size) vertices.addData3f(+size, +size, +size) triangles = GeomTriangles(Geom.UHStatic) def addQuad(v0, v1, v2, v3): triangles.addVertices(v0, v1, v2) triangles.addVertices(v0, v2, v3) triangles.closePrimitive() addQuad(4, 5, 7, 6) # Z+ addQuad(0, 2, 3, 1) # Z- addQuad(3, 7, 5, 1) # X+ addQuad(4, 6, 2, 0) # X- addQuad(2, 6, 7, 3) # Y+ addQuad(0, 1, 5, 4) # Y+ geom = Geom(data) geom.addPrimitive(triangles) node = GeomNode(geom_name) node.addGeom(geom) return NodePath(node)
def __init__(self, name='ConstrainedDelaunayTriangles', geomVertexDataObj=None, format=GeomVertexFormat.getV3(), usage=Geom.UHDynamic, onVertexCreationCallback=None, universalZ=0): if geomVertexDataObj is None: geomVertexDataObj = GeomVertexData(name, format, usage) self.vertexData = geomVertexDataObj # self.vertexRewriter = GeomVertexRewriter(self.vertexData, 'vertex') if onVertexCreationCallback is None: onVertexCreationCallback = lambda vdata: None self._onVertexCreationCallback = onVertexCreationCallback self.universalZ = universalZ
def makeGeomNode(): vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') length = 1.0 gapLen = 0.2 coneLen = 0.18 coneRad = 0.06 circRes = 10 v.addData3f(0, 0, -length/2.0) # back cone butt v.addData3f(0, 0, -length/2.0 + coneLen) # back cone point v.addData3f(0, 0, -gapLen/2.0) v.addData3f(0, 0, gapLen/2.0) v.addData3f(0, 0, length/2.0 - coneLen) # front cone butt v.addData3f(0, 0, length/2.0) # font cone point # Add vertices for the cone's circles. for z in [-length/2.0, length/2.0 - coneLen]: for i in xrange(circRes): theta = i*(2*pi/circRes) v.addData3f(coneRad*sin(theta), coneRad*cos(theta), z) lines = Geom(vdata) # Make prims for the two lines. for vertices in [(0, 2), (3, 5)]: line = GeomLines(Geom.UHStatic) line.addVertices(*vertices) line.closePrimitive() lines.addPrimitive(line) cones = Geom(vdata) # Make prims for the cones. for back, circ in [(0, 6), (4, 6 + circRes)]: point = back + 1 cone = GeomTriangles(Geom.UHStatic) for i in xrange(circRes): if i + 1 == circRes: cone.addVertices(back, circ, circ + i) cone.addVertices(point, circ + i, circ) else: cone.addVertices(back, circ + i + 1, circ + i) cone.addVertices(point, circ + i, circ + i + 1) cone.closePrimitive() cones.addPrimitive(cone) node = GeomNode('geomnode') node.addGeom(lines) node.addGeom(cones) return node
def makeGeomNode(): vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') length = 1.0 gapLen = 0.2 coneLen = 0.18 coneRad = 0.06 circRes = 10 v.addData3f(0, 0, -length / 2.0) # back cone butt v.addData3f(0, 0, -length / 2.0 + coneLen) # back cone point v.addData3f(0, 0, -gapLen / 2.0) v.addData3f(0, 0, gapLen / 2.0) v.addData3f(0, 0, length / 2.0 - coneLen) # front cone butt v.addData3f(0, 0, length / 2.0) # font cone point # Add vertices for the cone's circles. for z in [-length / 2.0, length / 2.0 - coneLen]: for i in xrange(circRes): theta = i * (2 * pi / circRes) v.addData3f(coneRad * sin(theta), coneRad * cos(theta), z) lines = Geom(vdata) # Make prims for the two lines. for vertices in [(0, 2), (3, 5)]: line = GeomLines(Geom.UHStatic) line.addVertices(*vertices) line.closePrimitive() lines.addPrimitive(line) cones = Geom(vdata) # Make prims for the cones. for back, circ in [(0, 6), (4, 6 + circRes)]: point = back + 1 cone = GeomTriangles(Geom.UHStatic) for i in xrange(circRes): if i + 1 == circRes: cone.addVertices(back, circ, circ + i) cone.addVertices(point, circ + i, circ) else: cone.addVertices(back, circ + i + 1, circ + i) cone.addVertices(point, circ + i, circ + i + 1) cone.closePrimitive() cones.addPrimitive(cone) node = GeomNode('geomnode') node.addGeom(lines) node.addGeom(cones) return node
def create_instance(self): if not self.orbit: return self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') delta = self.body.parent.get_local_position() for i in range(self.nbOfPoints): time = self.orbit.period / self.nbOfPoints * i pos = self.orbit.get_position_at(time) rot = self.orbit.get_rotation_at(time) pos = self.orbit.frame.get_local_position(rot.xform(pos)) - delta self.vertexWriter.addData3f(*pos) self.lines = GeomLines(Geom.UHStatic) for i in range(self.nbOfPoints - 1): self.lines.addVertex(i) self.lines.addVertex(i + 1) self.lines.closePrimitive() self.lines.addVertex(self.nbOfPoints - 1) self.lines.addVertex(0) self.lines.closePrimitive() self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-orbit') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.orbit_thickness) self.instance.setCollideMask(GeomNode.getDefaultCollideMask()) self.instance.node().setPythonTag('owner', self) self.instance.reparentTo(self.context.annotation_shader) if self.color is None: self.color = self.parent.get_orbit_color() self.instance.setColor(self.color * self.fade) self.instance.setAntialias(AntialiasAttrib.MMultisample) self.appearance = ModelAppearance(attribute_color=True) if settings.use_inv_scaling: vertex_control = LargeObjectVertexControl() else: vertex_control = None self.instance_ready = True self.shader = BasicShader(lighting_model=FlatLightingModel(), vertex_control=vertex_control) self.shader.apply(self, self.appearance) self.shader.update(self, self.appearance)
def makeNode(self, pointmap=(lambda x, y: (x, y, 0))): vt = tuple(self.vertices) t = Triangulator() fmt = GeomVertexFormat.getV3() vdata = GeomVertexData('name', fmt, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') for x, y in vt: t.addPolygonVertex(t.addVertex(x, y)) vertex.addData3f(pointmap(x, y)) t.triangulate() prim = GeomTriangles(Geom.UHStatic) for n in xrange(t.getNumTriangles()): prim.addVertices(t.getTriangleV0(n),t.getTriangleV1(n),t.getTriangleV2(n)) prim.closePrimitive() geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode('gnode') node.addGeom(geom) return node
def __init__(self): ShowBase.__init__(self) # 初期化 vs = open('vs_water.glsl', "r", encoding="UTF-8").read() fs = open('fs_water.glsl', "r", encoding="UTF-8").read() props = WindowProperties() props.setTitle('Fragment') Win_size = (1920, 1080) # ウィンドウサイズ props.setSize(Win_size) # ウィンドウのサイズを設定 props.setCursorHidden(True) # マウスカーソルを隠す base.win.requestProperties(props) self.AspectRaito = float(Win_size[0] / Win_size[1]) # アスペクト比を計算 self.accept("escape", sys.exit) # 終了 self.disableMouse() # マウスカーソルを非表示 self.setFrameRateMeter(True) # FPSを表示 camera.setPos(0, -2, 0) # カメラを配置 format = GeomVertexFormat.getV3() mesh = GeomVertexData('', format, Geom.UHDynamic) # メッシュを用意 vertex = GeomVertexWriter(mesh, 'vertex') # 頂点オブジェクト vertex.addData3(-1, 0, -1) # 頂点を追加 vertex.addData3(-1, 0, 1) vertex.addData3(1, 0, 1) vertex.addData3(1, 0, -1) tri = GeomTriangles(Geom.UHDynamic) # 面オブジェクト tri.addVertices(0, 2, 1) # 面のインデックスを追加 tri.addVertices(0, 3, 2) node = GeomNode('') geo = Geom(mesh) # ジオメトリオブジェクト geo.addPrimitive(tri) # プリミティブにする node.addGeom(geo) self.panel = render.attachNewNode(node) # レンダーオブジェクトとして追加 shader = Shader.make(Shader.SL_GLSL, vs, fs) self.panel.setShader(shader) resolution = self.win.getXSize(), self.win.getYSize() self.panel.setShaderInput('resolution', resolution) taskMgr.add(self.Loop, 'update') # メインループ
def Patch(size=1.0): (path, node) = empty_node('patch') form = GeomVertexFormat.getV3() vdata = GeomVertexData("vertices", form, Geom.UHStatic) vertexWriter = GeomVertexWriter(vdata, b"vertex") vertexWriter.addData3f(-size, -size, 0) vertexWriter.addData3f(size, -size, 0) vertexWriter.addData3f(size, size, 0) vertexWriter.addData3f(-size, size, 0) patches = GeomPatches(4, Geom.UHStatic) patches.addConsecutiveVertices(0, 4) #South, west, north, east patches.closePrimitive() gm = Geom(vdata) gm.addPrimitive(patches) node.addGeom(gm) return path
def CreateTestScene(self): form = GeomVertexFormat.getV3() vdata = GeomVertexData("myLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f(0, 0, 0) vertex.addData3f(60, 0, 50) prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("gnode") node.addGeom(geom) nodePath = self.render.attachNewNode(node)
def addLine(self, points): """ Adds a line to class GeomNode from a pair of points """ #Creates objects needed to draw a geometry on the HUD #The vertex data which will define the rendered geometry vertex_data = GeomVertexData("graph", GeomVertexFormat.getV3(), Geom.UHStatic) #The object that writes vertexes the vertex data writer = GeomVertexWriter(vertex_data, "vertex") for point in points: writer.add_data3f(point[0], 0, point[1]) #Defines that this geometry represents a polyline primitive = GeomLinestrips(Geom.UHStatic) #Tells geometry how many verticies will be added(?) primitive.add_consecutive_vertices(0, 2) primitive.close_primitive() geometry = Geom(vertex_data) geometry.add_primitive(primitive) #Draws a graph on the HUD self.geom_node.add_geom(geometry)
def makeClickableGeom(): vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') length = 1.0 cylRad = 0.10 circRes = 8 # Add vertices cylinder. for z in [length / 2.0, -length / 2.0]: for i in xrange(circRes): theta = i * (2 * pi / circRes) v.addData3f(cylRad * sin(theta), cylRad * cos(theta), z) geom = Geom(vdata) # Make polys for the circles CCW = 1 CW = 0 for i, wind in ((0, CCW), (circRes, CW)): circle = GeomTristrips(Geom.UHStatic) l = range(i, i + circRes) for i in xrange(1 - wind, (len(l) - wind) / 2): l.insert(2 * i + wind, l.pop()) for v in l: circle.addVertex(v) circle.closePrimitive() geom.addPrimitive(circle) # Make polys for the cylinder. cyl = GeomTristrips(Geom.UHStatic) for i in xrange(circRes): cyl.addVertex(i + circRes) cyl.addVertex(i) cyl.addVertex(circRes) cyl.addVertex(0) cyl.closePrimitive() geom.addPrimitive(cyl) node = GeomNode('geomnode') node.addGeom(geom) return node
def createPlane(width,height): format=GeomVertexFormat.getV3() vdata=GeomVertexData("vertices", format, Geom.UHStatic) vertexWriter=GeomVertexWriter(vdata, "vertex") vertexWriter.addData3f(0,0,0) vertexWriter.addData3f(width,0,0) vertexWriter.addData3f(width,height,0) vertexWriter.addData3f(0,height,0) #step 2) make primitives and assign vertices to them tris=GeomTriangles(Geom.UHStatic) #have to add vertices one by one since they are not in order tris.addVertex(0) tris.addVertex(1) tris.addVertex(3) #indicates that we have finished adding vertices for the first triangle. tris.closePrimitive() #since the coordinates are in order we can use this convenience function. tris.addConsecutiveVertices(1,3) #add vertex 1, 2 and 3 tris.closePrimitive() #step 3) make a Geom object to hold the primitives squareGeom=Geom(vdata) squareGeom.addPrimitive(tris) #now put squareGeom in a GeomNode. You can now position your geometry in the scene graph. squareGN=GeomNode("square") squareGN.addGeom(squareGeom) terrainNode = NodePath("terrNode") terrainNode.reparentTo(render) terrainNode.attachNewNode(squareGN) terrainNode.setX(-width/2) texGrass = loader.loadTexture("textures/envir-ground.jpg") terrainNode.setTexture(texGrass)
def makeClickableGeom(): vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') length = 1.0 cylRad = 0.10 circRes = 8 # Add vertices cylinder. for z in [length/2.0, -length/2.0]: for i in xrange(circRes): theta = i*(2*pi/circRes) v.addData3f(cylRad*sin(theta), cylRad*cos(theta), z) geom = Geom(vdata) # Make polys for the circles CCW = 1 CW = 0 for i, wind in ((0, CCW), (circRes, CW)): circle = GeomTristrips(Geom.UHStatic) l = range(i, i+circRes) for i in xrange(1-wind, (len(l)-wind)/2): l.insert(2*i+wind, l.pop()) for v in l: circle.addVertex(v) circle.closePrimitive() geom.addPrimitive(circle) # Make polys for the cylinder. cyl = GeomTristrips(Geom.UHStatic) for i in xrange(circRes): cyl.addVertex(i + circRes) cyl.addVertex(i) cyl.addVertex(circRes) cyl.addVertex(0) cyl.closePrimitive() geom.addPrimitive(cyl) node = GeomNode('geomnode') node.addGeom(geom) return node
def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') delta = self.body.parent.get_local_position() if self.orbit.is_periodic(): epoch = self.context.time.time_full - self.orbit.period / 2 step = self.orbit.period / (self.nbOfPoints - 1) else: #TODO: Properly calculate orbit start and end time epoch = self.orbit.get_time_of_perihelion() - self.orbit.period * 5.0 step = self.orbit.period * 10.0 / (self.nbOfPoints - 1) for i in range(self.nbOfPoints): time = epoch + step * i pos = self.orbit.get_position_at(time) - delta self.vertexWriter.addData3f(*pos) self.lines = GeomLines(Geom.UHStatic) for i in range(self.nbOfPoints-1): self.lines.addVertex(i) self.lines.addVertex(i+1) if self.orbit.is_periodic() and self.orbit.is_closed(): self.lines.addVertex(self.nbOfPoints-1) self.lines.addVertex(0) self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-orbit') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.orbit_thickness) self.instance.setCollideMask(GeomNode.getDefaultCollideMask()) self.instance.node().setPythonTag('owner', self) self.instance.reparentTo(self.context.annotation) if self.color is None: self.color = self.parent.get_orbit_color() self.instance.setColor(srgb_to_linear(self.color * self.fade)) self.instance_ready = True if self.shader is None: self.create_shader() self.shader.apply(self, self.appearance) self.shader.update(self, self.appearance)
def QuadPatch(x0, y0, x1, y1, x_inverted=False, y_inverted=False, xy_swap=False, offset=None): (x0, y0, x1, y1, dx, dy) = convert_xy(x0, y0, x1, y1, x_inverted, y_inverted, xy_swap) if offset is None: offset = 1.0 (path, node) = empty_node('patch') form = GeomVertexFormat.getV3() vdata = GeomVertexData("vertices", form, Geom.UHStatic) vertexWriter = GeomVertexWriter(vdata, b"vertex") x0 = 2.0 * x0 - 1.0 x1 = 2.0 * x1 - 1.0 y0 = 2.0 * y0 - 1.0 y1 = 2.0 * y1 - 1.0 vertexWriter.addData3f(x0, y0, offset) vertexWriter.addData3f(x1, y0, offset) vertexWriter.addData3f(x1, y1, offset) vertexWriter.addData3f(x0, y1, offset) patches = GeomPatches(4, Geom.UHStatic) patches.addConsecutiveVertices(0, 4) #South, west, north, east patches.closePrimitive() gm = Geom(vdata) gm.addPrimitive(patches) node.addGeom(gm) return path
def __init__(self, vertexName='ConstrainedDelaunayTriangles', vertexFormat=GeomVertexFormat.getV3(), usage = Geom.UHDynamic, onVertexCreationCallback = None, universalZ = 0.0): self._vertexData = GeomVertexData(vertexName, vertexFormat, Geom.UHDynamic) self._geomTriangles = GeomTriangles(usage) self._geomTrianglesHoles = GeomTriangles(usage) self._vertexRewriter = GeomVertexRewriter(self._vertexData, 'vertex') # user cannot have control of a writer if onVertexCreationCallback is None: onVertexCreationCallback = lambda x, y, z: None # something to call without checking existence later self._vertexCallback = onVertexCreationCallback self._universalZ = universalZ self.__holes = [[]] self.__polygon = [] inf = float('inf') negInf = float('-inf') self.bounds = { 'minX': inf, 'maxX': negInf, 'minY': inf, 'maxY': negInf, } self.lastStaticVertexIndex = -1
def line (self, start, end): # since we're doing line segments, just vertices in our geom format = GeomVertexFormat.getV3() # build our data structure and get a handle to the vertex column vdata = GeomVertexData ('', format, Geom.UHStatic) vertices = GeomVertexWriter (vdata, 'vertex') # build a linestrip vertex buffer lines = GeomLinestrips (Geom.UHStatic) vertices.addData3f (start[0], start[1], start[2]) vertices.addData3f (end[0], end[1], end[2]) lines.addVertices (0, 1) lines.closePrimitive() geom = Geom (vdata) geom.addPrimitive (lines) # Add our primitive to the geomnode #self.gnode.addGeom (geom) return geom
def generate(self): format = GeomVertexFormat.getV3() data = GeomVertexData("Data", format, Geom.UHStatic) vertices = GeomVertexWriter(data, "vertex") size = self.size vertices.addData3f(-size, -size, -size) vertices.addData3f(+size, -size, -size) vertices.addData3f(-size, +size, -size) vertices.addData3f(+size, +size, -size) vertices.addData3f(-size, -size, +size) vertices.addData3f(+size, -size, +size) vertices.addData3f(-size, +size, +size) vertices.addData3f(+size, +size, +size) triangles = GeomTriangles(Geom.UHStatic) def addQuad(v0, v1, v2, v3): triangles.addVertices(v0, v1, v2) triangles.addVertices(v0, v2, v3) triangles.closePrimitive() addQuad(4, 5, 7, 6) # Z+ addQuad(0, 2, 3, 1) # Z- addQuad(3, 7, 5, 1) # X+ addQuad(4, 6, 2, 0) # X- addQuad(2, 6, 7, 3) # Y+ addQuad(0, 1, 5, 4) # Y+ geom = Geom(data) geom.addPrimitive(triangles) node = GeomNode("CubeMaker") node.addGeom(geom) cube = NodePath(node) cube.setColor(0.0, 1.0, 1.0) return cube
def line(self): # Create and populate the Moon orbit model using Vertices and Lines self.planetOrbitVertexData = GeomVertexData(self.description+'OrbitVertexData', GeomVertexFormat.getV3(), Geom.UHDynamic) self.planetOrbitVertexWriter = GeomVertexWriter(self.planetOrbitVertexData, 'vertex') self.planetOrbitNumberPoints = 360 for i in range(self.planetOrbitNumberPoints): angleDegrees = i * 360 / self.planetOrbitNumberPoints angleRadians = angleDegrees * (pi / 180.0) x = -self.distance * sin(angleRadians) y = self.distance * cos(angleRadians) self.planetOrbitVertexWriter.addData3f(x, y, 0.0) self.planetOrbitLines = GeomLines(Geom.UHStatic) for i in range(self.planetOrbitNumberPoints-1): self.planetOrbitLines.addVertex(i) self.planetOrbitLines.addVertex(i+1) self.planetOrbitLines.closePrimitive() self.planetOrbitLines.addVertex(self.planetOrbitNumberPoints-1) self.planetOrbitLines.addVertex(0) self.planetOrbitLines.closePrimitive() self.planetOrbitGeom = Geom(self.planetOrbitVertexData) self.planetOrbitGeom.addPrimitive(self.planetOrbitLines) self.planetOrbitNode = GeomNode(self.description+'OrbitNode') self.planetOrbitNode.addGeom(self.planetOrbitGeom) self.planetOrbitNnodePath = render.attachNewNode(self.planetOrbitNode) self.planetOrbitNnodePath.reparentTo(self.worldOrigin) return self.planetOrbitVertexWriter
def CreateProximalSynapses(self, inputNames, inputObj, permanences, thresholdConnected, createOnlyActive=False): self.DestroyProximalSynapses() printLog("Creating proximal permanences", verbosityMedium) printLog("To inputObj called:" + str(inputNames), verbosityMedium) printLog("permanences count:" + str(len(permanences)), verbosityMedium) printLog("active:" + str(sum([i for i in permanences])), verbosityHigh) # inputObj are divided into separate items in list - [input1,input2,input3] # permanences are one united array [1,0,0,1,0,1,0...] # length is the same # synapses can be connected to one input or to several inputObj # if to more than one - split synapses array synapsesDiv = [] offset = 0 for inputName in inputNames: synapsesDiv.append(permanences[offset : offset + inputObj[inputName].count]) offset += inputObj[inputName].count for i in range(len(synapsesDiv)): # for each input object inputObj[inputNames[i]].resetProximalFocus() # clear color highlight for y in range( len(synapsesDiv[i]) ): # go through every synapse and check if its connected (we are comparing permanences) if synapsesDiv[i][y] >= thresholdConnected: if createOnlyActive and not inputObj[inputNames[i]].inputBits[y].active:# we want to show only active synapses continue form = GeomVertexFormat.getV3() vdata = GeomVertexData("ProximalSynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f( inputObj[inputNames[i]] .inputBits[y] .getNode() .getPos(self.__node) ) vertex.addData3f(0, 0, 0) # vertex.addData3f(self.__node.getPos()) # printLog("inputObj:"+str(i)+"bits:"+str(y)) # printLog(inputObj[i].inputBits[y].getNode().getPos(self.__node)) # highlight inputObj[inputNames[i]].inputBits[ y ].setProximalFocus() # highlight connected bits prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("ProximalSynapse") node.addGeom(geom) nodePath = self.__cellsNodePath.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if inputObj[inputNames[i]].inputBits[y].active: nodePath.setColor(COL_PROXIMAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_PROXIMAL_SYNAPSES_INACTIVE)
def generate( self ): # call this after setting some of the variables to update it if not self.vertices: return if hasattr(self, 'geomNode'): self.geomNode.removeAllGeoms() static_mode = Geom.UHStatic if self.static else Geom.UHDynamic formats = { (0, 0, 0): GeomVertexFormat.getV3(), (1, 0, 0): GeomVertexFormat.getV3c4(), (0, 1, 0): GeomVertexFormat.getV3t2(), (0, 0, 1): GeomVertexFormat.getV3n3(), (1, 0, 1): GeomVertexFormat.getV3n3c4(), (1, 1, 0): GeomVertexFormat.getV3c4t2(), (0, 1, 1): GeomVertexFormat.getV3n3t2(), (1, 1, 1): GeomVertexFormat.getV3n3c4t2(), } vertex_format = formats[(bool(self.colors), bool(self.uvs), bool(self.normals))] vdata = GeomVertexData('name', vertex_format, static_mode) vdata.setNumRows(len(self.vertices)) # for speed vertexwriter = GeomVertexWriter(vdata, 'vertex') for v in self.vertices: vertexwriter.addData3f((v[0], v[2], v[1])) # swap y and z if self.colors: colorwriter = GeomVertexWriter(vdata, 'color') for c in self.colors: colorwriter.addData4f(c) if self.uvs: uvwriter = GeomVertexWriter(vdata, 'texcoord') for uv in self.uvs: uvwriter.addData2f(uv[0], uv[1]) if self.normals != None: normalwriter = GeomVertexWriter(vdata, 'normal') for norm in self.normals: normalwriter.addData3f((norm[0], norm[2], norm[1])) modes = { 'triangle': GeomTriangles(static_mode), 'tristrip': GeomTristrips(static_mode), 'ngon': GeomTrifans(static_mode), 'line': GeomLines(static_mode), 'lines': GeomLinestrips(static_mode), 'point': GeomPoints(static_mode), } if self.mode == 'line' and len(self.vertices) % 2 > 0: if len(self.vertices) == 1: self.mode = point print( 'warning: number of vertices must be even for line mode, ignoring last vert' ) self.vertices = self.vertices[:len(self.vertices) - 1] prim = modes[self.mode] if self._triangles: if isinstance(self._triangles[0], int): for t in self._triangles: prim.addVertex(t) elif len( self._triangles[0] ) >= 3: # if tris are tuples like this: ((0,1,2), (1,2,3)) for t in self._triangles: if len(t) == 3: for e in t: prim.addVertex(e) elif len(t) == 4: # turn quad into tris prim.addVertex(t[0]) prim.addVertex(t[1]) prim.addVertex(t[2]) prim.addVertex(t[2]) prim.addVertex(t[3]) prim.addVertex(t[0]) else: prim.addConsecutiveVertices(0, len(self.vertices)) prim.close_primitive() geom = Geom(vdata) geom.addPrimitive(prim) self.geomNode = GeomNode('mesh') self.geomNode.addGeom(geom) self.attachNewNode(self.geomNode) # print('finished') self.recipe = f'''Mesh(
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 CreateProximalSynapses(self, inputObjects, inputs, synapses): for child in self.__cellsNodePath.getChildren(): if child.getName() == "ProximalSynapseLine": child.removeNode() printLog("Creating proximal synapses", verbosityMedium) printLog("To inputs called:" + str(inputObjects), verbosityMedium) printLog("Synapses count:" + str(len(synapses)), verbosityMedium) printLog("active:" + str(sum([i for i in synapses])), verbosityHigh) # inputs are divided into separate items in list - [input1,input2,input3] # synapses are one united array [1,0,0,1,0,1,0...] # length is the same # synapses can be connected to one input or to several inputs # if to more than one - split synapses array synapsesDiv = [] offset = 0 for inputObj in inputObjects: synapsesDiv.append(synapses[offset:offset + inputs[inputObj].count]) offset += inputs[inputObj].count for i in range(len(synapsesDiv)): # for each input object inputs[ inputObjects[i]].resetProximalFocus() # clear color highlight for y in range(len(synapsesDiv[i]) ): # go through every synapse and check activity if synapsesDiv[i][y] == 1: form = GeomVertexFormat.getV3() vdata = GeomVertexData("ProximalSynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f( inputs[inputObjects[i]].inputBits[y].getNode().getPos( self.__node)) vertex.addData3f(0, 0, 0) # vertex.addData3f(self.__node.getPos()) # printLog("Inputs:"+str(i)+"bits:"+str(y)) # printLog(inputs[i].inputBits[y].getNode().getPos(self.__node)) # highlight inputs[inputObjects[i]].inputBits[y].setProximalFocus( ) # highlight connected bits prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("ProximalSynapse") node.addGeom(geom) nodePath = self.__cellsNodePath.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if inputs[inputObjects[i]].inputBits[y].active: nodePath.setColor(COL_PROXIMAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_PROXIMAL_SYNAPSES_INACTIVE)
class Mesh(NodePath): _formats = { (0, 0, 0): GeomVertexFormat.getV3(), (1, 0, 0): GeomVertexFormat.getV3c4(), (0, 1, 0): GeomVertexFormat.getV3t2(), (0, 0, 1): GeomVertexFormat.getV3n3(), (1, 0, 1): GeomVertexFormat.getV3n3c4(), (1, 1, 0): GeomVertexFormat.getV3c4t2(), (0, 1, 1): GeomVertexFormat.getV3n3t2(), (1, 1, 1): GeomVertexFormat.getV3n3c4t2(), } _modes = { 'triangle': GeomTriangles, 'tristrip': GeomTristrips, 'ngon': GeomTrifans, 'line': GeomLinestrips, 'point': GeomPoints, } def __init__(self, vertices=None, triangles=None, colors=None, uvs=None, normals=None, static=True, mode='triangle', thickness=1): super().__init__('mesh') self.vertices = vertices self.triangles = triangles self.colors = colors self.uvs = uvs self.normals = normals self.static = static self.mode = mode self.thickness = thickness for var in (('vertices', vertices), ('triangles', triangles), ('colors', colors), ('uvs', uvs), ('normals', normals)): name, value = var if value is None: setattr(self, name, list()) if self.vertices: self.generate() def generate( self ): # call this after setting some of the variables to update it if hasattr(self, 'geomNode'): self.geomNode.removeAllGeoms() static_mode = Geom.UHStatic if self.static else Geom.UHDynamic vertex_format = Mesh._formats[(bool(self.colors), bool(self.uvs), bool(self.normals))] vdata = GeomVertexData('name', vertex_format, static_mode) vdata.setNumRows(len(self.vertices)) # for speed if not hasattr(self, 'geomNode'): self.geomNode = GeomNode('mesh') self.attachNewNode(self.geomNode) vertexwriter = GeomVertexWriter(vdata, 'vertex') for v in self.vertices: vertexwriter.addData3f(*v) if self.colors: colorwriter = GeomVertexWriter(vdata, 'color') for c in self.colors: colorwriter.addData4f(c) if self.uvs: uvwriter = GeomVertexWriter(vdata, 'texcoord') for uv in self.uvs: uvwriter.addData2f(uv[0], uv[1]) if self.normals != None: normalwriter = GeomVertexWriter(vdata, 'normal') for norm in self.normals: normalwriter.addData3f(*norm) if self.mode != 'line' or not self._triangles: self.indices = list() if self._triangles: if isinstance(self._triangles[0], int): for t in self._triangles: self.indices.append(t) elif len( self._triangles[0] ) >= 3: # if tris are tuples like this: ((0,1,2), (1,2,3)) for t in self._triangles: if len(t) == 3: self.indices.extend(t) elif len(t) == 4: # turn quad into tris self.indices.extend( [t[i] for i in (0, 1, 2, 2, 3, 0)]) else: self.indices = [i for i in range(len(self.vertices))] prim = Mesh._modes[self.mode](static_mode) self.generated_vertices = [self.vertices[i] for i in self.indices] for v in self.indices: prim.addVertex(v) prim.close_primitive() geom = Geom(vdata) geom.addPrimitive(prim) self.geomNode.addGeom(geom) else: # line with segments defined in triangles for line in self._triangles: prim = Mesh._modes[self.mode](static_mode) for e in line: prim.addVertex(e) prim.close_primitive() geom = Geom(vdata) geom.addPrimitive(prim) self.geomNode.addGeom(geom) if self.mode == 'point': self.setTexGen(TextureStage.getDefault(), TexGenAttrib.MPointSprite) # self.set_render_mode_perspective(True) # print('finished') @property def recipe(self): if hasattr(self, '_recipe'): return self._recipe return dedent(f''' Mesh( vertices={[tuple(e) for e in self.vertices]}, triangles={self._triangles}, colors={[tuple(e) for e in self.colors]}, uvs={self.uvs}, normals={[tuple(e) for e in self.normals]}, static={self.static}, mode="{self.mode}", thickness={self.thickness} ) ''') @recipe.setter def recipe(self, value): self._recipe = value def __add__(self, other): self.vertices += other.vertices self.triangles += other.triangles if other.colors: self.colors += other.colors else: self.colors += (color.white, ) * len(other.vertices) self.normals += other.normals self.uvs += other.uvs def __deepcopy__(self, memo): m = Mesh(self.vertices, self.triangles, self.colors, self.uvs, self.normals, self.static, self.mode, self.thickness) m.name = self.name return m @property def thickness(self): return self.getRenderModeThickness() @thickness.setter def thickness(self, value): self.setRenderModeThickness(value) @property def triangles(self): if self._triangles == None: self._triangles = [(i, i + 1, i + 2) for i in range(0, len(self.vertices), 3)] return self._triangles @triangles.setter def triangles(self, value): self._triangles = value def generate_normals(self, smooth=True): self.normals = list( generate_normals(self.vertices, self.triangles, smooth)) self.generate() return self.normals def colorize(self, left=color.white, right=color.blue, down=color.red, up=color.green, back=color.white, forward=color.white, smooth=True, world_space=True): colorize(self, left, right, down, up, back, forward, smooth, world_space) def project_uvs(self, aspect_ratio=1, direction='forward'): project_uvs(self, aspect_ratio) def clear(self, regenerate=True): self.vertices, self.triangles, self.colors, self.uvs, self.normals = list( ), list(), list(), list(), list() if regenerate: self.generate() def save(self, name='', path=application.compressed_models_folder): if not application.compressed_models_folder.exists(): application.compressed_models_folder.mkdir() if not name and hasattr(self, 'path'): name = self.path.stem if not '.' in name: name += '.ursinamesh' if name.endswith('ursinamesh'): with open(path / name, 'w') as f: # recipe = self.recipe.replace('LVector3f', '') f.write(self.recipe) print('saved .ursinamesh to:', path / name) elif name.endswith('.obj'): from ursina.mesh_importer import ursina_mesh_to_obj ursina_mesh_to_obj(self, name, path) elif name.endswith('.bam'): success = self.writeBamFile(path / name) print('saved .bam to:', path / name)
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
class Mesh(NodePath): _formats = { (0, 0, 0): GeomVertexFormat.getV3(), (1, 0, 0): GeomVertexFormat.getV3c4(), (0, 1, 0): GeomVertexFormat.getV3t2(), (0, 0, 1): GeomVertexFormat.getV3n3(), (1, 0, 1): GeomVertexFormat.getV3n3c4(), (1, 1, 0): GeomVertexFormat.getV3c4t2(), (0, 1, 1): GeomVertexFormat.getV3n3t2(), (1, 1, 1): GeomVertexFormat.getV3n3c4t2(), } _modes = { 'triangle': GeomTriangles, 'tristrip': GeomTristrips, 'ngon': GeomTrifans, 'line': GeomLinestrips, 'point': GeomPoints, } def __init__(self, vertices=None, triangles=None, colors=None, uvs=None, normals=None, static=True, mode='triangle', thickness=1): super().__init__('mesh') self.vertices = vertices self.triangles = triangles self.colors = colors self.uvs = uvs self.normals = normals self.static = static self.mode = mode self.thickness = thickness for var in (('vertices', vertices), ('triangles', triangles), ('colors', colors), ('uvs', uvs), ('normals', normals)): name, value = var if value is None: setattr(self, name, list()) if self.vertices: self.vertices = [tuple(v) for v in self.vertices] self.generate() def generate( self ): # call this after setting some of the variables to update it if hasattr(self, 'geomNode'): self.geomNode.removeAllGeoms() static_mode = Geom.UHStatic if self.static else Geom.UHDynamic vertex_format = Mesh._formats[(bool(self.colors), bool(self.uvs), bool(self.normals))] vdata = GeomVertexData('name', vertex_format, static_mode) vdata.setNumRows(len(self.vertices)) # for speed vertexwriter = GeomVertexWriter(vdata, 'vertex') for v in self.vertices: vertexwriter.addData3f((v[0], v[2], v[1])) # swap y and z if self.colors: colorwriter = GeomVertexWriter(vdata, 'color') for c in self.colors: colorwriter.addData4f(c) if self.uvs: uvwriter = GeomVertexWriter(vdata, 'texcoord') for uv in self.uvs: uvwriter.addData2f(uv[0], uv[1]) if self.normals != None: normalwriter = GeomVertexWriter(vdata, 'normal') for norm in self.normals: normalwriter.addData3f((norm[0], norm[2], norm[1])) if self.mode != 'line' or not self._triangles: prim = Mesh._modes[self.mode](static_mode) if self._triangles: if isinstance(self._triangles[0], int): for t in self._triangles: prim.addVertex(t) elif len( self._triangles[0] ) >= 3: # if tris are tuples like this: ((0,1,2), (1,2,3)) for t in self._triangles: if len(t) == 3: for e in t: prim.addVertex(e) elif len(t) == 4: # turn quad into tris prim.addVertex(t[0]) prim.addVertex(t[1]) prim.addVertex(t[2]) prim.addVertex(t[2]) prim.addVertex(t[3]) prim.addVertex(t[0]) else: prim.addConsecutiveVertices(0, len(self.vertices)) prim.close_primitive() geom = Geom(vdata) geom.addPrimitive(prim) else: # line with segments defined in triangles for line in self._triangles: prim = Mesh._modes[self.mode](static_mode) for e in line: prim.addVertex(e) prim.close_primitive() geom = Geom(vdata) geom.addPrimitive(prim) self.geomNode = GeomNode('mesh') self.geomNode.addGeom(geom) self.attachNewNode(self.geomNode) # if self.normals: # self.normals = [tuple(e) for e in self.normals] self.recipe = dedent(f''' Mesh( vertices={[tuple(e) for e in self.vertices]}, triangles={self._triangles}, colors={[tuple(e) for e in self.colors]}, uvs={self.uvs}, normals={[tuple(e) for e in self.normals]}, static={self.static}, mode="{self.mode}", thickness={self.thickness} ) ''') # print('finished') def __add__(self, other): self.vertices += other.vertices self.triangles += other.triangles if other.colors: self.colors += other.colors else: self.colors += (color.white, ) * len(other.vertices) self.normals += other.normals self.uvs += other.uvs @property def thickness(self): return self.getRenderModeThickness() @thickness.setter def thickness(self, value): self.setRenderModeThickness(value) @property def triangles(self): if self._triangles == None: self._triangles = [(i, i + 1, i + 2) for i in range(0, len(self.vertices), 3)] return self._triangles @triangles.setter def triangles(self, value): self._triangles = value def generate_normals(self, smooth=True): self.normals = list( generate_normals(self.vertices, self.triangles, smooth)) self.generate() return self.normals def colorize(self, left=color.white, right=color.blue, down=color.red, up=color.green, back=color.white, forward=color.white, smooth=True, world_space=True): colorize(self, left, right, down, up, back, forward, smooth, world_space) def project_uvs(self, aspect_ratio=1, direction='forward'): project_uvs(self, aspect_ratio) def clear(self, regenerate=True): self.vertices, self.triangles, self.colors, self.uvs, self.normals = list( ), list(), list(), list(), list() if regenerate: self.generate() def save(self, name, path=application.asset_folder, filetype='ursinamesh'): if filetype == 'ursinamesh': if not '.' in name: name += '.ursinamesh' with open(path / name, 'w') as f: recipe = self.recipe.replace('LVector3f', '') f.write(recipe) elif filetype == 'obj': from ursina.mesh_importer import ursina_mesh_to_obj ursina_mesh_to_obj(self, name, path)
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