def __init__(self, base, obj, **kwargs):
super(GalaxyView, self).__init__(base, obj, **kwargs)
array = GeomVertexArrayFormat()
array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32,
Geom.CPoint)
array.addColumn(InternalName.make('color'), 4, Geom.NTFloat32,
Geom.CColor)
array.addColumn(InternalName.make('size'), 1, Geom.NTFloat32,
Geom.COther)
gmformat = GeomVertexFormat()
gmformat.addArray(array)
gmformat = GeomVertexFormat.registerFormat(gmformat)
vdata = GeomVertexData('points', gmformat, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
size = GeomVertexWriter(vdata, 'size')
self.node = NodePath('galaxy')
self.node.reparentTo(self.base.render)
self.node.setTransparency(TransparencyAttrib.MAlpha)
lumsort = sorted([star.luminosity for star in self.obj.stars])
#highest_luminosity = lumsort[-1]
median_luminosity = lumsort[len(lumsort) / 2]
for star in self.obj.stars:
vertex.addData3f(star.galpos.x, star.galpos.y, star.galpos.z)
color.addData4f(star.red, star.green, star.blue, 1.0)
#size.addData1f(min(100, max(5, 10-star.magnitude/2)))
sizeval = 10 + log(star.luminosity)
size.addData1f(min(30, max(10, sizeval)))
prim = GeomPoints(Geom.UHStatic)
prim.addConsecutiveVertices(0, len(self.obj.stars))
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(geom)
galaxy_node = self.node.attachNewNode(node)
galaxy_node.setRenderModeThickness(1)
ts = TextureStage.getDefault() #TextureStage('ts')
#ts.setMode(TextureStage.MGlow)
galaxy_node.setTexGen(ts, TexGenAttrib.MPointSprite)
galaxy_node.setTexture(
ts, self.base.loader.loadTexture('texture/flare.png'))
#galaxy_node.setRenderModePerspective(True)
galaxy_node.setBin("unsorted", 1)
galaxy_node.setDepthWrite(0)
galaxy_node.setTransparency(1)
self.setup_glow_shader()
"""
def update_geom(self, points, colors, sizes):
geom = self.instance.children[0].node().modify_geom(0)
vdata = geom.modify_vertex_data()
vdata.unclean_set_num_rows(len(points))
vwriter = GeomVertexRewriter(vdata, InternalName.get_vertex())
colorwriter = GeomVertexWriter(vdata, InternalName.get_color())
sizewriter = GeomVertexWriter(vdata, InternalName.get_size())
for (point, color, size) in zip(points, colors, sizes):
vwriter.addData3f(*point)
colorwriter.addData4f(*color)
sizewriter.addData1f(size)
class GalaxyShapeBase(Shape):
templates = {}
def __init__(self, radius=1.0, scale=None):
Shape.__init__(self)
self.radius = radius
self.seed = random()
if scale is None:
self.radius = radius
self.scale = LVecBase3(self.radius, self.radius, self.radius)
else:
self.scale = LVecBase3(*scale) * radius
self.radius = max(scale) * radius
self.nb_points = 1
self.size = 1.0
self.yellow_color = srgb_to_linear((255.0 / 255, 248.0 / 255, 231.0 / 255, 1.0))
self.blue_color = srgb_to_linear((102.0 / 255, 153.0 / 255, 255.0 / 255, 1.0))
def shape_id(self):
return ''
def get_apparent_radius(self):
return self.radius
def get_scale(self):
return self.scale / self.size
def is_flat(self):
return False
def create_points(self, radius=1.0):
return None
def apply(self):
self.instance.node().setBounds(OmniBoundingVolume())
self.instance.node().setFinal(True)
def create_instance(self):
shape_id = self.shape_id()
if shape_id in GalaxyShapeBase.templates:
template = GalaxyShapeBase.templates[shape_id]
else:
seed(self.seed)
self.gnode = GeomNode('galaxy')
self.geom = self.makeGeom(*self.create_points())
self.gnode.addGeom(self.geom)
template = NodePath(self.gnode)
# Disable caching
#GalaxyShapeBase.templates[shape_id] = template
self.instance = NodePath('galaxy')
template.instanceTo(self.instance)
self.apply()
self.update_geom(*self.create_points())
return self.instance
def update_shape(self):
seed(self.seed)
self.update_geom(*self.create_points())
def makeGeom(self, points, colors, sizes):
#format = GeomVertexFormat.getV3c4()
array = GeomVertexArrayFormat()
array.addColumn(InternalName.get_vertex(), 3, Geom.NTFloat32, Geom.CPoint)
array.addColumn(InternalName.get_color(), 4, Geom.NTFloat32, Geom.CColor)
array.addColumn(InternalName.get_size(), 1, Geom.NTFloat32, Geom.COther)
format = GeomVertexFormat()
format.addArray(array)
format = GeomVertexFormat.registerFormat(format)
vdata = GeomVertexData('vdata', format, Geom.UH_static)
vdata.unclean_set_num_rows(len(points))
self.vwriter = GeomVertexWriter(vdata, InternalName.get_vertex())
self.colorwriter = GeomVertexWriter(vdata, InternalName.get_color())
self.sizewriter = GeomVertexWriter(vdata, InternalName.get_size())
geompoints = GeomPoints(Geom.UH_static)
geompoints.reserve_num_vertices(len(points))
index = 0
for (point, color, size) in zip(points, colors, sizes):
self.vwriter.addData3f(*point)
self.colorwriter.addData4f(*color)
self.sizewriter.addData1f(size)
geompoints.addVertex(index)
#geompoints.closePrimitive()
index += 1
geom = Geom(vdata)
geom.addPrimitive(geompoints)
return geom
def update_geom(self, points, colors, sizes):
geom = self.instance.children[0].node().modify_geom(0)
vdata = geom.modify_vertex_data()
vdata.unclean_set_num_rows(len(points))
vwriter = GeomVertexRewriter(vdata, InternalName.get_vertex())
colorwriter = GeomVertexWriter(vdata, InternalName.get_color())
sizewriter = GeomVertexWriter(vdata, InternalName.get_size())
for (point, color, size) in zip(points, colors, sizes):
vwriter.addData3f(*point)
colorwriter.addData4f(*color)
sizewriter.addData1f(size)
class Mesh():
def __init__(self, name):
self.name = name
self.poly_groups = []
# GeomVertexFormats
#
# GeomVertexFormat.getV3cpt2() - vertex, color, uv
# GeomVertexFormat.getV3t2() - vertex, uv
# GeomVertexFormat.getV3cp() - vertex, color
# GeomVertexFormat.getV3n3t2() - vertex, normal, uv
# GeomVertexFormat.getV3n3cpt2()- vertex, normal, rgba, uv
# textured
self.vdata = GeomVertexData(name, GeomVertexFormat.getV3n3cpt2(),
Geom.UHStatic)
# plain color filled polys
# self.vdata = GeomVertexData(name, GeomVertexFormat.getV3cp(), Geom.UHStatic)
self.vertex = GeomVertexWriter(self.vdata, 'vertex')
self.vnormal = GeomVertexWriter(self.vdata, 'normal')
self.color = GeomVertexWriter(self.vdata, 'color')
self.texcoord = GeomVertexWriter(self.vdata, 'texcoord')
self.root = NodePath(PandaNode(name + '_mesh'))
# f is a 0x36 mesh fragment (see fragment.py for reference)
def buildFromFragment(self, f, wld_container, debug=False):
# write vertex coordinates
for v in f.vertexList:
self.vertex.addData3f(v[0], v[1], v[2])
# write vertex colors
for rgba in f.vertexColorsList:
'''
r = (rgba & 0xff000000) >> 24
g = (rgba & 0x00ff0000) >> 16
b = (rgba & 0x0000ff00) >> 8
a = (rgba & 0x000000ff)
if a != 0:
print 'vertex color has alpha component, r:0x%x g:0x%x b:0x%x a:0x%x ' % (r, g, b, a)
'''
self.color.addData1f(rgba)
# write vertex normals
for v in f.vertexNormalsList:
self.vnormal.addData3f(v[0], v[1], v[2])
# write texture uv
for uv in f.uvList:
self.texcoord.addData2f(uv[0], uv[1])
# Build PolyGroups
# each polyTexList is a tuple containing a polygon count and the texture index for those polys
# we create a PolyGroup for each of these
# the PolyGroup creates all Polygons sharing a texture and adds them under a NodePath
poly_idx = 0
for pt in f.polyTexList:
n_polys = pt[0]
tex_idx = pt[1]
if debug:
print(" Bulding a poly group with tex_id " + str(tex_idx))
pg = PolyGroup(self.vdata, tex_idx)
# pass fragment so that it can access the SPRITES
if pg.build(wld_container, f, poly_idx, n_polys, tex_idx,
debug) == 1:
self.poly_groups.append(pg)
pg.nodePath.reparentTo(self.root)
poly_idx += n_polys
if poly_idx != f.polyCount or poly_idx != len(f.polyList):
print 'ERROR: polycount mismatch'
class Mesh():
def __init__(self, name):
self.name = name
self.poly_groups = []
# GeomVertexFormats
#
# GeomVertexFormat.getV3cpt2() - vertex, color, uv
# GeomVertexFormat.getV3t2() - vertex, uv
# GeomVertexFormat.getV3cp() - vertex, color
# GeomVertexFormat.getV3n3t2() - vertex, normal, uv
# GeomVertexFormat.getV3n3cpt2()- vertex, normal, rgba, uv
# textured
self.vdata = GeomVertexData(name, GeomVertexFormat.getV3n3cpt2(), Geom.UHStatic)
# plain color filled polys
# self.vdata = GeomVertexData(name, GeomVertexFormat.getV3cp(), Geom.UHStatic)
self.vertex = GeomVertexWriter(self.vdata, 'vertex')
self.vnormal = GeomVertexWriter(self.vdata, 'normal')
self.color = GeomVertexWriter(self.vdata, 'color')
self.texcoord = GeomVertexWriter(self.vdata, 'texcoord')
self.root = NodePath(PandaNode(name+'_mesh'))
# f is a 0x36 mesh fragment (see fragment.py for reference)
def buildFromFragment(self, f, wld_container,debug=False):
# write vertex coordinates
for v in f.vertexList:
self.vertex.addData3f(v[0], v[1], v[2])
# write vertex colors
for rgba in f.vertexColorsList:
'''
r = (rgba & 0xff000000) >> 24
g = (rgba & 0x00ff0000) >> 16
b = (rgba & 0x0000ff00) >> 8
a = (rgba & 0x000000ff)
if a != 0:
print 'vertex color has alpha component, r:0x%x g:0x%x b:0x%x a:0x%x ' % (r, g, b, a)
'''
self.color.addData1f(rgba)
# write vertex normals
for v in f.vertexNormalsList:
self.vnormal.addData3f(v[0], v[1], v[2])
# write texture uv
for uv in f.uvList:
self.texcoord.addData2f(uv[0], uv[1])
# Build PolyGroups
# each polyTexList is a tuple containing a polygon count and the texture index for those polys
# we create a PolyGroup for each of these
# the PolyGroup creates all Polygons sharing a texture and adds them under a NodePath
poly_idx = 0
for pt in f.polyTexList:
n_polys = pt[0]
tex_idx = pt[1]
if debug:
print(" Bulding a poly group with tex_id " + str(tex_idx))
pg = PolyGroup(self.vdata, tex_idx)
# pass fragment so that it can access the SPRITES
if pg.build(wld_container, f, poly_idx, n_polys, tex_idx, debug) == 1:
self.poly_groups.append(pg)
pg.nodePath.reparentTo(self.root)
poly_idx += n_polys
if poly_idx != f.polyCount or poly_idx != len(f.polyList):
print 'ERROR: polycount mismatch'
class PointsSet(VisibleObject):
tex = None
def __init__(self,
use_sprites=True,
use_sizes=True,
points_size=2,
sprite=None,
background=None,
shader=None):
self.gnode = GeomNode('starfield')
self.use_sprites = use_sprites
self.use_sizes = use_sizes
self.background = background
if shader is None:
shader = BasicShader(lighting_model=FlatLightingModel(),
point_shader=False)
self.shader = shader
self.reset()
self.geom = self.makeGeom([], [], [])
self.gnode.addGeom(self.geom)
self.instance = NodePath(self.gnode)
if self.use_sprites:
if sprite is None:
sprite = RoundDiskPointSprite()
self.sprite = sprite
else:
self.sprite = SimplePoint(points_size)
self.min_size = self.sprite.get_min_size()
self.sprite.apply(self.instance)
self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
self.instance.node().setPythonTag('owner', self)
#TODO: Should not use ModelAppearance !
self.appearance = ModelAppearance(vertex_color=True)
if self.appearance is not None:
self.appearance.bake()
self.appearance.apply(self, self)
if self.shader is not None:
self.shader.apply(self, self.appearance)
if self.use_sprites:
self.instance.node().setBounds(OmniBoundingVolume())
self.instance.node().setFinal(True)
if self.background is not None:
self.instance.setBin('background', self.background)
self.instance.set_depth_write(False)
def jobs_done_cb(self, patch):
pass
def reset(self):
self.points = []
self.colors = []
self.sizes = []
def add_point_scale(self, position, color, size):
#Observer is at position (0, 0, 0)
distance_to_obs = position.length()
vector_to_obs = -position / distance_to_obs
point, _, _ = self.get_real_pos_rel(position, distance_to_obs,
vector_to_obs)
self.points.append(point)
self.colors.append(color)
self.sizes.append(size)
def add_point(self, position, color, size):
self.points.append(position)
self.colors.append(color)
self.sizes.append(size)
def update(self):
self.update_arrays(self.points, self.colors, self.sizes)
def makeGeom(self, points, colors, sizes):
#format = GeomVertexFormat.getV3c4()
array = GeomVertexArrayFormat()
array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32,
Geom.CPoint)
array.addColumn(InternalName.make('color'), 4, Geom.NTFloat32,
Geom.CColor)
if self.use_sizes:
array.addColumn(InternalName.make('size'), 1, Geom.NTFloat32,
Geom.COther)
format = GeomVertexFormat()
format.addArray(array)
format = GeomVertexFormat.registerFormat(format)
vdata = GeomVertexData('vdata', format, Geom.UH_static)
vdata.unclean_set_num_rows(len(points))
self.vwriter = GeomVertexWriter(vdata, 'vertex')
self.colorwriter = GeomVertexWriter(vdata, 'color')
if self.use_sizes:
self.sizewriter = GeomVertexWriter(vdata, 'size')
geompoints = GeomPoints(Geom.UH_static)
geompoints.reserve_num_vertices(len(points))
index = 0
for (point, color, size) in zip(points, colors, sizes):
self.vwriter.addData3f(*point)
#self.colorwriter.addData3f(color[0], color[1], color[2])
self.colorwriter.addData4f(*color)
if self.use_sizes:
self.sizewriter.addData1f(size)
geompoints.addVertex(index)
geompoints.closePrimitive()
index += 1
geom = Geom(vdata)
geom.addPrimitive(geompoints)
return geom
def update_arrays(self, points, colors, sizes):
self.gnode.removeAllGeoms()
self.geom = self.makeGeom(points, colors, sizes)
self.gnode.addGeom(self.geom)
