def gen_mesh(self, address):
mesh = None
if address in self._generated_meshes:
mesh = self._generated_meshes[address]
else:
#b = datetime.now()
bound_min_x, bound_min_z, bound_max_x, bound_max_z, face = CubeSphereMap.get_address_bounds(address)
verts, noise = self._gen_verts(address)
faces = []
v = 0
for c in xrange(self._increments):
for r in xrange(self._increments):
bl = v + c + r
tl = bl + 1
tr = tl + self._increments + 1
br = tr - 1
faces.append((bl, tl, tr))
faces.append((bl, tr, br))
v = v + self._increments
tex_coords = []
bound_width = bound_max_x - bound_min_x
bound_height = bound_max_z - bound_min_z
for i in xrange(self._increments + 1):
# Generate 0.0 - 1.0 local uv coords
c = i * (1.0 / (self._increments))
# generate global uv coords i.e. 0.2 - 0.3
#c = (i * (bound_width / float(self._increments) ) ) + bound_min_x
tc = []
for j in xrange(self._increments + 1):
# local
r = j * ( 1.0 / (self._increments))
# global
#r = (j * ( bound_height / float(self._increments) ) )+ bound_min_z
#y = j/self._increments
p = [c,r]
tex_coords.append(p)
tc.append(p)
# s = ""
# for n in tc:
# s += "\t(%0.3f,%0.3f)," % (n[0], n[1])
# print s
#print "%s Vertex gen time: %3.5f" % (address, (datetime.now() - b).total_seconds())
b = datetime.now()
# Build a mesh
mesh = Mesh(verts, faces, Preset.green, tex_coords=tex_coords)
self._generated_meshes[address] = mesh
self._generated_noise[address] = noise
#print "%s Mesh obj Gen time: %3.5f" % (address, (datetime.now() - b).total_seconds())
return mesh
def _gen_verts(self, address):
bound_min_x, bound_min_z, bound_max_x, bound_max_z, face = CubeSphereMap.get_address_bounds(address)
verts = []
noise_x = []
h_height = self._max_height / 2.0
for i in xrange(self._increments + 1):
#c = i * (1.0 / self._increments)
c = (i * ( (bound_max_x - bound_min_x) / float(self._increments) ) ) + bound_min_x
nv = []
noise_y = []
for j in xrange(self._increments + 1):
#r = j * ( 1.0 / self._increments )
r = (j * ( (bound_max_z - bound_min_z) / float(self._increments) ) ) + bound_min_z
p = CubeSphereMap.get_sphere_vector(c, r, face) * self._radius
n = Vector3()#c, r, -1) * self._radius
if True:
u = c
v = r
u = (u * 2.0) - 1.0
v = (v * 2.0) - 1.0
if face == CubeSphereMap.BACK:
n = Vector3(-u, -v, -1) * self._radius
elif face == CubeSphereMap.LEFT:
n = Vector3(-1, -v, u) * self._radius
elif face == CubeSphereMap.RIGHT:
n = Vector3(1, -v, -u) * self._radius
elif face == CubeSphereMap.TOP:
n = Vector3(u, 1, v) * self._radius
elif face == CubeSphereMap.BOTTOM:
n = Vector3(u, -1, -v) * self._radius
elif face == CubeSphereMap.FRONT:
n = Vector3(u, -v, 1) * self._radius
else:
# Adjust the surface level using noise
n = p.copy()
# if face == CubeSphereMap.RIGHT:
# n.x = self._radius
# elif face == CubeSphereMap.LEFT:
# n.x = -self._radius
# elif face == CubeSphereMap.TOP:
# n.y = self._radius
# elif face == CubeSphereMap.BOTTOM:
# n.y = -self._radius
# elif face == CubeSphereMap.FRONT:
# n.z = self._radius
# elif face == CubeSphereMap.BACK:
# n.z = -self._radius
frac = self._get_noise(n)
# if i == 0 and j == 0:
# frac = 5.0
# if i == self._increments and j == self._increments:
# frac = 10.0
# if j in [4, 6, 8, 20, 25, 30]:
# frac = 1
# else:
# frac = -1
# if i in [5,6,20,21]:
# frac = 1
#noise.append(frac)
noise_y.append(frac)
nv.append(frac)
#h = noise * self._max_height
h = (frac * h_height ) + h_height
# Increase the surface vector by the noise value
n = p.normalized()
n *= h
p += n
verts.append((p.x, p.y, p.z))
# s = ""
# for n in nv:
# s += "\t%0.3f," % n
# print s
noise_x.append(noise_y)
return verts, noise_x
def _calc_corners(self):
# Calculate the Cubic coordinates of this quad
x0, y0, x1, y1, face = CubeSphereMap.get_address_bounds(self._name)
self._corners = [x0, y0, x1, y1]
self._centre_coords = CubeSphereMap.get_address_centre(self._name)
self._quad_centres = [
CubeSphereMap.get_address_centre(self._name+'A'),
CubeSphereMap.get_address_centre(self._name+'B'),
CubeSphereMap.get_address_centre(self._name+'D'),
CubeSphereMap.get_address_centre(self._name+'C')
]
# if self._root:
# self._corners.append(0.0) #tl x
# self._corners.append(0.0) #tl y
# self._corners.append(1.0) #br x
# self._corners.append(1.0) #br y
# else:
# parent_corners = self.transform.parent.node.corners
# if self._quad == QuadName.TL:
# self._corners.append(parent_corners[0])
# self._corners.append(parent_corners[1])
# self._corners.append(parent_corners[0] + (parent_corners[2] - parent_corners[0]) * 0.5 )
# self._corners.append(parent_corners[1] + (parent_corners[3] - parent_corners[1]) * 0.5 )
# elif self._quad == QuadName.TR:
# self._corners.append(parent_corners[0] + (parent_corners[2] - parent_corners[0]) * 0.5)
# self._corners.append(parent_corners[1])
# self._corners.append(parent_corners[2])
# self._corners.append(parent_corners[1] + (parent_corners[3] - parent_corners[1]) * 0.5 )
# elif self._quad == QuadName.BL:
# self._corners.append(parent_corners[0])
# self._corners.append(parent_corners[1] + (parent_corners[3] - parent_corners[1]) * 0.5)
# self._corners.append(parent_corners[0] + (parent_corners[2] - parent_corners[0]) * 0.5)
# self._corners.append(parent_corners[3])
# elif self._quad == QuadName.BR:
# self._corners.append(parent_corners[0] + (parent_corners[2] - parent_corners[0]) * 0.5)
# self._corners.append(parent_corners[1] + (parent_corners[3] - parent_corners[1]) * 0.5)
# self._corners.append(parent_corners[2])
# self._corners.append(parent_corners[3])
# mid_x = (self._corners[2] - self._corners[0]) / 2
# mid_y = (self._corners[3] - self._corners[1]) / 2
# self._centre_coords = [(self._corners[0] + mid_x), (self._corners[1] + mid_y)]
# self._quad_centres = [ [self._corners[0] + (mid_x/2), self._corners[1] + (mid_y/2)], #TL
# [self._corners[2] - (mid_x/2), self._corners[1] + (mid_y/2)], #TR
# [self._corners[2] - (mid_x/2), self._corners[3] - (mid_y/2)], #BR
# [self._corners[0] + (mid_x/2), self._corners[3] - (mid_y/2)] #BL
# ]
# Get world positions for centres of child quads
self._child_pos = [CubeSphereMap.get_sphere_position(self._quad_centres[QuadName.TL][0],
self._quad_centres[QuadName.TL][1],
self._face,
self._sphere_parent.radius),
CubeSphereMap.get_sphere_position(self._quad_centres[QuadName.TR][0],
self._quad_centres[QuadName.TR][1],
self._face,
self._sphere_parent.radius),
CubeSphereMap.get_sphere_position(self._quad_centres[QuadName.BR][0],
self._quad_centres[QuadName.BR][1],
self._face,
self._sphere_parent.radius),
CubeSphereMap.get_sphere_position(self._quad_centres[QuadName.BL][0],
self._quad_centres[QuadName.BL][1],
self._face,
self._sphere_parent.radius),
]
