def __pack_data(self):
# Pack points,normals and texcoords into tuples and convert to ctype floats.
n_verts = len(self.vertices)
if len(self.tex_coords) != n_verts:
if len(self.normals) != n_verts:
self.N_BYTES = 12 # only use pts
self.array_buffer = c_floats(self.vertices.reshape(-1).tolist())
else:
self.N_BYTES = 24 # use pts and normals
self.array_buffer = c_floats(np.concatenate((self.vertices, self.normals),
axis=1).reshape(-1).tolist())
else:
self.N_BYTES = 32 # use all three NB doesn't check that normals are there
self.array_buffer = c_floats(np.concatenate((self.vertices, self.normals, self.tex_coords),
axis=1).reshape(-1).tolist())
self.ntris = len(self.indices)
self.element_array_buffer = c_shorts(self.indices.reshape(-1))
from pi3d.Display import Display
self.disp = Display.INSTANCE # rely on there always being one!
def __pack_data(self):
# Pack points,normals and texcoords into tuples and convert to ctype floats.
n_verts = len(self.vertices)
if len(self.tex_coords) != n_verts:
if len(self.normals) != n_verts:
self.N_BYTES = 12 # only use pts
self.array_buffer = c_floats(
self.vertices.reshape(-1).tolist())
else:
self.N_BYTES = 24 # use pts and normals
self.array_buffer = c_floats(
np.concatenate((self.vertices, self.normals),
axis=1).reshape(-1).tolist())
else:
self.N_BYTES = 32 # use all three NB doesn't check that normals are there
self.array_buffer = c_floats(
np.concatenate((self.vertices, self.normals, self.tex_coords),
axis=1).reshape(-1).tolist())
self.ntris = len(self.indices)
self.element_array_buffer = c_shorts(self.indices.reshape(-1))
from pi3d.Display import Display
self.disp = Display.INSTANCE # rely on there always being one!
def __init__(self, shape, pts, texcoords, faces, normals=None, smooth=True):
"""Generate a vertex buffer to hold data and indices. If no normals
are provided then these are generated.
Arguments:
*shape*
Shape object that this Buffer is a child of
*pts*
array of vertices tuples i.e. [(x0,y0,z0), (x1,y1,z1),...]
*texcoords*
array of texture (uv) coordinates tuples
i.e. [(u0,v0), (u1,v1),...]
*faces*
array of indices (of pts array) defining triangles
i.e. [(a0,b0,c0), (a1,b1,c1),...]
Keyword arguments:
*normals*
array of vector component tuples defining normals at each
vertex i.e. [(x0,y0,z0), (x1,y1,z1),...]
*smooth*
if calculating normals then average normals for all faces
meeting at this vertex, otherwise just use first (for speed).
"""
super(Buffer, self).__init__()
# Uniform variables all in one array!
self.unib = (c_float * 9)(0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.0)
""" pass to shader array of vec3 uniform variables:
===== ============================ ==== ==
vec3 description python
----- ---------------------------- -------
index from to
===== ============================ ==== ==
0 ntile, shiny, blend 0 2
1 material 3 5
2 umult, vmult (only 2 used) 6 7
===== ============================ ==== ==
"""
self.shape = shape
if not normals:
LOGGER.debug("Calculating normals ...")
normals = [[] for p in pts]
# Calculate normals.
for f in faces:
a, b, c = f[0:3]
ab = Utility.vec_sub(pts[a], pts[b])
bc = Utility.vec_sub(pts[a], pts[c])
n = tuple(Utility.vec_normal(Utility.vec_cross(ab, bc)))
for x in f[0:3]:
normals[x].append(n)
for i, n in enumerate(normals):
if n:
if smooth:
norms = [sum(v[k] for v in n) for k in range(3)]
else: # This should be slightly faster for large shapes
norms = [n[0][k] for k in range(3)]
normals[i] = tuple(Utility.vec_normal(norms))
else:
normals[i] = 0, 0, 0.01
# keep a copy for speeding up the collision testing of ElevationMap
self.vertices = pts
self.normals = normals
self.tex_coords = texcoords
self.indices = faces
self.material = (0.5, 0.5, 0.5, 1.0)
# Pack points,normals and texcoords into tuples and convert to ctype floats.
points = [p + n + t for p, n, t in zip(pts, normals, texcoords)]
self.array_buffer = c_floats(list(itertools.chain(*points)))
self.ntris = len(faces)
points = [f[0:3] for f in faces]
self.element_array_buffer = c_shorts(list(itertools.chain(*points)))
def __init__(self,
shape,
pts,
texcoords,
faces,
normals=None,
smooth=True):
"""Generate a vertex buffer to hold data and indices. If no normals
are provided then these are generated.
Arguments:
*shape*
Shape object that this Buffer is a child of
*pts*
array of vertices tuples i.e. [(x0,y0,z0), (x1,y1,z1),...]
*texcoords*
array of texture (uv) coordinates tuples
i.e. [(u0,v0), (u1,v1),...]
*faces*
array of indices (of pts array) defining triangles
i.e. [(a0,b0,c0), (a1,b1,c1),...]
Keyword arguments:
*normals*
array of vector component tuples defining normals at each
vertex i.e. [(x0,y0,z0), (x1,y1,z1),...]
*smooth*
if calculating normals then average normals for all faces
meeting at this vertex, otherwise just use first (for speed).
"""
super(Buffer, self).__init__()
# Uniform variables all in one array!
self.unib = (c_float * 12)(0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.0,
0.0, 0.0, 0.0)
""" pass to shader array of vec3 uniform variables:
===== ============================ ==== ==
vec3 description python
----- ---------------------------- -------
index from to
===== ============================ ==== ==
0 ntile, shiny, blend 0 2
1 material 3 5
2 umult, vmult (only 2 used) 6 7
3 u_off, v_off (only 2 used) 9 10
===== ============================ ==== ==
"""
self.shape = shape
if not normals:
LOGGER.debug("Calculating normals ...")
normals = [[] for p in pts]
# Calculate normals.
for f in faces:
a, b, c = f[0:3]
ab = Utility.vec_sub(pts[a], pts[b])
bc = Utility.vec_sub(pts[a], pts[c])
n = tuple(Utility.vec_normal(Utility.vec_cross(ab, bc)))
for x in f[0:3]:
normals[x].append(n)
for i, n in enumerate(normals):
if n:
if smooth:
norms = [sum(v[k] for v in n) for k in range(3)]
else: # This should be slightly faster for large shapes
norms = [n[0][k] for k in range(3)]
normals[i] = tuple(Utility.vec_normal(norms))
else:
normals[i] = 0, 0, 0.01
# keep a copy for speeding up the collision testing of ElevationMap
self.vertices = pts
self.normals = normals
self.tex_coords = texcoords
self.indices = faces
self.material = (0.5, 0.5, 0.5, 1.0)
# Pack points,normals and texcoords into tuples and convert to ctype floats.
points = [p + n + t for p, n, t in zip(pts, normals, texcoords)]
self.array_buffer = c_floats(list(itertools.chain(*points)))
self.ntris = len(faces)
points = [f[0:3] for f in faces]
self.element_array_buffer = c_shorts(list(itertools.chain(*points)))
def __init__(self, shape, pts, texcoords, faces, normals=None, smooth=True):
"""Generate a vertex buffer to hold data and indices. If no normals
are provided then these are generated.
Arguments:
*shape*
Shape object that this Buffer is a child of
*pts*
array of vertices tuples i.e. [(x0,y0,z0), (x1,y1,z1),...]
*texcoords*
array of texture (uv) coordinates tuples
i.e. [(u0,v0), (u1,v1),...]
*faces*
array of indices (of pts array) defining triangles
i.e. [(a0,b0,c0), (a1,b1,c1),...]
Keyword arguments:
*normals*
array of vector component tuples defining normals at each
vertex i.e. [(x0,y0,z0), (x1,y1,z1),...]
*smooth*
if calculating normals then average normals for all faces
meeting at this vertex, otherwise just use first (for speed).
"""
super(Buffer, self).__init__()
# Uniform variables all in one array!
self.unib = (c_float * 12)(0.0, 0.0, 0.0,
0.5, 0.5, 0.5,
1.0, 1.0, 0.0,
0.0, 0.0, 0.0)
""" pass to shader array of vec3 uniform variables:
===== ============================ ==== ==
vec3 description python
----- ---------------------------- -------
index from to
===== ============================ ==== ==
0 ntile, shiny, blend 0 2
1 material 3 5
2 umult, vmult, point_size 6 8
3 u_off, v_off (only 2 used) 9 10
===== ============================ ==== ==
"""
#self.shape = shape
self.textures = []
pts = np.array(pts)
texcoords = np.array(texcoords)
faces = np.array(faces)
if normals == None: #i.e. normals will only be generated if explictly None
LOGGER.debug('Calculating normals ...')
normals = np.zeros(pts.shape, dtype=pts.dtype) #empty array rights size
fv = pts[faces] #expand faces with x,y,z values for each vertex
#cross product of two edges of triangles
fn = np.cross(fv[:][:][:,1] - fv[:][:][:,0], fv[:][:][:,2] - fv[:][:][:,0])
fn = Utility.normalize_v3(fn)
normals[faces[:,0]] += fn #add up all normal vectors for a vertex
normals[faces[:,1]] += fn
normals[faces[:,2]] += fn
Utility.normalize_v3(normals)
else:
normals = np.array(normals)
# keep a copy for speeding up the collision testing of ElevationMap
self.vertices = pts
self.normals = normals
self.tex_coords = texcoords
self.indices = faces
self.material = (0.5, 0.5, 0.5, 1.0)
# Pack points,normals and texcoords into tuples and convert to ctype floats.
n_verts = len(pts)
if len(texcoords) != n_verts:
if len(normals) != n_verts:
self.N_BYTES = 12 # only use pts
self.array_buffer = c_floats(pts.reshape(-1).tolist())
else:
self.N_BYTES = 24 # use pts and normals
self.array_buffer = c_floats(np.concatenate((pts, normals),
axis=1).reshape(-1).tolist())
else:
self.N_BYTES = 32 # use all three NB doesn't check that normals are there
self.array_buffer = c_floats(np.concatenate((pts, normals, texcoords),
axis=1).reshape(-1).tolist())
self.ntris = len(faces)
self.element_array_buffer = c_shorts(faces.reshape(-1))
