def pandageom_from_vfnf(vertices, face_normals, triangles, name='auto'): """ :param vertices: nx3 nparray, each row is vertex :param face_normals: nx3 nparray, each row is the normal of a face :param triangles: nx3 nparray, each row is three idx to the vertices :param name: :return: a geom model that is ready to be used to define a nodepath author: weiwei date: 20160613, 20210109 """ # expand vertices to let each triangle refer to a different vert+normal # vertices and normals vertformat = GeomVertexFormat.getV3n3() vertexdata = GeomVertexData(name, vertformat, Geom.UHStatic) vertids = triangles.flatten() multiplied_verticies = np.empty((len(vertids), 3), dtype=np.float32) multiplied_verticies[:] = vertices[vertids] vertex_normals = np.repeat(face_normals.astype(np.float32), repeats=3, axis=0) npstr = np.hstack((multiplied_verticies, vertex_normals)).tobytes() vertexdata.modifyArrayHandle(0).setData(npstr) # triangles primitive = GeomTriangles(Geom.UHStatic) primitive.setIndexType(GeomEnums.NTUint32) multiplied_triangles = np.arange(len(vertids), dtype=np.uint32).reshape(-1, 3) primitive.modifyVertices(-1).modifyHandle().setData( multiplied_triangles.tobytes()) # make geom geom = Geom(vertexdata) geom.addPrimitive(primitive) return geom
def regesterGeomRequirements(self, LOD, collection): n = NodePath('tmp') if self.barkTexture is not None: n.setTexture(self.barkTexture) n.setShaderInput('diffTex', self.barkTexture) format = GeomVertexFormat.getV3n3t2() else: format = GeomVertexFormat.getV3n3() n.setColor(.4, .3, .3, 1) #n.setShader(customLoader.makeShader(n)) trunkRequirements = meshManager.GeomRequirements( geomVertexFormat=format, renderState=n.getState()) n = NodePath('tmp') if self.leafTexture is not None: #n.setTag("alpha","") n.setShaderInput("alpha", 0, 0, 0) # marker we need cutout alpha n.setTexture(self.leafTexture) n.setShaderInput('diffTex', self.leafTexture) format = GeomVertexFormat.getV3n3t2() else: format = GeomVertexFormat.getV3n3c4() #n.setShader(customLoader.makeShader(n,debugCodePrefix="tree",debugGraphPrefix="tree")) leafRequirements = meshManager.GeomRequirements( geomVertexFormat=format, renderState=n.getState()) self.trunkDataIndex[LOD] = collection.add(trunkRequirements) self.leafDataIndex[LOD] = collection.add(leafRequirements)
def regesterGeomRequirements(self, LOD, collection): n = NodePath("tmp") if self.barkTexture is not None: n.setTexture(self.barkTexture) n.setShaderInput("diffTex", self.barkTexture) format = GeomVertexFormat.getV3n3t2() else: format = GeomVertexFormat.getV3n3() n.setColor(0.4, 0.3, 0.3, 1) # n.setShader(customLoader.makeShader(n)) trunkRequirements = meshManager.GeomRequirements(geomVertexFormat=format, renderState=n.getState()) n = NodePath("tmp") if self.leafTexture is not None: # n.setTag("alpha","") n.setShaderInput("alpha", 0, 0, 0) # marker we need cutout alpha n.setTexture(self.leafTexture) n.setShaderInput("diffTex", self.leafTexture) format = GeomVertexFormat.getV3n3t2() else: format = GeomVertexFormat.getV3n3c4() # n.setShader(customLoader.makeShader(n,debugCodePrefix="tree",debugGraphPrefix="tree")) leafRequirements = meshManager.GeomRequirements(geomVertexFormat=format, renderState=n.getState()) self.trunkDataIndex[LOD] = collection.add(trunkRequirements) self.leafDataIndex[LOD] = collection.add(leafRequirements)
def __init__(self, name: str = 'cube_mesh', wireframe_thickness: float = 5) -> None: self.name = name self.__vertex_data_format = GeomVertexFormat.getV3n3() self.__vertex_data = GeomVertexData(name, self.__vertex_data_format, Geom.UHStatic) self.geom = Geom(self.__vertex_data) self.__triangles = GeomTriangles(Geom.UHStatic) self.__triangle_data = self.__triangles.modifyVertices() self.__vertex = GeomVertexWriter(self.__vertex_data, 'vertex') self.__normal = GeomVertexWriter(self.__vertex_data, 'normal') self.__face_count = 0 def add_face(face: Face) -> None: self.__make_face(face) self.__make_face(Face.LEFT) self.__make_face(Face.RIGHT) self.__make_face(Face.BACK) self.__make_face(Face.FRONT) self.__make_face(Face.BOTTOM) self.__make_face(Face.TOP) self.__triangles.close_primitive() self.geom.add_primitive(self.__triangles) def is_connected(x, y, z, x1, y1, z1): return (abs(x - x1) == 1 and abs(y - y1) != 1 and abs(z - z1) != 1) or \ (abs(x - x1) != 1 and abs(y - y1) == 1 and abs(z - z1) != 1) or \ (abs(x - x1) != 1 and abs(y - y1) != 1 and abs(z - z1) == 1) ls = LineSegs() ls.set_thickness(wireframe_thickness) arr_x = [0, 0, 0, 0, 1, 1, 1, 1] arr_y = [0, 0, 1, 1, 1, 1, 0, 0] arr_z = [0, -1, -1, 0, 0, -1, -1, 0] for pos1 in range(len(arr_x) - 1): for pos2 in range(pos1, len(arr_x)): x = arr_x[pos1] y = arr_y[pos1] z = arr_z[pos1] x1 = arr_x[pos2] y1 = arr_y[pos2] z1 = arr_z[pos2] if (is_connected(x, y, z, x1, y1, z1)): ls.move_to(x, y, z) ls.draw_to(x1, y1, z1) self.__wireframe_node = ls.create()
def regesterGeomRequirements(self, LOD, collection): n = NodePath('tmp') if self.leafTexture is not None: n.setTexture(self.leafTexture) n.setShaderInput('diffTex', self.leafTexture) format = GeomVertexFormat.getV3n3t2() else: n.setColor(.1, .3, .1, 1) format = GeomVertexFormat.getV3n3() #n.setShader(customLoader.makeShader(n,debugCodePrefix="fern",debugGraphPrefix="fern")) leafRequirements = meshManager.GeomRequirements( geomVertexFormat=format, renderState=n.getState(), ) self.leafDataIndex[LOD] = collection.add(leafRequirements)
def regesterGeomRequirements(self,LOD,collection): n=NodePath('tmp') if self.leafTexture is not None: n.setTexture(self.leafTexture) n.setShaderInput('diffTex',self.leafTexture) format=GeomVertexFormat.getV3n3t2() else: n.setColor(.1,.3,.1,1) format=GeomVertexFormat.getV3n3() #n.setShader(customLoader.makeShader(n,debugCodePrefix="fern",debugGraphPrefix="fern")) leafRequirements=meshManager.GeomRequirements( geomVertexFormat=format, renderState=n.getState(), ) self.leafDataIndex[LOD]=collection.add(leafRequirements)
def pandageom_from_vvnf(vertices, vertex_normals, triangles, name=''): """ use environment.collisionmodel instead, vvnf = vertices, vertex normals, faces pack the vertices, vertice normals and triangles into a panda3d geom :param vertices: nx3 nparray, each row is a vertex :param vertex_normals: nx3 nparray, each row is the normal of a vertex :param triangles: nx3 nparray, each row is three idx to the vertices :param name: :return: author: weiwei date: 20171219, 20210901 """ vertformat = GeomVertexFormat.getV3n3() vertexdata = GeomVertexData(name, vertformat, Geom.UHStatic) vertexdata.modifyArrayHandle(0).setData( np.hstack((vertices, vertex_normals)).astype(np.float32).tobytes()) primitive = GeomTriangles(Geom.UHStatic) primitive.setIndexType(GeomEnums.NTUint32) primitive.modifyVertices(-1).modifyHandle().setData( triangles.astype(np.uint32).tobytes()) # make geom geom = Geom(vertexdata) geom.addPrimitive(primitive) return geom
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(
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)
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 addTriMeshSB(self,vertices, faces,normals = None,ghost=False,**kw): #step 1) create GeomVertexData and add vertex information # Soft body world information info = self.world.getWorldInfo() info.setAirDensity(0.0) info.setWaterDensity(0) info.setWaterOffset(0) info.setWaterNormal(Vec3(0, 0, 0)) format=GeomVertexFormat.getV3n3() #getV3()#http://www.panda3d.org/manual/index.php/Pre-defined_vertex_formats # vdata = GeomVertexData('name', format, Geom.UHStatic) vdata=GeomVertexData("Mesh", format, Geom.UHStatic) vertexWriter=GeomVertexWriter(vdata, "vertex") [vertexWriter.addData3f(v[0],v[1],v[2]) for v in vertices] if normals is not None : normalWriter = GeomVertexWriter(vdata, 'normal') [normalWriter.addData3f(n[0],n[1],n[2]) for n in normals] else : print "we need normals to bind geom to SoftBody" return None #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) vdata = geom.getVertexData() # print (vdata,vdata.hasColumn(InternalName.getVertex())) geomNode = GeomNode('') geomNode.addGeom(geom) #step 4) create the bullet softbody and node bodyNode = BulletSoftBodyNode.makeTriMesh(info, geom) # bodyNode.linkGeom(geomNode.modifyGeom(0)) bodyNode.setName('Tri') bodyNode.linkGeom(geom) bodyNode.generateBendingConstraints(1)#??? #bodyNode.getMaterial(0).setLinearStiffness(0.8) bodyNode.getCfg().setPositionsSolverIterations(4) # bodyNode.getCfg().setCollisionFlag(BulletSoftBodyConfig.CFVertexFaceSoftSoft, True) bodyNode.getCfg().setDynamicFrictionCoefficient(1) bodyNode.getCfg().setDampingCoefficient(0.001) bodyNode.getCfg().setPressureCoefficient(15000*10.0) bodyNode.getCfg().setPoseMatchingCoefficient(0.2) bodyNode.setPose(True, True) # bodyNode.randomizeConstraints() bodyNode.setTotalMass(50000*10, True) bodyNP = self.worldNP.attachNewNode(bodyNode) # fmt = GeomVertexFormat.getV3n3t2() # geom = BulletHelper.makeGeomFromFaces(bodyNode, fmt,True) # bodyNode.linkGeom(geomNode.modifyGeom(0)) # geomNode = GeomNode('') # geomNode.addGeom(geom) # world.attachSoftBody(bodyNode) # inodenp.setPos(0, 0, 0.1) # self.setRB(bodyNP,**kw)#set po # inodenp.setCollideMask(BitMask32.allOn()) self.world.attachSoftBody(bodyNode) geomNP = bodyNP.attachNewNode(geomNode) return bodyNP,geomNP
if sys.argv[1] == '-l': for sh in shapes.keys(): print sh sys.exit(0) shp = sys.argv[1] if not shapes.has_key(shp): print "cannot find shape, -l for list" sys.exit(-1) um = meta_generic(shapes[shp]) um.polygonize() format=GeomVertexFormat.getV3n3() vdata=GeomVertexData("vertices", format, Geom.UHStatic) vertexWriter=GeomVertexWriter(vdata, "vertex") normalWriter=GeomVertexWriter(vdata, "normal") print len(um.tri_list), "vertices" print len(um.tri_list) / 3.0, "tris" for p in um.tri_list: vertexWriter.addData3f(p[0],p[1],p[2]) for p in um.normal_list: normalWriter.addData3f(p[0],p[1],p[2]) for p in reversed(um.tri_list): vertexWriter.addData3f(p[0],p[1],p[2]) for p in reversed(um.normal_list): normalWriter.addData3f(-1 * p[0], -1 * p[1], -1 *p[2])
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 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': GeomLinestrips(static_mode), 'point': GeomPoints(static_mode), } if self.mode != 'line' or not self._triangles: 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) else: # line with segments defnined in triangles for line in self._triangles: prim = modes[self.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} ) ''')