def make_circle(x1,
y1,
z1,
x2,
y2,
z2,
inner_radius,
end_inner_radius,
arc,
new_z1,
new_z2,
tex_len=None,
tex_width=None,
end_radius=None,
rev=False):
format = GeomVertexFormat.getV3n3cpt2()
vdata = GeomVertexData('circle', format, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
normal = GeomVertexWriter(vdata, 'normal')
texcoord = GeomVertexWriter(vdata, 'texcoord')
ccw = arc < 0
arc = -arc if ccw else arc
num_parts = 50 * (arc / 360)**-1
num_draw = round(num_parts * (arc / 360))
x3 = x1 - x2
y3 = y1 - y2
z3 = z1 - z2
x3, y3, z3 = normalized(x3, y3, z3)
theta_offset = math.atan2(y1 - y2, x1 - x2)
orig_radius = math.sqrt((x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
cur_x1 = x1
cur_y1 = y1
cur_z1 = z1
cur_x2 = x2
cur_y2 = y2
cur_z2 = z2
z1_diff = new_z1 - z1
z2_diff = new_z2 - z2
if end_radius is None:
end_radius = orig_radius
inner_radius_diff = end_inner_radius - inner_radius
radius_diff = end_radius - orig_radius
for i in range(num_draw + 1):
theta = (math.pi - 2 * math.pi * (i / num_parts)) % (2 * math.pi)
interp = (i / num_draw)
inner_radius_interp = inner_radius + (inner_radius_diff *
(i / num_parts))
radius = (orig_radius + (radius_diff * interp)) + inner_radius_interp
radius_offset = 0
if rev:
radius_offset = radius_diff * interp
x1_interp = x1 + ((inner_radius + radius_offset) * x3)
y1_interp = y1 + ((inner_radius + radius_offset) * y3)
z1_interp = z1 + ((inner_radius + radius_offset) * z3)
x_outer = (math.cos((-theta if ccw else theta) + theta_offset) *
radius) + x1_interp
y_outer = (math.sin((-theta if ccw else theta) + theta_offset) *
radius) + y1_interp
x_inner = (math.cos((-theta if ccw else theta) + theta_offset) *
inner_radius_interp) + x1_interp
y_inner = (math.sin((-theta if ccw else theta) + theta_offset) *
inner_radius_interp) + y1_interp
D = Vec3(cur_x1, cur_y1, cur_z1)
C = Vec3(cur_x2, cur_y2, cur_z2)
B = Vec3(x_inner, y_inner, z1_interp + (z1_diff * interp))
A = Vec3(x_outer, y_outer, z1_interp + (z2_diff * interp))
normal_vec = (C - A).cross(D - B).normalize()
vertex.addData3(x_inner, y_inner, z1_interp + (z1_diff * interp))
cur_x1, cur_y1, cur_z1 = x_inner, y_inner, z1_interp + (z1_diff *
interp)
normal.addData3(normal_vec)
texcoord.addData2f(
(((i / num_parts) * 2 * math.pi * inner_radius_interp) /
tex_len) if tex_len is not None else 1.0,
(orig_radius / tex_width) if tex_width is not None else 1.0)
vertex.addData3(x_outer, y_outer, z1_interp + (z2_diff * interp))
cur_x2, cur_y2, cur_z2 = x_outer, y_outer, z1_interp + (z2_diff *
interp)
normal.addData3(normal_vec)
texcoord.addData2f((((i / num_parts) * 2 * math.pi * radius) /
tex_len) if tex_len is not None else 1.0, 0)
tris = GeomTriangles(Geom.UHDynamic)
for i in range(num_draw * 2):
tris.addVertices(0 + i, 1 + i, 2 + i)
circle = Geom(vdata)
circle.addPrimitive(tris)
return circle, cur_x1, cur_y1, cur_z1, cur_x2, cur_y2, cur_z2
def getNodeFromController(controller, controlled_prim):
if type(controlled_prim) is collada.controller.BoundSkinPrimitive:
ch = Character('simplechar')
bundle = ch.getBundle(0)
skeleton = PartGroup(bundle, '<skeleton>')
character_joints = {}
for (name, joint_matrix) in controller.joint_matrices.iteritems():
joint_matrix.shape = (-1)
character_joints[name] = CharacterJoint(ch, bundle, skeleton, name,
Mat4(*joint_matrix))
tbtable = TransformBlendTable()
for influence in controller.index:
blend = TransformBlend()
for (joint_index, weight_index) in influence:
char_joint = character_joints[controller.getJoint(joint_index)]
weight = controller.getWeight(weight_index)[0]
blend.addTransform(JointVertexTransform(char_joint), weight)
tbtable.addBlend(blend)
array = GeomVertexArrayFormat()
array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32,
Geom.CPoint)
array.addColumn(InternalName.make('normal'), 3, Geom.NTFloat32,
Geom.CPoint)
array.addColumn(InternalName.make('texcoord'), 2, Geom.NTFloat32,
Geom.CTexcoord)
blendarr = GeomVertexArrayFormat()
blendarr.addColumn(InternalName.make('transform_blend'), 1,
Geom.NTUint16, Geom.CIndex)
format = GeomVertexFormat()
format.addArray(array)
format.addArray(blendarr)
aspec = GeomVertexAnimationSpec()
aspec.setPanda()
format.setAnimation(aspec)
format = GeomVertexFormat.registerFormat(format)
dataname = controller.id + '-' + controlled_prim.primitive.material.id
vdata = GeomVertexData(dataname, format, Geom.UHStatic)
vertex = GeomVertexWriter(vdata, 'vertex')
normal = GeomVertexWriter(vdata, 'normal')
texcoord = GeomVertexWriter(vdata, 'texcoord')
transform = GeomVertexWriter(vdata, 'transform_blend')
numtris = 0
if type(controlled_prim.primitive) is collada.polylist.BoundPolylist:
for poly in controlled_prim.primitive.polygons():
for tri in poly.triangles():
for tri_pt in range(3):
vertex.addData3f(tri.vertices[tri_pt][0],
tri.vertices[tri_pt][1],
tri.vertices[tri_pt][2])
normal.addData3f(tri.normals[tri_pt][0],
tri.normals[tri_pt][1],
tri.normals[tri_pt][2])
if len(controlled_prim.primitive._texcoordset) > 0:
texcoord.addData2f(tri.texcoords[0][tri_pt][0],
tri.texcoords[0][tri_pt][1])
transform.addData1i(tri.indices[tri_pt])
numtris += 1
elif type(controlled_prim.primitive
) is collada.triangleset.BoundTriangleSet:
for tri in controlled_prim.primitive.triangles():
for tri_pt in range(3):
vertex.addData3f(tri.vertices[tri_pt][0],
tri.vertices[tri_pt][1],
tri.vertices[tri_pt][2])
normal.addData3f(tri.normals[tri_pt][0],
tri.normals[tri_pt][1],
tri.normals[tri_pt][2])
if len(controlled_prim.primitive._texcoordset) > 0:
texcoord.addData2f(tri.texcoords[0][tri_pt][0],
tri.texcoords[0][tri_pt][1])
transform.addData1i(tri.indices[tri_pt])
numtris += 1
tbtable.setRows(SparseArray.lowerOn(vdata.getNumRows()))
gprim = GeomTriangles(Geom.UHStatic)
for i in range(numtris):
gprim.addVertices(i * 3, i * 3 + 1, i * 3 + 2)
gprim.closePrimitive()
pgeom = Geom(vdata)
pgeom.addPrimitive(gprim)
render_state = getStateFromMaterial(controlled_prim.primitive.material)
control_node = GeomNode("ctrlnode")
control_node.addGeom(pgeom, render_state)
ch.addChild(control_node)
bundle = AnimBundle('simplechar', 5.0, 2)
skeleton = AnimGroup(bundle, '<skeleton>')
root = AnimChannelMatrixXfmTable(skeleton, 'root')
#hjoint = AnimChannelMatrixXfmTable(root, 'joint1')
#table = [10, 11, 12, 13, 14, 15, 14, 13, 12, 11]
#data = PTAFloat.emptyArray(len(table))
#for i in range(len(table)):
# data.setElement(i, table[i])
#hjoint.setTable(ord('i'), CPTAFloat(data))
#vjoint = AnimChannelMatrixXfmTable(hjoint, 'joint2')
#table = [10, 9, 8, 7, 6, 5, 6, 7, 8, 9]
#data = PTAFloat.emptyArray(len(table))
#for i in range(len(table)):
# data.setElement(i, table[i])
#vjoint.setTable(ord('j'), CPTAFloat(data))
wiggle = AnimBundleNode('wiggle', bundle)
np = NodePath(ch)
anim = NodePath(wiggle)
a = Actor(np, {'simplechar': anim})
a.loop('simplechar')
return a
#a.setPos(0, 0, 0)
else:
raise Exception("Error: unsupported controller type")
def regenerateGeometry(self):
#
# Generate vertex data
#
numVerts = len(self.vertices)
vdata = GeomVertexData("SolidFace", getFaceFormat(), GeomEnums.UHStatic)
vdata.uncleanSetNumRows(len(self.vertices))
vwriter = GeomVertexWriter(vdata, InternalName.getVertex())
twriter = GeomVertexWriter(vdata, InternalName.getTexcoord())
nwriter = GeomVertexWriter(vdata, InternalName.getNormal())
tanwriter = GeomVertexWriter(vdata, InternalName.getTangent())
bwriter = GeomVertexWriter(vdata, InternalName.getBinormal())
for i in range(len(self.vertices)):
vert = self.vertices[i]
vwriter.setData3f(vert.pos)
twriter.setData2f(vert.uv)
nwriter.setData3f(self.plane.getNormal())
tanwriter.setData3f(self.material.tangent)
bwriter.setData3f(self.material.binormal)
#
# Generate indices
#
# Triangles in 3D view
prim3D = GeomTriangles(GeomEnums.UHStatic)
prim3D.reserveNumVertices((numVerts - 2) * 3)
for i in range(1, numVerts - 1):
prim3D.addVertices(i + 1, i, 0)
prim3D.closePrimitive()
# Line loop in 2D view.. using line strips
prim2D = GeomLinestrips(GeomEnums.UHStatic)
prim2D.reserveNumVertices(numVerts + 1)
for i in range(numVerts):
prim2D.addVertex(i)
# Close off the line strip with the first vertex.. creating a line loop
prim2D.addVertex(0)
prim2D.closePrimitive()
#
# Generate mesh objects
#
geom3D = SolidFaceGeom(vdata)
geom3D.setDrawMask(VIEWPORT_3D_MASK)
geom3D.setPlaneCulled(True)
geom3D.setPlane(self.plane)
geom3D.addPrimitive(prim3D)
self.index3D = self.solid.addFaceGeom(geom3D, self.state3D)
geom3DLines = SolidFaceGeom(vdata)
geom3DLines.addPrimitive(prim2D)
geom3DLines.setDrawMask(VIEWPORT_3D_MASK)
geom3DLines.setDraw(False)
self.index3DLines = self.solid.addFaceGeom(geom3DLines, self.state3DLines)
geom2D = SolidFaceGeom(vdata)
geom2D.addPrimitive(prim2D)
geom2D.setDrawMask(VIEWPORT_2D_MASK)
self.index2D = self.solid.addFaceGeom(geom2D, self.state2D)
self.geom3D = geom3D
self.geom3DLines = geom3DLines
self.geom2D = geom2D
self.vdata = vdata
self.hasGeometry = True
def visualize(centers, corners, edges):
from meshtool.filters.panda_filters.pandacore import getVertexData, attachLights, ensureCameraAt
from meshtool.filters.panda_filters.pandacontrols import KeyboardMovement, MouseDrag, MouseScaleZoom, MouseCamera
from panda3d.core import GeomPoints, GeomTriangles, Geom, GeomNode, GeomVertexFormat, GeomVertexData, GeomVertexWriter, LineSegs, VBase3
from direct.showbase.ShowBase import ShowBase
format = GeomVertexFormat.getV3c4()
vdata = GeomVertexData('pts', format, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
vertex_index = 0
center_vertex_indices = {}
corner_vertex_indices = {}
for key, center in centers.iteritems():
vertex.addData3f(center.x * X_SCALE, center.y * Y_SCALE,
center.elevation * Z_SCALE)
curcolor = hex2rgb(COLORS[center.biome])
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
center_vertex_indices[key] = vertex_index
vertex_index += 1
for corner in center.corners:
vertex.addData3f(corner.x * X_SCALE, corner.y * Y_SCALE,
corner.elevation * Z_SCALE)
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
corner_vertex_indices[corner.id] = vertex_index
vertex_index += 1
tris = GeomTriangles(Geom.UHDynamic)
for edge in edges.itervalues():
corner0 = edge.corner0
corner1 = edge.corner1
center0 = edge.center0
center1 = edge.center1
if corner0 is None or corner1 is None:
continue
tris.addVertices(corner_vertex_indices[corner1.id],
corner_vertex_indices[corner0.id],
center_vertex_indices[center0.id])
tris.addVertices(center_vertex_indices[center1.id],
corner_vertex_indices[corner0.id],
corner_vertex_indices[corner1.id])
tris.closePrimitive()
pgeom = Geom(vdata)
pgeom.addPrimitive(tris)
node = GeomNode("primitive")
node.addGeom(pgeom)
p3dApp = ShowBase()
attachLights(render)
geomPath = render.attachNewNode(node)
#geomPath.setRenderModeThickness(6.0)
#geomPath.setRenderModeWireframe()
ensureCameraAt(geomPath, base.cam)
boundingSphere = geomPath.getBounds()
base.cam.setPos(boundingSphere.getCenter() + boundingSphere.getRadius())
base.cam.lookAt(boundingSphere.getCenter())
geomPath.setScale(VBase3(50, 50, 50))
KeyboardMovement()
#MouseDrag(geomPath)
MouseCamera()
MouseScaleZoom(geomPath)
#render.setShaderAuto()
p3dApp.run()
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
self.geomNode = GeomNode('mesh')
self.attachNewNode(self.geomNode)
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)
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)
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}
)
''')
def add_button(self, text, label_id, pos_x, pos_y, width=0.0, hight=0.1):
if width == 0.0:
for c in range(len(text) / 2):
width += 0.08
ls = LineSegs("lines")
ls.setColor(0, 1, 0, 1)
ls.drawTo(-width / 2, 0, hight / 2)
ls.drawTo(width / 2, 0, hight / 2)
ls.drawTo(width / 2, 0, -hight / 2)
ls.drawTo(-width / 2, 0, -hight / 2)
ls.drawTo(-width / 2, 0, hight / 2)
border = ls.create(False)
border.setTag('back_ground', '1')
array = GeomVertexArrayFormat()
array.addColumn("vertex", 4, Geom.NTFloat32, Geom.CPoint)
arr_format = GeomVertexFormat()
arr_format.addArray(array)
arr_format = GeomVertexFormat.registerFormat(arr_format)
vdata = GeomVertexData('fill', arr_format, Geom.UHStatic)
vdata.setNumRows(4)
vertex = GeomVertexWriter(vdata, 'vertex')
vertex.addData3f(-width / 2, 0, hight / 2)
vertex.addData3f(width / 2, 0, hight / 2)
vertex.addData3f(-width / 2, 0, -hight / 2)
vertex.addData3f(width / 2, 0, -hight / 2)
prim = GeomTristrips(Geom.UHStatic)
prim.addVertex(0)
prim.addVertex(1)
prim.addVertex(2)
prim.addVertex(3)
geom = Geom(vdata)
geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(geom)
nodePath = NodePath("button")
nodePath.attachNewNode(node)
nodePath.setPos(0, 0, 0)
nodePath.setTag('button', '1')
nodePath.setBin("unsorted", 0)
nodePath.setDepthTest(False)
nodePath.setColor(0, 0, 0, 1)
nodePath.attachNewNode(border)
nodePath1 = NodePath("button")
nodePath1.attachNewNode(node)
nodePath1.setPos(0, 0, 0)
nodePath1.setTag('button1', '1')
nodePath1.setBin("unsorted", 0)
nodePath1.setDepthTest(False)
nodePath1.setColor(0, 1, 0, 1)
nodePath1.attachNewNode(border)
button = DirectFrame(enableEdit=1,
text=text,
geom=nodePath,
text_scale=0.05,
text_fg=(0, 1, 0, 1),
borderWidth=(1, 1),
relief=None,
text_pos=(0, -0.01, 0),
textMayChange=1,
state=DGG.NORMAL,
parent=aspect2d)
button.setPos(pos_x, 0, pos_y)
button.bind(DGG.B1PRESS, button_click, [button])
button.bind(DGG.WITHIN, button_hover, [button])
button.bind(DGG.WITHOUT, button_no_hover, [button])
# button.resetFrameSize()
# self.button.bind(DGG.WITHIN, self.onMouseHoverInFunction, [button, some_value1])
defines.ENTITIES[defines.ENTITY_ID] = {
'CATEGORY': 'button',
'BUTTON': button,
'NODE': nodePath,
'LABEL': label_id,
'STATUS': 0
}
defines.ENTITY_ID += 1
def createCube(parent, index, cubeMembership, walls):
vertexFormat = GeomVertexFormat.getV3n3cp()
vertexData = GeomVertexData("cube_data", vertexFormat, Geom.UHStatic)
tris = GeomTriangles(Geom.UHStatic)
posWriter = GeomVertexWriter(vertexData, "vertex")
colWriter = GeomVertexWriter(vertexData, "color")
normalWriter = GeomVertexWriter(vertexData, "normal")
vertexCount = 0
for direction in (-1, 1):
for i in range(3):
normal = VBase3()
normal[i] = direction
rgb = [0., 0., 0.]
rgb[i] = 1.
if direction == 1:
rgb[i - 1] = 1.
r, g, b = rgb
color = (r, g, b, 0.)
for a, b in ((-1., -1.), (-1., 1.), (1., 1.), (1., -1.)):
pos = VBase3()
pos[i] = direction
pos[(i + direction) % 3] = a
pos[(i + direction * 2) % 3] = b
posWriter.addData3f(pos)
colWriter.addData4f(color)
normalWriter.addData3f(normal)
vertexCount += 4
tris.addVertices(vertexCount - 2, vertexCount - 3, vertexCount - 4)
tris.addVertices(vertexCount - 4, vertexCount - 1, vertexCount - 2)
geom = Geom(vertexData)
geom.addPrimitive(tris)
node = GeomNode("cube_node")
node.addGeom(geom)
cube = parent.attachNewNode(node)
x = index % 9 // 3 - 1
y = index // 9 - 1
z = index % 9 % 3 - 1
cube.setScale(.4)
cube.setPos(x * 0.85, y * 0.85, z * 0.85)
membership = set() # the walls this cube belongs to
cubeMembership[cube] = membership
if x == -1:
walls["left"].append(cube)
membership.add("left")
elif x == 1:
walls["right"].append(cube)
membership.add("right")
if y == -1:
walls["front"].append(cube)
membership.add("front")
elif y == 1:
walls["back"].append(cube)
membership.add("back")
if z == -1:
walls["bottom"].append(cube)
membership.add("bottom")
elif z == 1:
walls["top"].append(cube)
membership.add("top")
return cube
def renderCharts(facegraph, verts, vert_indices, lineset=None):
from meshtool.filters.panda_filters.pandacore import getVertexData, attachLights, ensureCameraAt
from meshtool.filters.panda_filters.pandacontrols import KeyboardMovement, MouseDrag, MouseScaleZoom, ButtonUtils
from panda3d.core import GeomTriangles, Geom, GeomNode, GeomVertexFormat, GeomVertexData, GeomVertexWriter, LineSegs
from direct.showbase.ShowBase import ShowBase
vformat = GeomVertexFormat.getV3c4()
vdata = GeomVertexData('tris', vformat, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
colors = gen_color3(len(facegraph))
numtris = 0
for chart, data in facegraph.nodes_iter(data=True):
curcolor = next(colors)
for tri in data['tris']:
triv = verts[vert_indices[tri]]
vertex.addData3f(triv[0][0], triv[0][1], triv[0][2])
vertex.addData3f(triv[1][0], triv[1][1], triv[1][2])
vertex.addData3f(triv[2][0], triv[2][1], triv[2][2])
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
numtris += 1
tris = GeomTriangles(Geom.UHDynamic)
tris.addConsecutiveVertices(0, 3 * numtris)
tris.closePrimitive()
linenodes = []
if lineset:
for lines in lineset:
ls = LineSegs()
ls.setThickness(4)
curcolor = next(colors)
ls.setColor(curcolor[0] / 256.0, curcolor[1] / 256.0,
curcolor[2] / 256.0, 1)
tuples = False
for blah in lines:
if isinstance(blah, tuple):
tuples = True
break
if tuples:
for i, j in lines:
frompt = verts[i]
topt = verts[j]
ls.moveTo(frompt[0], frompt[1], frompt[2])
ls.drawTo(topt[0], topt[1], topt[2])
else:
for i in range(len(lines) - 1):
frompt = verts[lines[i]]
topt = verts[lines[i + 1]]
ls.moveTo(frompt[0], frompt[1], frompt[2])
ls.drawTo(topt[0], topt[1], topt[2])
linenodes.append(ls.create())
pgeom = Geom(vdata)
pgeom.addPrimitive(tris)
node = GeomNode("primitive")
node.addGeom(pgeom)
p3dApp = ShowBase()
#attachLights(render)
geomPath = render.attachNewNode(node)
for linenode in linenodes:
geomPath.attachNewNode(linenode)
#geomPath.setRenderModeWireframe()
ensureCameraAt(geomPath, base.cam)
boundingSphere = geomPath.getBounds()
base.cam.setPos(boundingSphere.getCenter() + boundingSphere.getRadius())
base.cam.lookAt(boundingSphere.getCenter())
KeyboardMovement()
ButtonUtils(geomPath)
MouseDrag(geomPath)
MouseScaleZoom(geomPath)
#render.setShaderAuto()
p3dApp.run()
def generate(self):
'''(Re)generate the entire terrain erasing any current changes'''
factor = self.blockSize * self.chunkSize
#print "Factor:", factor
for terrain in self.terrains:
terrain.getRoot().removeNode()
self.terrains = []
# Breaking master heightmap into subimages
heightmaps = []
self.xchunks = (self.heightfield.getXSize() - 1) / factor
self.ychunks = (self.heightfield.getYSize() - 1) / factor
#print "X,Y chunks:", self.xchunks, self.ychunks
n = 0
for y in range(0, self.ychunks):
for x in range(0, self.xchunks):
heightmap = PNMImage(factor + 1, factor + 1)
heightmap.copySubImage(self.heightfield,
0,
0,
xfrom=x * factor,
yfrom=y * factor)
heightmaps.append(heightmap)
n += 1
# Generate GeoMipTerrains
n = 0
y = self.ychunks - 1
x = 0
for heightmap in heightmaps:
terrain = GeoMipTerrain(str(n))
terrain.setHeightfield(heightmap)
terrain.setBruteforce(self.bruteForce)
terrain.setBlockSize(self.blockSize)
terrain.generate()
self.terrains.append(terrain)
root = terrain.getRoot()
root.reparentTo(self.root)
root.setPos(n % self.xchunks * factor, (y) * factor, 0)
# In order to texture span properly we need to reiterate through every vertex
# and redefine the uv coordinates based on our size, not the subGeoMipTerrain's
root = terrain.getRoot()
children = root.getChildren()
for child in children:
geomNode = child.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.modifyGeom(i)
vdata = geom.modifyVertexData()
texcoord = GeomVertexWriter(vdata, 'texcoord')
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
t = texcoord.setData2f(
(v[0] + self.blockSize / 2 + self.blockSize * x) /
(self.xsize - 1),
(v[1] + self.blockSize / 2 + self.blockSize * y) /
(self.ysize - 1))
x += 1
if x >= self.xchunks:
x = 0
y -= 1
n += 1
def RingFaceGeometry(up, inner_radius, outer_radius, nbOfPoints):
format = GeomVertexFormat.getV3n3cpt2()
vdata = GeomVertexData('ring', format, Geom.UHStatic)
vdata.unclean_set_num_rows(nbOfPoints)
vertex = GeomVertexWriter(vdata, 'vertex')
normal = GeomVertexWriter(vdata, 'normal')
color = GeomVertexWriter(vdata, 'color')
texcoord = GeomVertexWriter(vdata, 'texcoord')
for i in range(nbOfPoints):
angle = 2 * pi / nbOfPoints * i
x = cos(angle)
y = sin(angle)
vertex.addData3f(outer_radius * x, outer_radius * y, 0)
normal.addData3f(0, 0, up)
color.addData4f(1, 1, 1, 1)
texcoord.addData2f(1, 0)
vertex.addData3f(inner_radius * x, inner_radius * y, 0)
normal.addData3f(0, 0, up)
color.addData4f(1, 1, 1, 1)
texcoord.addData2f(0, 0)
triangles = GeomTriangles(Geom.UHStatic)
triangles.reserve_num_vertices(nbOfPoints - 1)
for i in range(nbOfPoints - 1):
if up < 0:
triangles.addVertex(i * 2 + 0)
triangles.addVertex(i * 2 + 1)
triangles.addVertex(i * 2 + 2)
triangles.closePrimitive()
triangles.addVertex(i * 2 + 2)
triangles.addVertex(i * 2 + 1)
triangles.addVertex(i * 2 + 3)
triangles.closePrimitive()
else:
triangles.addVertex(i * 2 + 2)
triangles.addVertex(i * 2 + 1)
triangles.addVertex(i * 2 + 0)
triangles.closePrimitive()
triangles.addVertex(i * 2 + 3)
triangles.addVertex(i * 2 + 1)
triangles.addVertex(i * 2 + 2)
triangles.closePrimitive()
if up < 0:
triangles.addVertex((nbOfPoints - 1) * 2 + 0)
triangles.addVertex((nbOfPoints - 1) * 2 + 1)
triangles.addVertex(0)
triangles.closePrimitive()
triangles.addVertex(0)
triangles.addVertex((nbOfPoints - 1) * 2 + 1)
triangles.addVertex(1)
triangles.closePrimitive()
else:
triangles.addVertex(0)
triangles.addVertex((nbOfPoints - 1) * 2 + 1)
triangles.addVertex((nbOfPoints - 1) * 2 + 0)
triangles.closePrimitive()
triangles.addVertex(1)
triangles.addVertex((nbOfPoints - 1) * 2 + 1)
triangles.addVertex(0)
triangles.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(triangles)
return geom
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
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 __init__(self, parent):
DirectObject.DirectObject.__init__(self)
self.debugMode = config.GetInt('loading-screen') == 2
self.parent = parent
self.state = False
self.currScreenshot = None
self.snapshot = None
self.snapshotFrame = None
self.snapshotFrameBasic = None
self.currentTime = 0
self.analyzeMode = False
self.loadScale = 1.0
self.unmappedTicks = []
self.stepInfo = { }
self.accept(base.win.getWindowEvent(), self.adjustSize)
self.accept('tick', self.tick)
self.currStage = 'unmapped'
self.stagePercent = 0
self.numObjects = 0
self.currPercent = 0.0
self.line = LineSegs()
self.line.setColor((0, 0, 0, 1))
self.line.setThickness(1)
self.stageLabel = None
self.currNum = 0
self.overallPercent = 0
self.lastPercent = 0
self.topLock = aspect2dp.attachNewNode('topShift')
self.root = self.topLock.attachNewNode('loadingScreenRoot')
self.root.setZ(-1)
self.root.stash()
self.model = loader.loadModel('models/gui/pir_m_gui_gen_loadScreen.bam')
self.model.setP(90)
self.model.reparentTo(self.root)
cm = CardMaker('backdrop')
cm.setFrame(-10, 10, -10, 10)
if self.debugMode:
self.backdrop = self.root.attachNewNode(cm.generate())
self.backdrop.setX(-1.5)
self.backdrop.setZ(-1)
self.backdrop.setScale(4)
self.backdrop.setColor(0.5, 0.5, 0.5, 1)
cm = CardMaker('loadingBarBase')
cm.setFrame(-0.90000000000000002, 0.90000000000000002, 0.10000000000000001, 0.5)
self.loadingBarBacking = self.root.attachNewNode(cm.generate())
self.loadingBarRoot = self.root.attachNewNode('loadingBarRoot')
cm.setName('analysisBarBase')
cm.setFrame(-0.90000000000000002, 0.90000000000000002, -0.5, -0.10000000000000001)
self.analysisBar = self.root.attachNewNode(cm.generate())
self.analysisBarRoot = self.root.attachNewNode('analysisBarRoot')
self.analysisBar.hide()
self.analysisButtons = []
self.enterToContinue = DirectLabel(parent = self.root, text = 'Press Shift To Continue', relief = None, text_scale = 0.10000000000000001, pos = (0, 0, -0.90000000000000002), text_align = TextNode.ACenter)
self.enterToContinue.hide()
self.stageLabel = DirectLabel(parent = self.root, text = '', relief = None, text_scale = 0.10000000000000001, pos = (-1.25, 0, 0.75), text_align = TextNode.ALeft, textMayChange = 1)
self.tickLabel = DirectLabel(parent = self.root, text = '', relief = None, text_scale = 0.10000000000000001, pos = (0.75, 0, 0.75), textMayChange = 1)
self.overallLabel = DirectLabel(parent = self.root, text = '', relief = None, text_scale = 0.10000000000000001, pos = (0, 0, -0.75), textMayChange = 1)
else:
self.backdrop = loader.loadModel('models/gui/pir_m_gui_gen_loadScreen')
self.backdrop.reparentTo(self.root)
bg = self.backdrop.find('**/expandable_bg')
bg.setScale(1000, 1, 1000)
bg.flattenStrong()
self.backdrop.find('**/loadbar_grey').setColorScale(0.14999999999999999, 0.14999999999999999, 0.14999999999999999, 0.10000000000000001)
self.loadingBar = self.backdrop.find('**/loadbar')
self.loadingBar.setColorScale(0.20000000000000001, 0.59999999999999998, 0.5, 1)
self.loadingPlank = NodePathCollection()
self.loadingPlank.addPath(self.backdrop.find('**/plank_loading_bar'))
self.loadingPlank.addPath(self.backdrop.find('**/loadbar'))
self.loadingPlank.addPath(self.backdrop.find('**/loadbar_frame'))
self.loadingPlank.addPath(self.backdrop.find('**/loadbar_grey'))
self.titlePlank = self.backdrop.find('**/plank_title')
self.percentLabel = DirectLabel(text = '0%', parent = self.root, relief = None, text_font = PiratesGlobals.getPirateFont(), text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_scale = 0.031, pos = (0, 0, -0.44450000000000001), textMayChange = 1)
self.loadingPlank.addPath(self.percentLabel)
self.screenshot = self.backdrop.find('**/screenshot')
copyGeom = self.loadingBar.find('**/+GeomNode').node().getGeom(0)
format = copyGeom.getVertexData().getFormat()
primitive = copyGeom.getPrimitive(0)
data = GeomVertexData(self.screenshot.node().getGeom(0).getVertexData())
data.setFormat(format)
writer = GeomVertexWriter(data, 'texcoord')
writer.setData2f(0, 0)
writer.setData2f(1, 0)
writer.setData2f(1, 1)
writer.setData2f(0, 1)
geom = Geom(data)
geom.addPrimitive(primitive)
self.screenshot.node().removeGeom(0)
self.screenshot.node().addGeom(geom)
self.titlePlankMiddle = self.backdrop.find('**/plank_title_middle_box')
self.titlePlankLeft = self.backdrop.find('**/plank_title_left')
self.titlePlankRight = self.backdrop.find('**/plank_title_right')
self.loadingBarColors = [ (((i % 10) / 10.0 + 0.5) / 2.0, ((i % 100) / 10 / 10.0 + 0.5) / 2.0, (i / 100 / 10.0 + 0.5) / 2.0, 1) for i in range(1000) ]
random.shuffle(self.loadingBarColors)
self.lastUpdateTime = globalClock.getRealTime()
self.locationLabel = DirectLabel(parent = self.root, relief = None, text = '', text_font = PiratesGlobals.getPirateOutlineFont(), text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, text_scale = PiratesGuiGlobals.TextScaleTitleJumbo * 0.69999999999999996, text_align = TextNode.ACenter, pos = (0.0, 0.0, 0.51500000000000001), textMayChange = 1)
self.locationText = None
self.hintLabel = DirectLabel(parent = self.root, relief = None, text = '', text_font = PiratesGlobals.getPirateOutlineFont(), text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, text_scale = PiratesGuiGlobals.TextScaleTitleJumbo * 0.5, text_align = TextNode.ACenter, pos = (0.0, 0.0, -0.62), text_wordwrap = 30, textMayChange = 1)
self.hintText = None
self.adImage = None
self.allowLiveFlatten = ConfigVariableBool('allow-live-flatten')
self.title_art = []
self.tempVolume = []
self.adjustSize(base.win)
gsg = base.win.getGsg()
if gsg:
self.root.prepareScene(gsg)
def __init__(self, size, pos, depth, mask, spec = WaterSpec()):
NodePath.__init__(self, 'waterNode')
self.setPos(pos)
self.spec = spec
self.pos = pos
self.depth = depth
self.size = size
self.mask = mask
self.height = pos[2]
normal = (0, 0, 1)
tangent = (normal[0], normal[2], -normal[1])
binormal = (normal[2], normal[1], -normal[0])
# Build array for new format.
array = GeomVertexArrayFormat()
array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32, Geom.CPoint)
array.addColumn(InternalName.make('texcoord'), 2, Geom.NTFloat32, Geom.CTexcoord)
array.addColumn(InternalName.make('normal'), 3, Geom.NTFloat32, Geom.CVector)
array.addColumn(InternalName.make('binormal'), 3, Geom.NTFloat32, Geom.CVector)
array.addColumn(InternalName.make('tangent'), 3, Geom.NTFloat32, Geom.CVector)
# Create and register format.
format = GeomVertexFormat()
format.addArray(array)
format = GeomVertexFormat.registerFormat(format)
vdata = GeomVertexData('waterPlanes', format, Geom.UHStatic)
vdata.setNumRows(4)
vtxWriter = GeomVertexWriter(vdata, 'vertex')
tcWriter = GeomVertexWriter(vdata, 'texcoord')
tnWriter = GeomVertexWriter(vdata, 'tangent')
bnWriter = GeomVertexWriter(vdata, 'binormal')
normWriter = GeomVertexWriter(vdata, 'normal')
# top left corner
vtxWriter.addData3f(size[0], size[3], 0)
tcWriter.addData2f(0, 1)
normWriter.addData3f(*normal)
tnWriter.addData3f(*tangent)
bnWriter.addData3f(*binormal)
# bottom left corner
vtxWriter.addData3f(size[0], size[2], 0)
tcWriter.addData2f(0, 0)
normWriter.addData3f(*normal)
tnWriter.addData3f(*tangent)
bnWriter.addData3f(*binormal)
# top right corner
vtxWriter.addData3f(size[1], size[3], 0)
tcWriter.addData2f(1, 1)
normWriter.addData3f(*normal)
tnWriter.addData3f(*tangent)
bnWriter.addData3f(*binormal)
# bottom right corner
vtxWriter.addData3f(size[1], size[2], 0)
tcWriter.addData2f(1, 0)
normWriter.addData3f(*normal)
tnWriter.addData3f(*tangent)
bnWriter.addData3f(*binormal)
topTris = GeomTriangles(Geom.UHStatic)
topTris.addVertices(0, 1, 2)
topTris.addVertices(3, 2, 1)
topGeom = Geom(vdata)
topGeom.addPrimitive(topTris)
self.topNP = self.attachNewNode(GeomNode('waterTop'))
self.topNP.node().addGeom(topGeom)
# Reverse the winding for the bottom water plane
botTris = GeomTriangles(Geom.UHStatic)
botTris.addVertices(2, 1, 0)
botTris.addVertices(1, 2, 3)
botGeom = Geom(vdata)
botGeom.addPrimitive(botTris)
self.botNP = self.attachNewNode(GeomNode('waterBot'))
self.botNP.node().addGeom(botGeom)
# Create an AABB which defines the volume of this water.
self.aabb = BoundingBox(Point3(size[0], size[2], -depth), Point3(size[1], size[3], 0))
self.aabb.xform(self.getMat(render))
self.cubemap = base.bspLoader.getClosestCubemapTexture(self.getPos(render))
self.dudvFrame = 0
def draw_water_mesh(self):
_format = GeomVertexFormat.get_v3n3cp()
self.water_vdata = GeomVertexData('water', _format, Geom.UHDynamic)
self.water_vdata.setNumRows((self.n_points // self.details)**2)
vertex = GeomVertexWriter(self.water_vdata, 'vertex')
normal = GeomVertexWriter(self.water_vdata, 'normal')
color = GeomVertexWriter(self.water_vdata, 'color')
for j in range(0, self.n_points, self.details):
for i in range(0, self.n_points, self.details):
if j == self.n_points - self.details:
j = self.n_points - 1
if i == self.n_points - self.details:
i = self.n_points - 1
# Water Vertices
vertex.addData3f(self.x[j][i], self.y[j][i], self.wz[j][i])
# Water Color
color.addData4f(0.3, 0.3, 1, 0.8)
# water Normals
n = np.array([self.x[j][i], self.y[j][i], self.wz[j][i]])
norm = n / np.linalg.norm(n)
normal.addData3f(norm[0], norm[1], norm[2])
# Water Primitive
prim = GeomTriangles(Geom.UHDynamic)
for j in range(self.n_points // self.details):
for i in range(self.n_points // self.details):
if j != (self.n_points // self.details) - 1 and i != (
self.n_points // self.details) - 1:
prim.add_vertices(
j * (self.n_points // self.details) + i,
j * (self.n_points // self.details) + (i + 1),
(j + 1) * (self.n_points // self.details) + i)
prim.add_vertices(
j * (self.n_points // self.details) + (i + 1),
(j + 1) * (self.n_points // self.details) + (i + 1),
(j + 1) * (self.n_points // self.details) + i)
geom = Geom(self.water_vdata)
prim.closePrimitive()
geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(geom)
water_nodePath = render.attachNewNode(node)
water_nodePath.setTransparency(TransparencyAttrib.MAlpha)
water_nodePath.setAntialias(AntialiasAttrib.MAuto)
water_nodePath.setPos(-50, -50, 0)
# Border
self.water_border_vdata = GeomVertexData('water_border', _format,
Geom.UHDynamic)
self.water_border_vdata.setNumRows(8)
vertex = GeomVertexWriter(self.water_border_vdata, 'vertex')
normal = GeomVertexRewriter(self.water_border_vdata, 'normal')
color = GeomVertexWriter(self.water_border_vdata, 'color')
for i in [0, 99]:
for j in range(1, -1, -1):
# Borders Vertices
vertex.addData3f(i, 0, j)
# Borders Colors
color.addData4f(0.3, 0.3, 1, 0.8)
# Borders Normals
n = np.array([i, 0, 1e-12 if j == 0 else 1])
norm = n / np.linalg.norm(n)
normal.addData3f(norm[0], norm[1], norm[2])
for i in [99, 0]:
for j in range(1, -1, -1):
vertex.addData3f(i, 99, j)
color.addData4f(0.3, 0.3, 1, 0.8)
n = np.array([i, 99, 1e-12 if j == 0 else 1])
norm = n / np.linalg.norm(n)
normal.addData3f(norm[0], norm[1], norm[2])
# Borders Primitive
prim = GeomTriangles(Geom.UHDynamic)
for i in range(0, 8, 2):
prim.add_vertices(i, i+1 if i+1 < 8 else i+1-8, \
i+2 if i+2 < 8 else i+2-8)
prim.add_vertices(i+2 if i+2 < 8 else i+2-8, \
i+1 if i+1 < 8 else i+1-8, i+3 if i+3 < 8 else i+3-8)
geom = Geom(self.water_border_vdata)
geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(geom)
water_border_nodePath = render.attachNewNode(node)
water_border_nodePath.setTransparency(TransparencyAttrib.MAlpha)
water_border_nodePath.setAntialias(AntialiasAttrib.MAuto)
water_border_nodePath.setPos(-50, -50, 0)
def gen_geom(self, mesh_json):
# Create vertex format
geom_array = GeomVertexArrayFormat()
geom_array.add_column("vertex", 3, Geom.NTFloat32, Geom.CPoint)
has_normals = False
has_texcoords = False
has_weights = False
if "normals" in mesh_json:
geom_array.add_column("normal", 3, Geom.NTFloat32, Geom.CNormal)
has_normals = True
if "texcoords" in mesh_json:
geom_array.add_column("texcoord", 3, Geom.NTFloat32,
Geom.CTexcoord)
has_texcoords = True
if "weights" in mesh_json:
geom_array.add_column("joint", 4, Geom.NTUint8, Geom.CIndex)
geom_array.add_column("weight", 4, Geom.NTFloat32, Geom.COther)
has_weights = True
geom_format = GeomVertexFormat()
geom_format.add_array(geom_array)
geom_format = GeomVertexFormat.register_format(geom_format)
# Set up vertex data
vdata = GeomVertexData(
str(random.randint(0, 255)) + "_vdata", geom_format, Geom.UHStatic)
vcount = len(mesh_json["vertices"]) // 3
vdata.setNumRows(vcount)
vertex = GeomVertexWriter(vdata, "vertex")
for i in range(vcount):
vertex.addData3(mesh_json["vertices"][3 * i],
mesh_json["vertices"][3 * i + 1],
mesh_json["vertices"][3 * i + 2])
if has_normals:
normal = GeomVertexWriter(vdata, "normal")
for i in range(vcount):
normal.addData3(mesh_json["normals"][3 * i],
mesh_json["normals"][3 * i + 1],
mesh_json["normals"][3 * i + 2])
if has_texcoords:
texcoord = GeomVertexWriter(vdata, "texcoord")
for i in range(vcount):
texcoord.addData2(mesh_json["texcoords"][2 * i],
mesh_json["texcoords"][2 * i + 1])
if has_weights:
joint = GeomVertexWriter(vdata, "joint")
weight = GeomVertexWriter(vdata, "weight")
for i in range(vcount):
joint_count = len(mesh_json["joints"][i])
joint.addData4(
0 if joint_count < 1 else mesh_json["joints"][i][0],
0 if joint_count < 2 else mesh_json["joints"][i][1],
0 if joint_count < 3 else mesh_json["joints"][i][2],
0 if joint_count < 4 else mesh_json["joints"][i][3])
weight.addData4(
0 if joint_count < 1 else mesh_json["weights"][i][0],
0 if joint_count < 2 else mesh_json["weights"][i][1],
0 if joint_count < 3 else mesh_json["weights"][i][2],
0 if joint_count < 4 else mesh_json["weights"][i][3])
# Create primitive
prim = GeomTriangles(Geom.UHStatic)
for i in range(vcount // 3):
prim.addVertices(3 * i, 3 * i + 1, 3 * i + 2)
geom = Geom(vdata)
geom.add_primitive(prim)
# Load texture
tex = None
if "texture" in mesh_json:
tex = Loader(EComponent.base).loadTexture(
(Path("resources") / mesh_json["texture"]).absolute())
tex.setMagfilter(SamplerState.FT_nearest)
tex.setMinfilter(SamplerState.FT_nearest)
# Create new geometry node
geom_node = GeomNode(str(random.randint(0, 255)) + "_node")
if tex is None:
geom_node.addGeom(geom)
else:
attrib = TextureAttrib.make(tex)
state = RenderState.make(attrib)
geom_node.addGeom(geom, state)
if EComponent.panda_root_node is not None:
self.geom_path = EComponent.panda_root_node.attach_new_node(
geom_node)
self.geom_path.set_shader_input("object_id", self.object_id)
# Set shader
if has_weights and self.geom_path is not None:
self.geom_path.setTag("shader type", "skinned")
bone_mats = PTA_LMatrix4f()
for _ in range(100):
bone_mats.push_back(helper.np_mat4_to_panda(np.identity(4)))
self.geom_path.set_shader_input(f"boneMats", bone_mats)
# Disable culling
self.geom_path.node().setBounds(OmniBoundingVolume())
self.geom_path.node().setFinal(True)
def generateNode(self):
self.destroy()
self.node = NodePath('gameobjectnode')
self.node.setTwoSided(True)
self.node.reparentTo(self.parent.node)
if self.properties['avoidable'] == True:
self.node.setTag("avoidable", 'true')
else:
self.node.setTag("avoidable", 'false')
#setting scripting part
self.node.setTag("onWalked", self.onWalked)
self.node.setTag("onPicked", self.onPicked)
#set unique id
self.node.setTag("id", self.properties['id'])
tex = loader.loadTexture(
resourceManager.getResource(self.properties['url']) + '.png')
tex.setWrapV(Texture.WM_clamp)
tex.setWrapU(Texture.WM_clamp)
#this is true pixel art
#change to FTLinear for linear interpolation between pixel colors
tex.setMagfilter(Texture.FTNearest)
tex.setMinfilter(Texture.FTNearest)
xorig = tex.getOrigFileXSize() / self.baseDimension
yorig = tex.getOrigFileYSize() / self.baseDimension
xscaled = (tex.getOrigFileXSize() /
self.baseDimension) * self.properties['scale']
yscaled = (tex.getOrigFileYSize() /
self.baseDimension) * self.properties['scale']
self.node.setTag("xscaled", str(xscaled))
self.node.setTag("yscaled", str(yscaled))
cm = CardMaker("tileobject")
cm.setFrame(0, xorig, 0, yorig)
ts = TextureStage('ts')
ts.setMode(TextureStage.MDecal)
# distinguish between 3d collisions (for objects with an height and sensible self.properties['inclination'])
# and 2d collisions for plain sprites
if self.properties['walkable'] == 'false':
if self.properties['collisionmode'] == "3d":
#must handle differently objects which are small and big
if xscaled < 1:
self.collisionTube = CollisionBox(
LPoint3f(
0.5 - xscaled / 2 - self.properties['offsetwidth'],
0, 0),
LPoint3f(
0.5 + xscaled / 2 + self.properties['offsetwidth'],
0.1, 0.3 + self.properties['offsetheight']))
if xscaled >= 1:
self.collisionTube = CollisionBox(
LPoint3f(0 - self.properties['offsetwidth'], 0, 0),
LPoint3f(xscaled + self.properties['offsetwidth'], 0.1,
0.3 + self.properties['offsetheight']))
self.collisionNode = CollisionNode('objectSphere')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(
self.collisionNode)
self.collisionNodeNp.setX(self.properties['offsethorizontal'])
self.collisionNodeNp.setZ(self.properties['offsetvertical'])
self.collisionNodeNp.setX(self.collisionNodeNp.getX() +
self.properties['offsetcollisionh'])
self.collisionNodeNp.setZ(self.collisionNodeNp.getZ() +
self.properties['offsetcollisionv'] +
0.1)
if main.editormode:
self.collisionNodeNp.show()
elif self.properties['collisionmode'] == "2d":
#must handle differently objects which are small and big
if xscaled < 1:
self.collisionTube = CollisionBox(
LPoint3f(
0.5 - xscaled / 2 - self.properties['offsetwidth'],
0, 0),
LPoint3f(
0.5 + xscaled / 2 + self.properties['offsetwidth'],
yscaled + self.properties['offsetheight'], 0.3))
if xscaled >= 1:
self.collisionTube = CollisionBox(
LPoint3f(0 - self.properties['offsetwidth'], 0, 0),
LPoint3f(xscaled + self.properties['offsetwidth'],
yscaled + self.properties['offsetheight'],
0.3))
self.collisionNode = CollisionNode('objectSphere')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(
self.collisionNode)
self.collisionNodeNp.setP(
-(270 - int(self.properties['inclination'])))
self.collisionNodeNp.setX(self.properties['offsethorizontal'])
self.collisionNodeNp.setZ(self.properties['offsetvertical'])
self.collisionNodeNp.setX(self.collisionNodeNp.getX() +
self.properties['offsetcollisionh'])
self.collisionNodeNp.setZ(self.collisionNodeNp.getZ() +
self.properties['offsetcollisionv'] +
0.1)
if main.editormode:
self.collisionNodeNp.show()
geomnode = NodePath(cm.generate())
if geomnode.node().isGeomNode():
vdata = geomnode.node().modifyGeom(0).modifyVertexData()
writer = GeomVertexWriter(vdata, 'vertex')
reader = GeomVertexReader(vdata, 'vertex')
'''
this part apply rotation flattening to the perspective view
by modifying directly structure vertices
'''
i = 0 #counter
while not reader.isAtEnd():
v = reader.getData3f()
x = v[0]
y = v[1]
z = v[2]
newx = x
newy = y
newz = z
if self.properties['rotation'] == -90.0:
if i == 0:
newx = math.fabs(
math.cos(
math.radians(
self.properties['inclination']))) * z
newz = 0
ssen = math.fabs(
math.sin(
math.radians(
self.properties['inclination']))) * z
sparsen = math.fabs(
math.sin(
math.radians(
self.properties['inclination']))) * ssen
spercos = math.fabs(
math.cos(
math.radians(
self.properties['inclination']))) * ssen
newy -= spercos
newz += sparsen
if i == 2:
newx += math.fabs(
math.cos(
math.radians(
self.properties['inclination']))) * z
newz = 0
ssen = math.fabs(
math.sin(
math.radians(
self.properties['inclination']))) * z
sparsen = math.fabs(
math.sin(
math.radians(
self.properties['inclination']))) * ssen
spercos = math.fabs(
math.cos(
math.radians(
self.properties['inclination']))) * ssen
newy -= spercos
newz += sparsen
writer.setData3f(newx, newy, newz)
i += 1 #increase vertex counter
if xscaled >= 1:
geomnode.setX(0)
if xscaled < 1:
geomnode.setX(0.5 - xscaled / 2)
geomnode.setScale(self.properties['scale'])
geomnode.setX(geomnode.getX() + self.properties['offsethorizontal'])
geomnode.setZ(geomnode.getZ() + self.properties['offsetvertical'])
geomnode.setY(-self.properties['elevation'])
geomnode.setP(int(self.properties['inclination']) - 360)
geomnode.setTexture(tex)
geomnode.setTransparency(TransparencyAttrib.MAlpha)
geomnode.reparentTo(self.node)
self.node.setR(self.properties['rotation'])
def makeSquare(x1, y1, z1, x2, y2, z2):
format = GeomVertexFormat.getV3n3cpt2()
vdata = GeomVertexData('square', format, Geom.UHDynamic)
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(myNormalize(Vec3(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1)))
normal.addData3f(myNormalize(Vec3(2 * x2 - 1, 2 * y1 - 1, 2 * z1 - 1)))
normal.addData3f(myNormalize(Vec3(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1)))
normal.addData3f(myNormalize(Vec3(2 * x1 - 1, 2 * y2 - 1, 2 * z2 - 1)))
else:
vertex.addData3f(x1, y1, z1)
vertex.addData3f(x2, y2, z1)
vertex.addData3f(x2, y2, z2)
vertex.addData3f(x1, y1, z2)
normal.addData3f(myNormalize(Vec3(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1)))
normal.addData3f(myNormalize(Vec3(2 * x2 - 1, 2 * y2 - 1, 2 * z1 - 1)))
normal.addData3f(myNormalize(Vec3(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1)))
normal.addData3f(myNormalize(Vec3(2 * x1 - 1, 2 * y1 - 1, 2 * z2 - 1)))
#adding different colors to the vertex for visibility
color.addData4f(1.0, 0.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(1.0, 0.0, 1.0, 1.0)
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.UHDynamic)
tri2 = GeomTriangles(Geom.UHDynamic)
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)
return square
def makeMountains():
format = GeomVertexFormat.getV3t2()
vdata = GeomVertexData('mountains', format, Geom.UHStatic)
vertex = GeomVertexWriter(vdata, 'vertex')
texcoord = GeomVertexWriter(vdata, 'texcoord')
format2 = GeomVertexFormat.getV3c4()
vdata2 = GeomVertexData('sky', format2, Geom.UHStatic)
vertex2 = GeomVertexWriter(vdata2, 'vertex')
color2 = GeomVertexWriter(vdata2, 'color')
numQuads = 32
angle = 0
textureX = 0
angleAdd = math.pi * 2 / numQuads
textureXAdd = 1.0 / numQuads
currentQuad = 0
numVertices = 0
while currentQuad < numQuads:
if currentQuad == 0:
vertexX = math.sin(angle) * 3000
vertexY = math.cos(angle) * 3000
vertex.addData3f(vertexX, vertexY, 0.0)
vertex.addData3f(vertexX, vertexY, 360.0)
texcoord.addData2f(1.0, 0.0)
texcoord.addData2f(1.0, 1.0)
numVertices = numVertices + 2
vertexX = math.sin(angle) * 3000
vertexY = math.cos(angle) * 3000
vertex.addData3f(vertexX, vertexY, 0.0)
vertex.addData3f(vertexX, vertexY, 360.0)
vertex2.addData3f(vertexX, vertexY, 360.0)
color2.addData4f(45.0 / 255.0, 112.0 / 255.0, 255.0 / 255.0, 1.0)
#color2.addData4f(1.0,1.0,1.0,1.0)
#print('created vertex at '+str(vertexX)+','+str(vertexY)+',2')
#print('created vertex at '+str(vertexX)+','+str(vertexY)+',0')
texcoord.addData2f(textureX, 0.0)
texcoord.addData2f(textureX, 1.0)
#print('texturex is '+str(textureX))
#print('creating vertices v'+str(numVertices)+' and v'+str(numVertices+1))
numVertices = numVertices + 2
currentQuad = currentQuad + 1
textureX = textureX + textureXAdd
angle = angle + angleAdd
vertex2.addData3f(0.0, 0.0, 360.0)
#color2.addData4f(1.0,1.0,1.0,1.0)
color2.addData4f(45.0 / 255.0, 112.0 / 255.0, 255.0 / 255.0, 1.0)
currentQuad = 0
currentOffset = 2
tris = GeomTriangles(Geom.UHDynamic)
#print('creating tris - numVertices is '+str(numVertices))
while currentQuad < numQuads:
vertexOffsets = []
for innerIndex in range(4):
offset = currentOffset + innerIndex
#print('comparing '+str(offset)+' with '+str(numVertices-1))
if offset > numVertices - 1:
offset = offset - numVertices
vertexOffsets.append(offset)
#print('adding tri connecting v'+str(vertexOffsets[0])+', v'+str(vertexOffsets[1])+', v'+str(vertexOffsets[3]))
#print('adding tri connecting v'+str(vertexOffsets[1])+', v'+str(vertexOffsets[3])+', v'+str(vertexOffsets[2]))
tris.addVertex(vertexOffsets[0])
tris.addVertex(vertexOffsets[2])
tris.addVertex(vertexOffsets[1])
tris.closePrimitive()
tris.addVertex(vertexOffsets[1])
tris.addVertex(vertexOffsets[2])
tris.addVertex(vertexOffsets[3])
tris.closePrimitive()
currentOffset = currentOffset + 2
currentQuad = currentQuad + 1
tris2 = GeomTriangles(Geom.UHDynamic)
currentOffset = 1
numTris = numQuads
currentTri = 0
while currentTri < numTris:
tris2.addVertex(numTris)
tris2.addVertex(currentTri)
if currentTri == numTris - 1:
tris2.addVertex(0)
else:
tris2.addVertex(currentTri + 1)
tris2.closePrimitive()
currentTri = currentTri + 1
mountains = Geom(vdata)
mountains.addPrimitive(tris)
sky = Geom(vdata2)
sky.addPrimitive(tris2)
snode = GeomNode('mountains')
snode.addGeom(mountains)
snode2 = GeomNode('sky')
snode2.addGeom(sky)
returnValues = {"mountains": snode, "sky": snode2}
return returnValues
def __init__(self, vdata):
self.count = 0
self.vertex = GeomVertexWriter(vdata, 'vertex')
self.normal = GeomVertexWriter(vdata, 'normal')
self.color = GeomVertexWriter(vdata, 'color')
self.texcoord = GeomVertexWriter(vdata, 'texcoord')
def __init__(self,
x_extend=None,
y_extend=None,
x_size=1,
y_size=1,
z=-0.01,
tickness=1.,
name='Grid',
x_color=None,
y_color=None):
GeomNode.__init__(self, name)
if x_color is None:
x_color = LVector4f(1.0, 1.0, 1.0, 1.0)
if y_color is None:
y_color = LVector4f(1.0, 1.0, 1.0, 1.0)
if x_extend is None:
x_extend = [0, 10]
if y_extend is None:
y_extend = [0, 10]
self.vertexData = GeomVertexData("Chunk", GeomVertexFormat.getV3c4(),
Geom.UHStatic)
self.vertex = GeomVertexWriter(self.vertexData, 'vertex')
self.color = GeomVertexWriter(self.vertexData, 'color')
self.mesh = Geom(self.vertexData)
self.lines = GeomLines(Geom.UHStatic)
nb_lines_x = int((x_extend[1] - x_extend[0]) / x_size)
nb_lines_y = int((y_extend[1] - y_extend[0]) / y_size)
vertex_nb = 0
for ix in range(nb_lines_x):
for iy in range(nb_lines_y):
x = x_extend[0] + ix * x_size
y = y_extend[0] + iy * y_size
self.vertex.addData3f(x, y, z)
self.color.addData4f(x_color)
self.vertex.addData3f(x + x_size, y, z)
self.color.addData4f(x_color)
self.vertex.addData3f(x, y, z)
self.color.addData4f(y_color)
self.vertex.addData3f(x, y + y_size, z)
self.color.addData4f(y_color)
self.lines.add_vertices(vertex_nb, vertex_nb + 1,
vertex_nb + 2, vertex_nb + 3)
vertex_nb += 4
self.lines.closePrimitive()
self.mesh.addPrimitive(self.lines)
self.addGeom(self.mesh)
NodePath(self).setRenderModeThickness(tickness)
NodePath(self).setLightOff()
NodePath(self).setColorOff()
NodePath(self).set_bin('fixed', 8)
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=LMatrix4.rotateMat(45, axis)*LMatrix4.scaleMat(radius)*LMatrix4.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)
def __init__(self):
ShowBase.__init__(self)
self.cols = 100
self.rows = 100
base.disableMouse()
base.setFrameRateMeter(True)
self.cameraHeight = 13
self.camera.set_pos(self.cols / 2, -30, self.cameraHeight)
self.camera.look_at(self.cols / 2, 300, 0)
plights = []
for i in range(0, int(self.cols / 5), 2):
plight = PointLight("plight")
plight.setColor(VBase4(1, 1, 1, 1))
plights.append(plight)
plights[i] = self.render.attachNewNode(plight)
x, y, z = self.camera.get_pos()
plights[i].setPos(self.cols / 2 + ((i - int(i / 2)) * 10), y + 20,
5)
self.render.set_light(plights[i])
plight = PointLight("plight")
plight.setColor(VBase4(1, 1, 1, 1))
plights.append(plight)
plights[i + 1] = self.render.attachNewNode(plight)
x, y, z = self.camera.get_pos()
plights[i + 1].setPos(self.cols / 2 + ((i - int(i / 2)) * 10),
y + 20, 10)
self.render.set_light(plights[i + 1])
self.plights = plights
format = GeomVertexFormat.getV3c4()
vdata = GeomVertexData('name', format, Geom.UHStatic)
vdata.setNumRows(self.cols * self.rows)
self.vertex = GeomVertexWriter(vdata, 'vertex')
self.color = GeomVertexWriter(vdata, 'color')
pz = [random.uniform(-1, 1)]
for i in range(self.rows):
pz.append(random.uniform(pz[i - 1] - 1, pz[i] + 1))
for y in range(0, self.rows):
for x in range(0, self.cols):
nz1 = random.uniform(pz[x] - 1, pz[x] + 1)
nz2 = random.uniform(pz[x - 1] - 1, pz[x - 1] + 1)
nz3 = random.uniform(pz[x + 1] - 1, pz[x + 1] + 1)
nz = (nz1 + nz2 + nz3) / 3
self.vertex.add_data3f((x, y + 1, nz))
self.vertex.add_data3f((x, y, pz[x]))
if nz < -5:
self.color.add_data4f(0.2, 0.1, 0, 1)
elif nz < -3:
self.color.add_data4f(0, 0.2, 0.1, 1)
elif nz < 0:
self.color.add_data4f(0, 0.4, 0.2, 1)
elif nz < 2:
self.color.add_data4f(0.4, 0.4, 0.4, 1)
else:
self.color.add_data4f(1, 1, 1, 1)
if nz < -5:
self.color.add_data4f(0.2, 0.1, 0, 1)
elif nz < -3:
self.color.add_data4f(0, 0.2, 0.1, 1)
elif pz[x] < 0:
self.color.add_data4f(0, 0.4, 0.2, 1)
elif pz[x] < 2:
self.color.add_data4f(0.4, 0.4, 0.4, 1)
else:
self.color.add_data4f(1, 1, 1, 1)
pz[x] = nz
#print (nz)
self.pz = pz
geom = Geom(vdata)
for y in range(0, self.rows):
prim = GeomTristrips(Geom.UH_static)
prim.addVertex(y * self.cols * 2)
prim.add_next_vertices((self.cols * 2) - 1)
prim.close_primitive()
geom.addPrimitive(prim)
nodeTris = GeomNode("TriStrips")
nodeTris.addGeom(geom)
self.nodeTrisPath = self.render.attachNewNode(nodeTris)
self.task_mgr.add(self.moveForwardTask, "moveForwardTask")
self.vdata = vdata
self.newNodePath = []
self.counter = 0
self.rows1 = self.rows
skybox = self.loader.loadModel("models/skybox.bam")
skybox.reparent_to(self.render)
skybox.set_scale(20000)
skybox_texture = self.loader.loadTexture("textures/dayfair.jpg")
skybox_texture.set_minfilter(SamplerState.FT_linear)
skybox_texture.set_magfilter(SamplerState.FT_linear)
skybox_texture.set_wrap_u(SamplerState.WM_repeat)
skybox_texture.set_wrap_v(SamplerState.WM_mirror)
skybox_texture.set_anisotropic_degree(16)
skybox.set_texture(skybox_texture)
skybox_shader = Shader.load(Shader.SL_GLSL, "skybox.vert.glsl",
"skybox.frag.glsl")
skybox.set_shader(skybox_shader)
def __init__(self):
self.textures = {}
for k in texMap:
v = texMap[k]
tex = loader.loadTexture("gfx/%s" % v)
tex.setWrapU(Texture.WM_clamp)
tex.setWrapV(Texture.WM_clamp)
self.textures[k] = tex
self.viewPoint = (0, 0, 0)
self.cubeVtxSrc = [
# 14 vertices per cube mapped
# so that UV coords utilize
# the typical cube unwrap:
#
# #### <-- square texture
# ##U#
# BLFR
# ##D# #=unused
#
# This form uses 14 vertices per cube since
# the extra (worldspace overlapped) vertices
# map different U,V coordinates at the same
# worldspace coordinates, depending on face
#
# x y z u v
(1.00, 1.00, 1.00, 0.00, 0.50), # A
(1.00, 1.00, 0.00, 0.00, 0.25), # B
(0.00, 1.00, 1.00, 0.25, 0.50), # C
(0.00, 1.00, 0.00, 0.25, 0.25), # D
(0.00, 0.00, 1.00, 0.50, 0.50), # E
(0.00, 0.00, 0.00, 0.50, 0.25), # F
(1.00, 0.00, 1.00, 0.75, 0.50), # G
(1.00, 0.00, 0.00, 0.75, 0.25), # H
(1.00, 1.00, 1.00, 1.00, 0.50), # I
(1.00, 1.00, 0.00, 1.00, 0.25), # J
(0.00, 1.00, 1.00, 0.50, 0.75), # K
(1.00, 1.00, 1.00, 0.75, 0.75), # L
(0.00, 1.00, 0.00, 0.50, 0.00), # M
(1.00, 1.00, 0.00, 0.75, 0.00) # N
]
self.triSrc = [
#
# Faces (QUAD/TRIPAIR)
# using RHR vertex ordering for
# correct face surface normals
#
# front: EFHG/EFH+HGE
# rear: CABD/CAB+BDC
# left: CDFE/CDF+FEC
# right: GHJI/GHJ+JIG
# upper: KEGL/KEG+GLK
# lower: FMNH/FMN+NHF
#
"EFH",
"HGE",
"CAB",
"BDC",
"CDF",
"FEC",
"GHJ",
"JIG",
"KEG",
"GLK",
"FMN",
"NHF"
]
#
# setup cube
#
# one cube node will be generated per non-air block
# since different block id's potentially refer to
# different textures and thus must be separate nodes
# of the scene graph.
#
# 1. vertices
self.cubeVtx = GeomVertexData('blockCube', GeomVertexFormat.getV3t2(),
Geom.UHStatic)
self.cubeVtx.setNumRows(len(self.cubeVtxSrc))
vtxW = GeomVertexWriter(self.cubeVtx, 'vertex')
txcW = GeomVertexWriter(self.cubeVtx, 'texcoord')
for vertex in self.cubeVtxSrc:
vtxW.addData3f(*vertex[0:3])
txcW.addData2f(*vertex[3:5])
# 2. mesh
self.cubeMesh = GeomTriangles(Geom.UHStatic)
for tri in self.triSrc:
for triV in tri:
triVtxId = ord(triV) - 65 # changea 'A'-'N' to 0-13
self.cubeMesh.addVertex(triVtxId)
self.cubeMesh.close_primitive()
# 3. geometry (primitive+vertex pair)
self.cubeGeom = Geom(self.cubeVtx)
self.cubeGeom.addPrimitive(self.cubeMesh)
def create_instance(self):
self.vertexData = GeomVertexData('vertexData',
GeomVertexFormat.getV3c4(),
Geom.UHStatic)
self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
self.colorwriter = GeomVertexWriter(self.vertexData, 'color')
for r in range(1, self.nbOfRings + 1):
for i in range(self.nbOfPoints):
angle = 2 * pi / self.nbOfPoints * i
x = cos(angle) * sin(pi * r / (self.nbOfRings + 1))
y = sin(angle) * sin(pi * r / (self.nbOfRings + 1))
z = sin(-pi / 2 + pi * r / (self.nbOfRings + 1))
self.vertexWriter.addData3f(
(self.context.observer.infinity * x,
self.context.observer.infinity * y,
self.context.observer.infinity * z))
if r == self.nbOfRings / 2 + 1:
self.colorwriter.addData4f(self.color.x * 1.5, 0, 0, 1)
else:
self.colorwriter.addData4f(*self.color)
for s in range(self.nbOfSectors):
for i in range(self.points_to_remove,
self.nbOfPoints // 2 - self.points_to_remove + 1):
angle = 2 * pi / self.nbOfPoints * i
x = cos(2 * pi * s / self.nbOfSectors) * sin(angle)
y = sin(2 * pi * s / self.nbOfSectors) * sin(angle)
z = cos(angle)
self.vertexWriter.addData3f(
(self.context.observer.infinity * x,
self.context.observer.infinity * y,
self.context.observer.infinity * z))
if s == 0:
self.colorwriter.addData4f(self.color.x * 1.5, 0, 0, 1)
else:
self.colorwriter.addData4f(*self.color)
self.lines = GeomLines(Geom.UHStatic)
index = 0
for r in range(self.nbOfRings):
for i in range(self.nbOfPoints - 1):
self.lines.addVertex(index)
self.lines.addVertex(index + 1)
self.lines.closePrimitive()
index += 1
self.lines.addVertex(index)
self.lines.addVertex(index - self.nbOfPoints + 1)
self.lines.closePrimitive()
index += 1
for r in range(self.nbOfSectors):
for i in range(self.nbOfPoints // 2 - self.points_to_remove * 2):
self.lines.addVertex(index)
self.lines.addVertex(index + 1)
self.lines.closePrimitive()
index += 1
index += 1
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.lines)
self.node = GeomNode("grid")
self.node.addGeom(self.geom)
self.instance = NodePath(self.node)
self.instance.setRenderModeThickness(settings.grid_thickness)
#myMaterial = Material()
#myMaterial.setEmission((1.0, 1.0, 1.0, 1))
#self.instance.setMaterial(myMaterial)
self.instance.reparentTo(self.context.annotation)
self.instance.setQuat(LQuaternion(*self.orientation))
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)
def interpolate_maps(self, task):
# First, the actual interpolation
t_index = self.last_time
current_map = {}
for x in range(0, self.sidelength):
for y in range(0, self.sidelength):
# calculate vertices
p_1 = self.map_a[(x, y)]
p_2 = self.map_b[(x, y)]
v_x = p_1[0]*(1.0-t_index) + p_2[0]*t_index
v_y = p_1[1]*(1.0-t_index) + p_2[1]*t_index
v_z = p_1[2]*(1.0-t_index) + p_2[2]*t_index
current_map[(x, y)] = (v_x, v_y, v_z)
# Set up the writers
vertex = GeomVertexWriter(self.vdata, 'vertex')
normal = GeomVertexWriter(self.vdata, 'normal')
# We don't use vertex readers as we don't care about the
# current state, but if we did, it'd look like this:
# vertex_reader = GeomVertexReader(self.vdata, 'vertex')
# v = vertex_reader.getData3f()
# Remember that all vertex readers working on a
# GeomVertexData have to be created *after* the writers
# working on it (due to engine internals; see the manual).
for x in range(0, self.sidelength):
for y in range(0, self.sidelength):
v_x, v_y, v_z = current_map[(x, y)]
vertex.setData3f(v_x, v_y, v_z)
# Calculate the normal
if x==0 and y==0:
s_0 = Vec3( 0.0, 1.0, v_z - current_map[(x, y+1)][2])
s_1 = Vec3( 1.0, 0.0, v_z - current_map[(x+1, y)][2])
e_0 = s_0.cross(s_1)
# Flip if necessary, then normalize
if e_0[2] < 0.0:
e_0 = e_0*-1.0
n = e_0
n = n/n.length()
elif x==0 and y==(self.sidelength-1):
# First, we calculate the vectors to the neighbors.
s_1 = Vec3( 1.0, 0.0, v_z - current_map[(x+1, y)][2])
s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
e_1 = s_1.cross(s_2)
# Flip if necessary, then normalize
if e_1[2] < 0.0:
e_1 = e_1*-1.0
n = e_1
n = n/n.length()
elif x==(self.sidelength-1) and y==0:
# First, we calculate the vectors to the neighbors.
s_0 = Vec3( 0.0, 1.0, v_z - current_map[(x, y+1)][2])
s_3 = Vec3(-1.0, 0.0, v_z - current_map[(x-1, y)][2])
e_3 = s_3.cross(s_0)
# Flip if necessary, then normalize
if e_3[2] < 0.0:
e_3 = e_3*-1.0
n = e_3
n = n/n.length()
elif x==(self.sidelength-1) or y==(self.sidelength-1):
# First, we calculate the vectors to the neighbors.
s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
s_3 = Vec3(-1.0, 0.0, v_z - current_map[(x-1, y)][2])
e_2 = s_2.cross(s_3)
# Flip if necessary, then normalize
if e_2[2] < 0.0:
e_2 = e_2*-1.0
n = e_2
n = n/n.length()
elif x==0:
# First, we calculate the vectors to the neighbors.
s_0 = Vec3( 0.0, 1.0, v_z - current_map[(x, y+1)][2])
s_1 = Vec3( 1.0, 0.0, v_z - current_map[(x+1, y)][2])
s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
e_0 = s_0.cross(s_1)
e_1 = s_1.cross(s_2)
# Flip if necessary, then normalize
if e_0[2] < 0.0:
e_0 = e_0*-1.0
if e_1[2] < 0.0:
e_1 = e_1*-1.0
n = e_0 + e_1
n = n/n.length()
elif y==0:
# First, we calculate the vectors to the neighbors.
s_0 = Vec3( 0.0, 1.0, v_z - current_map[(x, y+1)][2])
s_1 = Vec3( 1.0, 0.0, v_z - current_map[(x+1, y)][2])
s_3 = Vec3(-1.0, 0.0, v_z - current_map[(x-1, y)][2])
e_0 = s_0.cross(s_1)
e_3 = s_3.cross(s_0)
# Flip if necessary, then normalize
if e_0[2] < 0.0:
e_0 = e_0*-1.0
if e_3[2] < 0.0:
e_3 = e_3*-1.0
n = e_0 + e_3
n = n/n.length()
elif x==(self.sidelength-1):
# First, we calculate the vectors to the neighbors.
s_1 = Vec3( 1.0, 0.0, v_z - current_map[(x+1, y)][2])
s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
s_3 = Vec3(-1.0, 0.0, v_z - current_map[(x-1, y)][2])
e_1 = s_1.cross(s_2)
e_2 = s_2.cross(s_3)
# Flip if necessary, then normalize
if e_1[2] < 0.0:
e_1 = e_1*-1.0
if e_2[2] < 0.0:
e_2 = e_2*-1.0
n = e_1 + e_2
n = n/n.length()
elif y==(self.sidelength-1):
# First, we calculate the vectors to the neighbors.
s_1 = Vec3( 1.0, 0.0, v_z - current_map[(x+1, y)][2])
s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
s_3 = Vec3(-1.0, 0.0, v_z - current_map[(x-1, y)][2])
e_1 = s_1.cross(s_2)
e_2 = s_2.cross(s_3)
# Flip if necessary, then normalize
if e_1[2] < 0.0:
e_1 = e_1*-1.0
if e_2[2] < 0.0:
e_2 = e_2*-1.0
n = e_1 + e_2
n = n/n.length()
else: # This is a normal case, not an edge or corner.
# First, we calculate the vectors to the neighbors.
s_0 = Vec3( 0.0, 1.0, v_z - current_map[(x, y+1)][2])
s_1 = Vec3( 1.0, 0.0, v_z - current_map[(x+1, y)][2])
s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
s_3 = Vec3(-1.0, 0.0, v_z - current_map[(x-1, y)][2])
e_0 = s_0.cross(s_1)
e_1 = s_1.cross(s_2)
e_2 = s_2.cross(s_3)
e_3 = s_3.cross(s_0)
# Flip if necessary, then normalize
if e_0[2] < 0.0:
e_0 = e_0*-1.0
if e_1[2] < 0.0:
e_1 = e_1*-1.0
if e_2[2] < 0.0:
e_2 = e_2*-1.0
if e_3[2] < 0.0:
e_3 = e_3*-1.0
n = e_0 + e_1 + e_2 + e_3
n = n/n.length()
normal.setData3f(n[0], n[1], n[2])
return Task.cont
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 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)
def makeSquare(
x1, y1, z1, x2, y2, z2, color
): # This is straight copied off the Panda3d 'procedural cube' example https://github.com/panda3d/panda3d/blob/master/samples/procedural-cube/main.py#L11
format = GeomVertexFormat.getV3n3cpt2()
vdata = GeomVertexData('square', format, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
normal = GeomVertexWriter(vdata, 'normal')
color_setter = GeomVertexWriter(vdata, 'color')
texcoord = GeomVertexWriter(vdata, 'texcoord')
# make sure we draw the sqaure in the right plane
if x1 != x2:
vertex.addData3(x1, y1, z1)
vertex.addData3(x2, y1, z1)
vertex.addData3(x2, y2, z2)
vertex.addData3(x1, y2, z2)
normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
normal.addData3(normalized(2 * x2 - 1, 2 * y1 - 1, 2 * z1 - 1))
normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
normal.addData3(normalized(2 * x1 - 1, 2 * y2 - 1, 2 * z2 - 1))
else:
vertex.addData3(x1, y1, z1)
vertex.addData3(x2, y2, z1)
vertex.addData3(x2, y2, z2)
vertex.addData3(x1, y1, z2)
normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z1 - 1))
normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z2 - 1))
# adding different colors to the vertex for visibility
if np.sum(color) > 0:
a = 1 # Alpha transparency
else:
a = 0
# Handling channel size 1 or 3
if np.size(color) == 1:
for i in range(
4
): # Have to run this 4 times cuz each vertex on the square has a color setting
color_setter.addData2f(color, a)
elif np.size(color) == 3:
r, g, b = color[0], color[1], color[2]
for i in range(4):
color_setter.addData4f(r, g, b, 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 aren't directly supported by the Geom interface
# you might be interested in the CardMaker class if you are
# interested in rectangle though
tris = GeomTriangles(Geom.UHDynamic)
tris.addVertices(0, 1, 3)
tris.addVertices(1, 2, 3)
square = Geom(vdata)
square.addPrimitive(tris)
return square
