def loadECfiles(path, fname, suffix='jpg', nobottom=False):
"""Helper for loading environment cube faces.
TODO nobottom will redraw the top on the bottom of cube. It really should
substitute a blank (black) texture instead!
Arguments:
*path*
to the image files relative to the top directory.
*fname*
The stem of the file name without the _top, _bottom, _right etc.
Keyword arguments:
*suffix*
String to add after the '_top','_bottom' has been added to the stem.
*nobottom*
If True then only load five parts into array the bottom will be
drawn with the previous image i.e. top.
"""
if nobottom:
parts = [p for p in CUBE_PARTS if p != 'bottom']
else:
parts = CUBE_PARTS
files = (os.path.join(path, '%s_%s.%s' % (fname, p, suffix))
for p in parts)
return [Texture(f) for f in files]
def __init__(self, texture, shader, **kwds):
super(ImageSprite, self).__init__(**kwds)
if not isinstance(texture, Texture): # i.e. can load from file name
texture = Texture(texture)
self.set_shader(shader)
self.buf[0].set_draw_details(shader, [texture])
self.set_2d_size() # method in Shape, default full window size
print("Good turnings are often greener and tend to be near")
print("(but in the opposite direction to) big holes")
print("############################################################")
print("If you get touched by a monster you will return to the start!")
print("############################################################")
print()
# Setup display and initialise pi3d
DISPLAY = Display.create(x=100, y=100, background=(0.4, 0.8, 0.8, 1))
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
#========================================
# load Textures
rockimg1 = Texture("textures/techy1.jpg")
rockimg2 = Texture("textures/rocktile2.jpg")
tree2img = Texture("textures/tree2.png")
raspimg = Texture("textures/Raspi256x256.png")
monstimg = Texture("textures/pong2.jpg")
monsttex = Texture("textures/floor_nm.jpg")
shineimg = Texture("textures/stars.jpg")
# environment cube
ectex = Texture("textures/ecubes/skybox_stormydays.jpg")
myecube = EnvironmentCube(size=900.0, maptype="CROSS")
myecube.set_draw_details(flatsh, ectex)
# Create elevation map
mapwidth = 1000.0
mapdepth = 1000.0
def __init__(self, pex_file, emission_rate=10, scale=1.0, rot_rate=None,
rot_var=0.0, **kwargs):
''' has to be supplied with a pex xml type file to parse. The results
are loaded into new attributes of the instance of this class with identifiers
matching the Elements of the pex file. There is zero checking for the
correct file format:
self.texture={name:'particle.png'}
self.sourcePosition={x:160.00,y:369.01}
self.sourcePositionVariance={x:60.00,y:0.00}
self.speed=138.16
self.speedVariance=0.00
self.particleLifeSpan=0.7000
self.particleLifespanVariance=0.0000
self.angle=224.38
self.angleVariance=360.00
self.gravity={x:0.00,y:-1400.00}
self.radialAcceleration=0.00
self.tangentialAcceleration=0.00
self.radialAccelVariance=0.00
self.tangentialAccelVariance=-0.00
self.startColor={red:0.15,green:0.06,blue:1.00,alpha:1.00}
self.startColorVariance={red:0.00,green:0.00,blue:0.00,alpha:0.00}
self.finishColor={red:0.00,green:0.14,blue:0.23,alpha:0.00}
self.finishColorVariance={red:0.00,green:0.00,blue:0.00,alpha:0.00}
self.maxParticles=300
self.startParticleSize=43.79
self.startParticleSizeVariance=0.00
self.finishParticleSize=138.11
self.FinishParticleSizeVariance=0.00
self.duration=-1.00
self.emitterType=0
self.maxRadius=100.00
self.maxRadiusVariance=0.00
self.minRadius=0.00
self.rotatePerSecond=0.00
self.rotatePerSecondVariance=0.00
self.blendFuncSource=770
self.blendFuncDestination=772
self.rotationStart=0.00
self.rotationStartVariance=0.00
self.rotationEnd=0.00
self.rotationEndVariance=0.00
'''
# first parse the pex file, json would have been nicer than xml!
_config = parse(pex_file).childNodes[0].childNodes
for c in _config:
if c.localName is not None:
key = c.localName
val = {}
for v in c.attributes.items():
try:
v_tp = int(v[1]) # try int first
except ValueError:
try:
v_tp = float(v[1]) # if not try float
except ValueError:
v_tp = v[1] # otherwise leave as string
if v[0] == 'value': # single value 'value' don't use dictionary
val = v_tp
break
else:
val[v[0]] = v_tp # not just a value
self.__setattr__(key, val)
self._emission_rate = emission_rate # particles per second
self._last_emission_time = None
self._last_time = None
self.scale = scale
self.rot_rate = rot_rate
self.rot_var = rot_var
''' make the numpy arrays to hold the particle info
vertices[0] x position of centre of point relative to centre of screen in pixels
vertices[1] y position
vertices[2] z depth but fract(z) is used as a multiplier for point size
normals[0] rotation in radians
normals[1] red and green values to multiply with the texture
normals[2] blue and alph values to multiply with the texture. The values
are packed into the whole number and fractional parts of
the float i.e. where R and G are between 0.0 and 0.999
normals[:,2] = floor(999 * R) + G
tex_coords[0] distance of left side of sprite square from left side of
texture in uv scale 0.0 to 1.0
tex_coords[1] distance of top of sprite square from top of texture
arr[8] x velocity
arr[9] y velocity
arr[10] lifespan
arr[11] lifespan remaining
arr[12:16] rgba target values
arr[16:20] rgba difference
arr[20] size delta (finish size - start size) / full_lifespan
arr[21] radial acceleration
arr[22] tangential acceleration
'''
self.arr = np.zeros((self.maxParticles, 23), dtype='float32')
self.point_size = max(self.startParticleSize + self.startParticleSizeVariance,
self.finishParticleSize + self.FinishParticleSizeVariance) #NB capital F!
super(PexParticles, self).__init__(vertices=self.arr[:,0:3],
normals=self.arr[:,3:6],
tex_coords=self.arr[:,6:8],
point_size=self.point_size * self.scale, **kwargs) # pass to Points.__init__()
shader = Shader('uv_pointsprite')
try:
tex = Texture(self.texture['name']) # obvious first!
except:
import os
tex = Texture(os.path.join(
os.path.split(pex_file)[0], self.texture['name']))
self.set_draw_details(shader, [tex])
self.unif[48] = 1.0 # sprite uses whole image
def loadFileOBJ(model, fileName):
"""Loads an obj file with associated mtl file to produce Buffer object
as part of a Shape. Arguments:
*model*
Model object to add to.
*fileName*
Path and name of obj file relative to program file.
"""
model.coordinateSystem = "Y-up"
model.parent = None
#model.childModel = [] # don't really need parent and child pointers but will speed up traversing tree
model.vNormal = False
model.vGroup = {} # holds the information for each vertex group
# read in the file and parse into some arrays, name='teapot', z=4
#import os
if fileName[0] != '/':
for p in sys.path:
if os.path.isfile(p + '/' + fileName): # this could theoretically get different files with same name
fileName = p + '/' + fileName
break
filePath = os.path.split(os.path.abspath(fileName))[0]
LOGGER.debug(filePath)
f = open(fileName, 'r')
vertices = []
normals = []
uvs = []
faces = {}
materials = {}
material = ""
mcounter = 0
mcurrent = 0
mtllib = ""
# current face state
group = 0
objct = 0
smooth = 0
for l in f:
chunks = l.split()
if len(chunks) > 0:
# Vertices as (x,y,z) coordinates
# v 0.123 0.234 0.345
if chunks[0] == "v" and len(chunks) >= 4:
x = float(chunks[1])
y = float(chunks[2])
z = -float(chunks[3]) # z direction away in gl es 2.0 shaders
vertices.append((x, y, z))
# Normals in (x, y, z) form; normals might not be unit
# vn 0.707 0.000 0.707
if chunks[0] == "vn" and len(chunks) >= 4:
x = float(chunks[1])
y = float(chunks[2])
z = -float(chunks[3]) # z direction away in gl es 2.0 shaders
normals.append((x, y, z))
# Texture coordinates in (u,v)
# vt 0.500 -1.352
if chunks[0] == "vt" and len(chunks) >= 3:
u = float(chunks[1])
v = float(chunks[2])
uvs.append((u, v))
# Face
if chunks[0] == "f" and len(chunks) >= 4:
vertex_index = []
uv_index = []
normal_index = []
# Precompute vert / normal / uv lists
# for negative index lookup
vertlen = len(vertices) + 1
normlen = len(normals) + 1
uvlen = len(uvs) + 1
for v in chunks[1:]:
vertex = parse_vertex(v)
if vertex['v']:
if vertex['v'] < 0:
vertex['v'] += vertlen
vertex_index.append(vertex['v'])
if vertex['t']:
if vertex['t'] < 0:
vertex['t'] += uvlen
uv_index.append(vertex['t'])
if vertex['n']:
if vertex['n'] < 0:
vertex['n'] += normlen
normal_index.append(vertex['n'])
if not mcurrent in faces:
faces[mcurrent] = []
faces[mcurrent].append({
'vertex':vertex_index,
'uv':uv_index,
'normal':normal_index,
'group':group,
'object':objct,
'smooth':smooth,
})
# Group
if chunks[0] == "g" and len(chunks) == 2:
group = chunks[1]
# Object
if chunks[0] == "o" and len(chunks) == 2:
objct = chunks[1]
# Materials definition
if chunks[0] == "mtllib" and len(chunks) == 2:
mtllib = chunks[1]
# Material
if chunks[0] == "usemtl":
if len(chunks) > 1:
material = chunks[1]
else:
material = ""
if not material in materials:
mcurrent = mcounter
materials[material] = mcounter
mcounter += 1
else:
mcurrent = materials[material]
# Smooth shading
if chunks[0] == "s" and len(chunks) == 2:
smooth = chunks[1]
for g in faces: # make each of these into an array_buffer with its own material
g_vertices = []
g_normals = []
g_tex_coords = []
g_indices = []
i = 0 # vertex counter in this material
LOGGER.debug("len uv={}".format(len(vertices)))
vec_dict = {} # hold unique combinations of v/u/n
for f in faces[g]:
vec_list = [] # hold index vals for each array_buffer entry for this face
length = len(f['vertex'])
length_n = len(f['normal'])
length_uv = len(f['uv'])
for v in range(length):
vec_tuple = (f['vertex'][v],
f['uv'][v] if length_uv > 0 else -1,
f['normal'][v] if length_n == length else -1)
if vec_tuple in vec_dict: #already exists don't duplicate
vec_list.append(vec_dict[vec_tuple])
else:
g_vertices.append(vertices[vec_tuple[0] - 1])
if length_n == length: #only use normals if there is one for each vertex
g_normals.append(normals[vec_tuple[2] - 1])
if (length_uv > 0 and len(uvs[vec_tuple[1] - 1]) == 2):
g_tex_coords.append(uvs[vec_tuple[1] - 1])
vec_dict[vec_tuple] = i
vec_list.append(i)
i += 1
for t in range(len(vec_list) - 2):
g_indices.append((vec_list[0], vec_list[t + 2], vec_list[t + 1]))
if len(g_normals) != len(g_vertices):
g_normals = None # force Buffer.__init__() to generate normals
model.buf.append(Buffer(model, g_vertices, g_tex_coords, g_indices, g_normals))
n = len(model.buf) - 1
model.vGroup[g] = n
model.buf[n].indicesLen = len(model.buf[n].element_array_buffer)
model.buf[n].material = (0.0, 0.0, 0.0, 0.0)
model.buf[n].draw_method = GL_TRIANGLES
LOGGER.debug("indices=%s\nvertices=%s", len(model.buf[n].element_array_buffer),
len(model.buf[n].array_buffer))
try:
material_lib = parse_mtl(open(os.path.join(filePath, mtllib), 'r'))
for m in materials:
LOGGER.debug(m)
if 'mapDiffuse' in material_lib[m]:
tfileName = material_lib[m]['mapDiffuse']
model.buf[model.vGroup[materials[m]]].texFile = tfileName
model.buf[model.vGroup[materials[m]]].textures = [Texture(filePath + '/' + tfileName, blend=False, flip=True)] # load from file
else:
model.buf[model.vGroup[materials[m]]].texFile = None
model.buf[model.vGroup[materials[m]]].textures = []
if 'colorDiffuse' in material_lib[m]:#TODO don't create this array if texture being used though not exclusive.
#TODO check this works with appropriate mtl file
redVal = material_lib[m]['colorDiffuse'][0]
grnVal = material_lib[m]['colorDiffuse'][1]
bluVal = material_lib[m]['colorDiffuse'][2]
model.buf[model.vGroup[materials[m]]].material = (redVal, grnVal, bluVal, 1.0)
model.buf[model.vGroup[materials[m]]].unib[3:6] = [redVal, grnVal, bluVal]
except:
LOGGER.warning('no material specified')
# Setup display and initialise pi3d
DISPLAY = Display.create(x=200, y=200, frames_per_second=20)
DISPLAY.set_background(0.4, 0.8, 0.8, 1) # r,g,b,alpha
camera = Camera((0, 0, 0), (0, 0, -1),
(1, 1000, 30.0, DISPLAY.width / DISPLAY.height))
light = Light((10, -10, 20))
# load shader
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
defocus = Defocus()
#========================================
# Setting 2nd param to True renders 'True' Blending
# (this can be changed later to 'False' with 'rockimg2.blend = False')
groundimg = Texture("textures/stripwood.jpg")
monstimg = Texture("textures/pong3.png")
ballimg = Texture("textures/pong2.jpg")
# environment cube
ectex = Texture("textures/ecubes/skybox_stormydays.jpg")
myecube = EnvironmentCube(camera, light, 900.0, "CROSS")
myecube.set_draw_details(flatsh, [ectex])
#ball
maxdsz = 0.3
radius = 1.0
ball = Sphere(camera, light, radius, 12, 12, 0.0, "sphere", -4, 8, -7)
# Shape.set_draw_details is a wrapper for calling the method on each item in buf
# as is done explicitly here for no reason than to show that it can be done!
ball.buf[0].set_draw_details(shader, [ballimg], 0.0, 0.0)
def __init__(self,
camera=None,
light=None,
w=1.0,
h=1.0,
corner=0.1,
name="",
texture=None,
shader=None,
x=0.0,
y=0.0,
z=20.0,
rx=0.0,
ry=0.0,
rz=0.0,
sx=1.0,
sy=1.0,
sz=1.0,
cx=0.0,
cy=0.0,
cz=0.0):
"""Uses standard constructor for Shape. Extra Keyword arguments:
*w*
Width.
*h*
Height.
*corner*
The size that the edge thirds will be. Used for mapping textures to plane
"""
super(ButtonSprite, self).__init__(camera, light, name, x, y, z, rx,
ry, rz, sx, sy, sz, cx, cy, cz)
self.width = w
self.height = h
self.corner = corner
verts = []
norms = []
texcoords = []
inds = []
ww = w / 2.0
hh = h / 2.0
for (j, y) in enumerate((hh, hh - corner, -hh + corner, -hh)):
y_uv = j / 3.0
for (i, x) in enumerate((-ww, -ww + corner, ww - corner, ww)):
x_uv = i / 3.0
verts.extend([[x, y, 0.0]])
norms.extend([[0.0, 0.0, -1.0]])
texcoords.extend([[x_uv, y_uv]])
if i > 0 and j > 0:
n = j * 4 + i
inds.extend([[n - 1, n - 5, n - 4], [n - 4, n, n - 1]])
self.buf = [Buffer(self, verts, texcoords, inds, norms)]
if texture is None:
for p in sys.path:
img_path = os.path.join(p, "pi3d/shape/button_image.png")
if os.path.exists(img_path):
texture = Texture(img_path)
break
else:
if not isinstance(texture,
Texture): # i.e. can load from file name
texture = Texture(texture)
if shader is None:
shader = Shader("uv_flat")
else:
if not isinstance(shader, Shader):
shader = Shader(shader)
self.set_draw_details(shader, [texture])
def __init__(self, pex_file, emission_rate=10, scale=1.0, rot_rate=None,
rot_var=0.0, new_batch=0.1, hardness=2.0, **kwargs):
''' has to be supplied with a pex xml type file to parse. The results
are loaded into new attributes of the instance of this class with identifiers
matching the Elements of the pex file. There is zero checking for the
correct file format.
pex_file: file name. if "circle" then lite option doesn't
use texture lookup and used mat_pointsprite shader
emission_rate: new particles per second
scale: scale the point size and location
rot_rate: UV mapping rotates
rot_var: variance in rotation rate
new_batch: proportion of emission_rate to batch (for efficiency)
hardness: for lite version
The following attributes are created from the pex file and can be subsequently
altered. i.e. self.sourcePosition['x'] += 2.0
self.texture={name:'particle.png'}
self.sourcePosition={x:160.00,y:369.01}
self.sourcePositionVariance={x:60.00,y:0.00}
self.speed=138.16
self.speedVariance=0.00
self.particleLifeSpan=0.7000
self.particleLifespanVariance=0.0000
self.angle=224.38
self.angleVariance=360.00
self.gravity={x:0.00,y:-1400.00}
self.radialAcceleration=0.00
self.tangentialAcceleration=0.00
self.radialAccelVariance=0.00
self.tangentialAccelVariance=-0.00
self.startColor={red:0.15,green:0.06,blue:1.00,alpha:1.00}
self.startColorVariance={red:0.00,green:0.00,blue:0.00,alpha:0.00}
self.finishColor={red:0.00,green:0.14,blue:0.23,alpha:0.00}
self.finishColorVariance={red:0.00,green:0.00,blue:0.00,alpha:0.00}
self.maxParticles=300
self.startParticleSize=43.79
self.startParticleSizeVariance=0.00
self.finishParticleSize=138.11
self.FinishParticleSizeVariance=0.00
self.duration=-1.00
self.emitterType=0
self.maxRadius=100.00
self.maxRadiusVariance=0.00
self.minRadius=0.00
self.rotatePerSecond=0.00
self.rotatePerSecondVariance=0.00
self.blendFuncSource=770
self.blendFuncDestination=772
self.rotationStart=0.00
self.rotationStartVariance=0.00
self.rotationEnd=0.00
self.rotationEndVariance=0.00
'''
# first parse the pex file, json would have been nicer than xml!
_config = parse(pex_file).childNodes[0].childNodes
for c in _config:
if c.localName is not None:
key = c.localName
val = {}
for v in c.attributes.items():
try:
v_tp = int(v[1]) # try int first
except ValueError:
try:
v_tp = float(v[1]) # if not try float
except ValueError:
v_tp = v[1] # otherwise leave as string
if v[0] == 'value': # single value 'value' don't use dictionary
val = v_tp
break
else:
val[v[0]] = v_tp # not just a value
self.__setattr__(key, val)
self._emission_rate = emission_rate # particles per second
self._last_emission_time = None
self._last_time = None
self._new_batch = emission_rate * new_batch # to clump new particles
self.scale = scale
self.rot_rate = rot_rate
self.rot_var = rot_var
# make a flag to avoid this expensive operation if no accelerators
self.any_acceleration = (self.gravity['x'] != 0.0 or self.gravity['y'] != 0.0 or
self.radialAcceleration != 0.0 or
self.tangentialAcceleration != 0.0)
self.any_colorchange = any(self.startColor[i] != self.finishColor[i]
for i in ('red','green','blue','alpha'))
''' Buffer.array_buffer holds
[0] vertices[0] x position of centre of point relative to centre of screen in pixels
[1] vertices[1] y position
[2] vertices[2] z depth but fract(z) is used as a multiplier for point size
[3] normals[0] rotation in radians
[4] normals[1] red and green values to multiply with the texture
[5] normals[2] blue and alph values to multiply with the texture. The values
are packed into the whole number and fractional parts of
the float i.e. where R and G are between 0.0 and 0.999
normals[:,2] = floor(999 * R) + G
[6] tex_coords[0] distance of left side of sprite square from left side of
texture in uv scale 0.0 to 1.0
[7] tex_coords[1] distance of top of sprite square from top of texture
for lite version using the mat_pointsprite shader
[3:7] hold RGBA in simple float form
make additional numpy array to hold the particle info
arr[0] x velocity
arr[1] y velocity
arr[2] lifespan
arr[3] lifespan remaining
arr[4:8] rgba target values
arr[8:12] rgba difference
arr[12] size delta (finish size - start size) / full_lifespan
arr[13] radial acceleration
arr[14] tangential acceleration
'''
self.arr = np.zeros((self.maxParticles, 15), dtype='float32')
self.point_size = max(self.startParticleSize + self.startParticleSizeVariance,
self.finishParticleSize + self.FinishParticleSizeVariance) #NB capital F!
super(PexParticles, self).__init__(vertices=np.zeros((self.maxParticles, 3), dtype='float32'),
normals=np.zeros((self.maxParticles, 3), dtype='float32'),
tex_coords=np.zeros((self.maxParticles, 2), dtype='float32'),
point_size=self.point_size * self.scale, **kwargs) # pass to Points.__init__()
if self.texture['name'] == 'circle': # TODO alternative geometries
self.lite = True
shader = Shader('mat_pointsprite')
self.set_shader(shader)
self.buf[0].unib[0] = hardness
else:
self.lite = False
shader = Shader('uv_pointsprite')
try:
tex = Texture(self.texture['name']) # obvious first!
except:
import os
tex = Texture(os.path.join(
os.path.split(pex_file)[0], self.texture['name']))
self.set_draw_details(shader, [tex])
self.unif[48] = 1.0 # sprite uses whole image
# create splash screen and draw it
splash = ImageSprite("textures/tiger_splash.jpg", shade2d, w=10, h=10, z=0.2)
splash.draw()
DISPLAY.swap_buffers()
# create environment cube
ectex = EnvironmentCube.loadECfiles('textures/ecubes/Miramar', 'miramar_256',
suffix='png')
myecube = EnvironmentCube.EnvironmentCube(size=1800.0, maptype='FACES')
myecube.set_draw_details(flatsh, ectex)
# Create elevation map
mapwidth = 2000.0
mapdepth = 2000.0
mapheight = 100.0
mountimg1 = Texture('textures/mountains3_512.jpg')
bumpimg = Texture('textures/grasstile_n.jpg')
tigerbmp = Texture('models/Tiger/tiger_bump.jpg')
topbmp = Texture('models/Tiger/top_bump.jpg')
#roadway = Texture('textures/road5.png')
mymap = ElevationMap(mapfile='textures/mountainsHgt2.png',
width=mapwidth, depth=mapdepth,
height=mapheight, divx=64, divy=64)
mymap.buf[0].set_draw_details(shader, [mountimg1, bumpimg], 128.0, 0.0)
FOG = (0.7, 0.8, 0.9, 0.5)
def set_fog(shape):
shape.set_fog(FOG, 1000.0)
# Setup display and initialise pi3d
DISPLAY = Display.create(x=10, y=10, w=900, h=600, frames_per_second=25)
DISPLAY.set_background(0.4, 0.6, 0.8, 1.0) # r,g,b,alpha
persp_cam = Camera.instance() # default instance camera perspecive view
ortho_cam = Camera(is_3d=False) # 2d orthographic view camera
#setup textures, light position and initial model position
Light((0, 5, 0))
#create shaders
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
defocus = Defocus()
#Create textures
shapeimg = Texture("textures/straw1.jpg")
shapebump = Texture("textures/floor_nm.jpg", True)
shapeshine = Texture("textures/pong3.png")
#Create shape
myshape = MergeShape(camera=persp_cam) #specify perspective view
asphere = Sphere(sides=16, slices=16)
myshape.radialCopy(asphere, step=72)
myshape.position(0.0, 0.0, 5.0)
myshape.set_draw_details(shader, [shapeimg, shapebump, shapeshine], 8.0, 0.1)
mysprite = Sprite(w=10.0, h=10.0, camera=persp_cam)
mysprite.position(0.0, 0.0, 15.0)
mysprite.set_draw_details(flatsh, [shapebump])
tick = 0
cloud_depth = 350.0
zd = 1.0 * cloud_depth / cloudno
MARGIN = 100
# Setup display and initialise pi3d
DISPLAY = Display.create(x=MARGIN, y=MARGIN)
scnx = DISPLAY.width
scny = DISPLAY.height
DISPLAY.set_background(0, 0.7, 1, 1)
shader = Shader("shaders/uv_flat")
#############################
cloudTex = []
cloudTex.append(Texture("textures/cloud2.png", True))
cloudTex.append(Texture("textures/cloud3.png", True))
cloudTex.append(Texture("textures/cloud4.png", True))
cloudTex.append(Texture("textures/cloud5.png", True))
cloudTex.append(Texture("textures/cloud6.png", True))
# Setup cloud positions and cloud image refs
cz = 0.0
clouds = [] # an array for the clouds
for b in range(0, cloudno):
size = 0.5 + random.random() / 2.0
cloud = Sprite(w=size * widex,
h=size * widey,
x=150.0 * (random.random() - 0.5),
y=0.0,
z=cloud_depth - cz)
from pi3d.shape.EnvironmentCube import EnvironmentCube
from pi3d.shape.EnvironmentCube import loadECfiles
from pi3d.util.Screenshot import screenshot
from pi3d.util import Utility
# Setup display and initialise pi3d
DISPLAY = Display.create(x=50, y=50)
shader = Shader('shaders/uv_flat')
#========================================
#select the environment cube with 'box'...
box = 3
if box == 0:
ectex = [Texture('textures/ecubes/skybox_interstellar.jpg')]
myecube = EnvironmentCube(size=900.0, maptype='CROSS')
elif box == 1:
ectex = [Texture('textures/ecubes/SkyBox.jpg')]
myecube = EnvironmentCube(size=900.0, maptype='HALFCROSS')
elif box == 2:
ectex = loadECfiles('textures/ecubes', 'sbox_interstellar', nobottom=True)
myecube = EnvironmentCube(size=900.0, maptype='FACES', nobottom=True)
else:
ectex = loadECfiles('textures/ecubes', 'skybox_hall')
myecube = EnvironmentCube(size=900.0, maptype='FACES')
myecube.set_draw_details(shader, ectex)
rot = 0.0
tilt = 0.0
def loadFileOBJ(model, fileName):
"""Loads an obj file with associated mtl file to produce Buffer object
as part of a Shape. Arguments:
*model*
Model object to add to.
*fileName*
Path and name of obj file relative to top directory.
"""
model.coordinateSystem = "Y-up"
model.parent = None
model.childModel = [
] # don't really need parent and child pointers but will speed up traversing tree
model.vNormal = False
model.vGroup = {} # holds the information for each vertex group
# read in the file and parse into some arrays
filePath = os.path.split(os.path.abspath(fileName))[0]
print filePath
f = open(fileName, 'r')
vertices = []
normals = []
uvs = []
faces = {}
materials = {}
material = ""
mcounter = 0
mcurrent = 0
numv = [
] #number of vertices for each material (nb each vertex will have three coords)
numi = [] #number of indices (triangle corners) for each material
mtllib = ""
# current face state
group = 0
objct = 0
smooth = 0
for l in f:
chunks = l.split()
if len(chunks) > 0:
# Vertices as (x,y,z) coordinates
# v 0.123 0.234 0.345
if chunks[0] == "v" and len(chunks) == 4:
x = float(chunks[1])
y = float(chunks[2])
z = -float(chunks[3]) # z direction away in gl es 2.0 shaders
vertices.append((x, y, z))
# Normals in (x, y, z) form; normals might not be unit
# vn 0.707 0.000 0.707
if chunks[0] == "vn" and len(chunks) == 4:
x = float(chunks[1])
y = float(chunks[2])
z = -float(chunks[3]) # z direction away in gl es 2.0 shaders
normals.append((x, y, z))
# Texture coordinates in (u,v)
# vt 0.500 -1.352
if chunks[0] == "vt" and len(chunks) >= 3:
u = float(chunks[1])
v = float(chunks[2])
uvs.append((u, v))
# Face
if chunks[0] == "f" and len(chunks) >= 4:
vertex_index = []
uv_index = []
normal_index = []
# Precompute vert / normal / uv lists
# for negative index lookup
vertlen = len(vertices) + 1
normlen = len(normals) + 1
uvlen = len(uvs) + 1
if len(numv) < (mcurrent + 1): numv.append(0)
if len(numi) < (mcurrent + 1): numi.append(0)
for v in chunks[1:]:
numv[mcurrent] += 1
numi[mcurrent] += 3
vertex = parse_vertex(v)
if vertex['v']:
if vertex['v'] < 0:
vertex['v'] += vertlen
vertex_index.append(vertex['v'])
if vertex['t']:
if vertex['t'] < 0:
vertex['t'] += uvlen
uv_index.append(vertex['t'])
if vertex['n']:
if vertex['n'] < 0:
vertex['n'] += normlen
normal_index.append(vertex['n'])
numi[
mcurrent] -= 6 # number of corners of triangle = (n-2)*3 where n is the number of corners of face
if not mcurrent in faces: faces[mcurrent] = []
faces[mcurrent].append({
'vertex': vertex_index,
'uv': uv_index,
'normal': normal_index,
'group': group,
'object': objct,
'smooth': smooth,
})
# Group
if chunks[0] == "g" and len(chunks) == 2:
group = chunks[1]
# Object
if chunks[0] == "o" and len(chunks) == 2:
objct = chunks[1]
# Materials definition
if chunks[0] == "mtllib" and len(chunks) == 2:
mtllib = chunks[1]
# Material
if chunks[0] == "usemtl":
if len(chunks) > 1:
material = chunks[1]
else:
material = ""
if not material in materials:
mcurrent = mcounter
materials[material] = mcounter
mcounter += 1
else:
mcurrent = materials[material]
# Smooth shading
if chunks[0] == "s" and len(chunks) == 2:
smooth = chunks[1]
if VERBOSE:
print "materials: ", materials
print "numv: ", numv
for g in faces:
numv[g] -= 1
numi[g] -= 1
g_vertices = []
g_normals = []
g_tex_coords = []
g_indices = []
i = 0 # vertex counter in this material
if VERBOSE:
print "len uv=", len(vertices)
for f in faces[g]:
iStart = i
for v in range(len(f['vertex'])):
g_vertices.append(vertices[f['vertex'][v] - 1])
g_normals.append(normals[f['normal'][v] - 1])
if (len(f['uv']) > 0 and len(uvs[f['uv'][v] - 1]) == 2):
g_tex_coords.append(uvs[f['uv'][v] - 1])
i += 1
n = i - iStart - 1
for t in range(1, n):
g_indices.append((iStart, iStart + t + 1, iStart + t))
model.buf.append(
Buffer(model, g_vertices, g_tex_coords, g_indices, g_normals))
n = len(model.buf) - 1
model.vGroup[g] = n
model.buf[n].indicesLen = len(model.buf[n].indices)
model.buf[n].material = (0.0, 0.0, 0.0, 0.0)
model.buf[n].ttype = GL_TRIANGLES
#for i in range(len(model.vGroup[g].normals)):
# print model.vGroup[g].normals[i],
if VERBOSE:
print
print "indices=", len(model.buf[n].indices)
print "vertices=", len(model.buf[n].vertices)
print "normals=", len(model.buf[n].normals)
print "tex_coords=", len(model.buf[n].tex_coords)
material_lib = parse_mtl(open(os.path.join(filePath, mtllib), 'r'))
for m in materials:
if VERBOSE:
print m
if 'mapDiffuse' in material_lib[m]:
tfileName = material_lib[m]['mapDiffuse']
model.buf[model.vGroup[materials[m]]].texFile = tfileName
model.buf[model.vGroup[materials[m]]].textures = [
Texture(os.path.join(filePath, tfileName), False, True)
] # load from file
else:
model.buf[model.vGroup[materials[m]]].texFile = None
model.buf[model.vGroup[materials[m]]].textures = []
if 'colorDiffuse' in material_lib[
m]: #TODO don't create this array if texture being used though not exclusive.
#TODO check this works with appropriate mtl file
redVal = material_lib[m]['colorDiffuse'][0]
grnVal = material_lib[m]['colorDiffuse'][1]
bluVal = material_lib[m]['colorDiffuse'][2]
model.buf[model.vGroup[materials[m]]].material = (redVal,
grnVal,
bluVal, 1.0)
model.buf[model.vGroup[materials[m]]].unib[3:6] = [
redVal, grnVal, bluVal
]
from pi3d.shape.Sphere import Sphere
from pi3d.util.Screenshot import screenshot
# Setup display and initialise pi3d
DISPLAY = Display.create(x=50,
y=50,
w=-100,
h=-100,
background=(0.4, 0.8, 0.8, 1))
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
#############################
# Load textures
reflcn = Texture("textures/stars.jpg")
#load environment cube
ectex = loadECfiles("textures/ecubes", "sbox_interstellar")
myecube = EnvironmentCube(size=900.0, maptype="FACES")
myecube.set_draw_details(flatsh, ectex)
# Create elevation map
mapwidth = 1000.0
mapdepth = 1000.0
mapheight = 60.0
mountimg1 = Texture("textures/mars_colour.png")
bumpimg = Texture("textures/mudnormal.jpg")
mymap = ElevationMap(mapfile="textures/mars_height.png",
width=mapwidth,
depth=mapdepth,
from pi3d.Shader import Shader
from pi3d.Light import Light
from pi3d.shape.Model import Model
from pi3d.util.Screenshot import screenshot
# Setup display and initialise pi3d
DISPLAY = Display.create(x=100, y=100, background=(0.2, 0.4, 0.6, 1))
Light((1, 1, 1))
shader = Shader("shaders/mat_reflect")
#========================================
# load bump and reflection textures
bumptex = Texture("textures/floor_nm.jpg")
shinetex = Texture("textures/stars.jpg")
# load model_loadmodel
mymodel = Model(file_string='models/teapot.egg', name='teapot', x=0, y=0, z=10)
mymodel.set_shader(shader)
# material is set in the file
mymodel.set_normal_shine(bumptex, 4.0, shinetex, 0.2, is_uv = False)
# Fetch key presses
mykeys = Keyboard()
while DISPLAY.loop_running():
mymodel.draw()
mymodel.rotateIncY(2.0)
mymodel.rotateIncZ(0.1)
def __init__(self,
textures,
shader,
camera=None,
light=None,
w=1.0,
h=1.0,
name="",
x=0.0,
y=0.0,
z=20.0,
rx=0.0,
ry=0.0,
rz=0.0,
sx=1.0,
sy=1.0,
sz=1.0,
cx=0.0,
cy=0.0,
cz=0.0):
"""Uses standard constructor for Shape. Arguments:
*textures*
must be a two dimensional list of lists of textures or strings
(which must be the path/names of image files) The array runs left
to right then down so six textures in spreadsheet notation would be
[[R1C1, R1C2], [R2C1, R2C2], [R3C1, R3C2]]
*shader*
shader to use
Extra keyword arguments:
*w*
Width.
*h*
Height.
"""
try:
nh = len(textures)
nw = len(textures[0])
super(MultiSprite, self).__init__(camera, light, name, x, y, z, rx,
ry, rz, sx, sy, sz, cx, cy, cz)
self.width = w
self.height = h
self.ttype = GL_TRIANGLES
self.verts = []
self.norms = []
self.texcoords = []
self.inds = []
ww = w / 2.0 / nw
hh = h / 2.0 / nh
self.buf = []
for i in range(nw):
for j in range(nh):
offw = w * ((1.0 - nw) / 2.0 + i) / nw
offh = -h * ((1.0 - nh) / 2.0 + j) / nh
self.verts = ((-ww + offw, hh + offh,
0.0), (ww + offw, hh + offh,
0.0), (ww + offw, -hh + offh, 0.0),
(-ww + offw, -hh + offh, 0.0))
self.norms = ((0, 0, -1), (0, 0, -1), (0, 0, -1), (0, 0,
-1))
self.texcoords = ((0.0, 0.0), (1.0, 0.0), (1.0, 1.0),
(0.0, 1.0))
self.inds = ((0, 1, 3), (1, 2, 3))
thisbuf = Buffer(self, self.verts, self.texcoords,
self.inds, self.norms)
if not isinstance(textures[j][i],
Texture): # i.e. can load from file name
textures[j][i] = Texture(textures[j][i])
thisbuf.textures = [textures[j][i]]
self.buf.append(thisbuf)
self.set_shader(shader)
self.set_2d_size() # method in Shape, default full window size
except IndexError:
print('Must supply a list of lists of Textures or strings')
return
print("move this terminal window to top of screen to see FPS")
print("=====================================================")
# Setup display and initialise pi3d
DISPLAY = Display.create(x=200, y=150, frames_per_second=25.0)
DISPLAY.set_background(0.4, 0.6, 0.8, 0.5) # r,g,b,alpha
#setup textures, light position and initial model position
Light((5, -5, 8))
#create shaders
shader = Shader("shaders/uv_reflect")
matsh = Shader("shaders/mat_reflect")
flatsh = Shader("shaders/uv_flat")
#Create textures
shapeimg = Texture("textures/straw1.jpg")
shapebump = Texture("textures/mudnormal.jpg")
waterbump = []
iFiles = glob.glob("textures/water/n_norm???.png")
iFiles.sort() # order is vital to animation!
for f in iFiles:
waterbump.append(Texture(f))
num_n = len(waterbump)
shapeshine = Texture("textures/stars.jpg")
#Create shape
myshape = MergeShape()
num = (2, 2)
asphere = Sphere(sides=32)
for i in range(num[0]):
for j in range(num[1]):
def loadFileOBJ(model, fileName):
"""Loads an obj file with associated mtl file to produce Buffer object
as part of a Shape. Arguments:
*model*
Model object to add to.
*fileName*
Path and name of obj file relative to program file.
"""
model.coordinateSystem = "Y-up"
model.parent = None
#model.childModel = [] # don't really need parent and child pointers but will speed up traversing tree
model.vNormal = False
model.vGroup = {} # holds the information for each vertex group
# read in the file and parse into some arrays, name='teapot', z=4
#import os
if fileName[0] != '/':
for p in sys.path:
if os.path.isfile(
p + '/' + fileName
): # this could theoretically get different files with same name
fileName = p + '/' + fileName
break
filePath = os.path.split(os.path.abspath(fileName))[0]
LOGGER.info(filePath)
f = open(fileName, 'r')
vertices = []
normals = []
uvs = []
faces = {}
materials = {}
material = ""
mcounter = 0
mcurrent = 0
numv = [
] #number of vertices for each material (nb each vertex will have three coords)
numi = [] #number of indices (triangle corners) for each material
mtllib = ""
# current face state
group = 0
objct = 0
smooth = 0
for l in f:
chunks = l.split()
if len(chunks) > 0:
# Vertices as (x,y,z) coordinates
# v 0.123 0.234 0.345
if chunks[0] == "v" and len(chunks) >= 4:
x = float(chunks[1])
y = float(chunks[2])
z = -float(chunks[3]) # z direction away in gl es 2.0 shaders
vertices.append((x, y, z))
# Normals in (x, y, z) form; normals might not be unit
# vn 0.707 0.000 0.707
if chunks[0] == "vn" and len(chunks) >= 4:
x = float(chunks[1])
y = float(chunks[2])
z = -float(chunks[3]) # z direction away in gl es 2.0 shaders
normals.append((x, y, z))
# Texture coordinates in (u,v)
# vt 0.500 -1.352
if chunks[0] == "vt" and len(chunks) >= 3:
u = float(chunks[1])
v = float(chunks[2])
uvs.append((u, v))
# Face
if chunks[0] == "f" and len(chunks) >= 4:
vertex_index = []
uv_index = []
normal_index = []
# Precompute vert / normal / uv lists
# for negative index lookup
vertlen = len(vertices) + 1
normlen = len(normals) + 1
uvlen = len(uvs) + 1
if len(numv) < (mcurrent + 1): numv.append(0)
if len(numi) < (mcurrent + 1): numi.append(0)
for v in chunks[1:]:
numv[mcurrent] += 1
numi[mcurrent] += 3
vertex = parse_vertex(v)
if vertex['v']:
if vertex['v'] < 0:
vertex['v'] += vertlen
vertex_index.append(vertex['v'])
if vertex['t']:
if vertex['t'] < 0:
vertex['t'] += uvlen
uv_index.append(vertex['t'])
if vertex['n']:
if vertex['n'] < 0:
vertex['n'] += normlen
normal_index.append(vertex['n'])
numi[
mcurrent] -= 6 # number of corners of triangle = (n-2)*3 where n is the number of corners of face
if not mcurrent in faces: faces[mcurrent] = []
faces[mcurrent].append({
'vertex': vertex_index,
'uv': uv_index,
'normal': normal_index,
'group': group,
'object': objct,
'smooth': smooth,
})
# Group
if chunks[0] == "g" and len(chunks) == 2:
group = chunks[1]
# Object
if chunks[0] == "o" and len(chunks) == 2:
objct = chunks[1]
# Materials definition
if chunks[0] == "mtllib" and len(chunks) == 2:
mtllib = chunks[1]
# Material
if chunks[0] == "usemtl":
if len(chunks) > 1:
material = chunks[1]
else:
material = ""
if not material in materials:
mcurrent = mcounter
materials[material] = mcounter
mcounter += 1
else:
mcurrent = materials[material]
# Smooth shading
if chunks[0] == "s" and len(chunks) == 2:
smooth = chunks[1]
LOGGER.info("materials: %s\nnumv: %s", materials, numv)
for g in faces:
numv[g] -= 1
numi[g] -= 1
g_vertices = []
g_normals = []
g_tex_coords = []
g_indices = []
i = 0 # vertex counter in this material
LOGGER.info("len uv=", len(vertices))
for f in faces[g]:
iStart = i
length = len(f['vertex'])
length_n = len(f['normal'])
#for component in 'normal', 'uv':
# if length > len(f[component]):
# LOGGER.error('There were more vertices than %ss: %d > %d',
# component, length, len(f[component]))
# length = len(f[component])
for v in range(length):
g_vertices.append(vertices[f['vertex'][v] - 1])
if length_n == length: #only use normals if there is one for each vertex
g_normals.append(normals[f['normal'][v] - 1])
if (len(f['uv']) > 0 and len(uvs[f['uv'][v] - 1]) == 2):
g_tex_coords.append(uvs[f['uv'][v] - 1])
i += 1
n = i - iStart - 1
for t in range(1, n):
g_indices.append((iStart, iStart + t + 1, iStart + t))
if len(g_normals) != len(g_vertices):
g_normals = None # force Buffer.__init__() to generate normals
model.buf.append(
Buffer(model, g_vertices, g_tex_coords, g_indices, g_normals))
n = len(model.buf) - 1
model.vGroup[g] = n
model.buf[n].indicesLen = len(model.buf[n].element_array_buffer)
model.buf[n].material = (0.0, 0.0, 0.0, 0.0)
model.buf[n].ttype = GL_TRIANGLES
LOGGER.info("indices=%s\nvertices=%s",
len(model.buf[n].element_array_buffer),
len(model.buf[n].array_buffer))
try:
material_lib = parse_mtl(open(os.path.join(filePath, mtllib), 'r'))
for m in materials:
LOGGER.info(m)
if 'mapDiffuse' in material_lib[m]:
tfileName = material_lib[m]['mapDiffuse']
model.buf[model.vGroup[materials[m]]].texFile = tfileName
model.buf[model.vGroup[materials[m]]].textures = [
Texture(filePath + '/' + tfileName, blend=False, flip=True)
] # load from file
else:
model.buf[model.vGroup[materials[m]]].texFile = None
model.buf[model.vGroup[materials[m]]].textures = []
if 'colorDiffuse' in material_lib[
m]: #TODO don't create this array if texture being used though not exclusive.
#TODO check this works with appropriate mtl file
redVal = material_lib[m]['colorDiffuse'][0]
grnVal = material_lib[m]['colorDiffuse'][1]
bluVal = material_lib[m]['colorDiffuse'][2]
model.buf[model.vGroup[materials[m]]].material = (redVal,
grnVal,
bluVal,
1.0)
model.buf[model.vGroup[materials[m]]].unib[3:6] = [
redVal, grnVal, bluVal
]
except:
LOGGER.warning('no material specified')
# Setup display and initialise pi3d
DISPLAY = Display.create(x=100, y=100)
DISPLAY.set_background(0.4, 0.8, 0.8, 1) # r,g,b,alpha
# yellowish directional light blueish ambient light
Light(lightpos=(1, -1, -3),
lightcol=(1.0, 1.0, 0.7),
lightamb=(0.15, 0.1, 0.3))
#========================================
# load shader
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
tree2img = Texture("textures/tree2.png")
tree1img = Texture("textures/tree1.png")
hb2img = Texture("textures/hornbeam2.png")
bumpimg = Texture("textures/grasstile_n.jpg")
reflimg = Texture("textures/stars.jpg")
rockimg = Texture("textures/rock1.jpg")
clash = Clashtest()
FOG = ((0.3, 0.3, 0.4, 0.5), 650.0)
TFOG = ((0.1, 0.14, 0.12, 0.3), 150.0)
#myecube = EnvironmentCube(900.0,"HALFCROSS")
ectex = loadECfiles("textures/ecubes", "sbox")
myecube = EnvironmentCube(size=900.0, maptype="FACES", name="cube")
myecube.set_draw_details(flatsh, ectex)
def loadFileEGG(model, fileName):
"""Loads an panda3d egg file to produce Buffer object
as part of a Shape.
Arguments:
*model*
Model object to add to.
*fileName*
Path and name of egg file relative to top directory.
"""
model.coordinateSystem = "Y-up"
model.materialList = {}
model.textureList = {}
model.vertexGroupList = {}
model.vertexList = []
model.polygonList = []
model.childModelList = []
model.parentModel = None
model.childModel = [] # don't really need parent and child pointers but will speed up traversing tree
model.vNormal = False
model.vGroup = {} # holds the information for each vertex group
# read in the file and parse into some arrays
filePath = os.path.split(os.path.abspath(fileName))[0]
if VERBOSE:
print(filePath)
f = open(fileName, 'r')
l = f.read() # whole thing as a string in memory this will only work for reasonably small files!!!
############### function to parse file as one off process to avoid re-traversing string #########
# convertes the '<a> b { c <d> e {f} <g> h {i} }' structure
# into nested arrays ['a', 'b', 'c',[['d','e','',['','','f',[]]],['g','h','',['','','i',[]]]]]
def pRec(x, bReg, l, i):
while 1:
try:
nxtFind = advance_iterator(bReg)
j = nxtFind.start()
except:
return i+1
c = l[j]
if c == "<": # add entry to array at this level
if len(x[3]) == 0: x[2] = l[i:j].strip() # text after "{" and before "<Tabxyz>"
i = j+1 # save marker for start of descriptor
x[3].append(["", "", "", []])
elif c == "{":
xn = x[3][len(x[3])-1]
tx = l[i-1:j].strip().split()
xn[0] = tx[0] #x[0] & x[1] is the "<Tabxyz>" & "123" prior to "{"
xn[1] = tx[1] if len(tx) > 1 else ""
i = pRec(xn, bReg, l, j+1)
else: #i.e. c="}" # go up one level of recursion
if len(x[3]) == 0: x[2] = l[i:j].strip()
return j+1
################### end of pRec #################
####### go through all the nested <Groups> ####################
def groupDrill(gp, np):
structVList = {}
offsetVList = {}
structPList = []
offset = 0
#numv = 0
#numi = 0
for x in gp:
if len(x) == 0: continue
if ("<Group>" in x[0]):
if len(x[1]) > 0:
nextnp = np+x[1]
else:
nextnp = np+str(randint(10000, 99999))
groupDrill(x[3], nextnp)
else:
#build vertex, polygon, normal, triangles, UVs etc etc
if "<VertexPool>" in x[0]:
vp = x[1]
structVList[vp] = []
offsetVList[vp] = offset
for v in x[3]:
#if "<Vertex>" in v[0]: #try with this test first!
coords = [float(n) for n in v[2].strip().split()] # before first < error if no coords!
# texture mapping
UVcoords = []
normal = []
for u in v[3]:
if "<UV>" in u[0]: UVcoords = [float(n) for n in u[2].strip().split()]
#TODO get UVtangent and UVbinormal out of UVset (and use them!)
# if ("<Tangent>" in vList[v]): UVtangent = [float(n) for n in (extBracket("<Tangent>", vList[v]))[0].split()] # not sure how to use this at this stage
#else: UVtangent = []
# if ("<Binormal>" in vList[v]): UVbinormal = [float(n) for n in (extBracket("<Binormal>", vList[v]))[0].split()] # not sure how to use this at this stage
#else: UVbinormal = []
# normals, used in 'smoothing' edges between polygons
if "<Normal>" in u[0]: normal = [float(n) for n in u[2].strip().split()]
vInt = int(v[1])
while (len(structVList[vp]) < (vInt+1)): structVList[vp].append("")
structVList[vp][vInt] = (vertex(coords, UVcoords, normal))
offset += 1
#
# now go through splitting out the Polygons from this Group same level as vertexGroup
if "<Polygon>" in x[0]:
normal = []
rgba = []
MRef = ""
TRef = ""
for p in x[3]:
if ("<Normal>" in p[0]): normal = [float(n) for n in p[2].strip().split()]
if ("<RGBA>" in p[0]): rgba = [float(n) for n in p[2].strip().split()]
if ("<MRef>" in p[0]): MRef = p[2].strip()
if ("<TRef>" in p[0]): TRef = p[2].strip()
if ("<VertexRef>" in p[0]):
vref = []
for n in p[2].strip().split():
vref.append(int(n))
#numv += 1
#numi += 3
#numi -= 6 # number of corners of triangle = (n-2)*3 where n is the number of corners of face
vpKey = p[3][0][2].strip() # ought to do a for r in p[3]; if "Ref in...
# add to list
#while (len(structPList) < (p+1)): structPList.append("")
#
structPList.append(polygon(normal, rgba, MRef, TRef, vref, vpKey))
# now go through the polygons in order of vertexPool+id, trying to ensure that the polygon arrays in each group are built in the order of vertexPool names
# only cope with one material and one texture per group
#numv -= 1
#numi -= 1
g_vertices = []
g_normals = []
g_tex_coords = []
g_indices = []
nv = 0 # vertex counter in this material
#ni = 0 # triangle vertex count in this material
gMRef = ""
gTRef = ""
nP = len(structPList)
for p in xrange(nP):
if (len(structPList[p].MRef) > 0): gMRef = structPList[p].MRef
else: gMRef = ""
if (len(structPList[p].TRef) > 0): gTRef = structPList[p].TRef
else: gTRef = ""
vpKey = structPList[p].vpKey
vref = structPList[p].vref
startV = nv
for j in vref:
if (len(structVList[vpKey][j].normal) > 0): model.vNormal = True
else: model.vNormal = False
if model.coordinateSystem == "z-up":
thisV = [structVList[vpKey][j].coords[1], structVList[vpKey][j].coords[2], -structVList[vpKey][j].coords[0]]
if model.vNormal:
thisN = [structVList[vpKey][j].normal[1], structVList[vpKey][j].normal[2], -structVList[vpKey][j].normal[0]]
else:
thisV = [structVList[vpKey][j].coords[0], structVList[vpKey][j].coords[1], -structVList[vpKey][j].coords[2]]
if model.vNormal:
thisN = [structVList[vpKey][j].normal[0], structVList[vpKey][j].normal[1], -structVList[vpKey][j].normal[2]]
g_vertices.append(thisV)
if model.vNormal: nml = thisN
else: nml = structPList[p].normal
g_normals.append(nml)
uvc = structVList[vpKey][j].UVcoords
if (len(uvc) == 2):
g_tex_coords.append(uvc)
else:
g_tex_coords.append([0.0, 0.0])
nv += 1
n = nv - startV - 1
for j in range(1, n):
g_indices.append((startV, startV + j + 1, startV + j))
ilen = len(g_vertices)
if ilen > 0:
model.buf.append(Buffer(model, g_vertices, g_tex_coords, g_indices, g_normals))
n = len(model.buf) - 1
model.vGroup[np] = n
model.buf[n].indicesLen = ilen
model.buf[n].material = (0.0, 0.0, 0.0, 0.0)
model.buf[n].ttype = GL_TRIANGLES
# load the texture file TODO check if same as previously loaded files (for other loadModel()s)
if (gTRef in model.textureList):
model.buf[model.vGroup[np]].textures = [model.textureList[gTRef]["texID"]]
model.buf[model.vGroup[np]].texFile = model.textureList[gTRef]["filename"]
else:
model.buf[model.vGroup[np]].textures = []
model.buf[model.vGroup[np]].texFile = None
#TODO don't create this array if texture being used but should be able to combine
if (gMRef in model.materialList):
redVal = float(model.materialList[gMRef]["diffr"])
grnVal = float(model.materialList[gMRef]["diffg"])
bluVal = float(model.materialList[gMRef]["diffb"])
model.buf[model.vGroup[np]].material = (redVal, grnVal, bluVal, 1.0)
model.buf[model.vGroup[np]].unib[3:6] = [redVal, grnVal, bluVal]
else: model.buf[model.vGroup[np]].material = (0.0, 0.0, 0.0, 0.0)
####### end of groupDrill function #####################
bReg = re.finditer('[{}<]', l)
xx = ["", "", "", []]
pRec(xx, bReg, l, 0)
l = None #in case it's running out of memory?
f.close()
for x in xx[3]:
if "<Texture>" in x[0]:
model.textureList[x[1]] = {}
for i in xrange(len(x[3])): model.textureList[x[1]][x[3][i][1]] = x[3][i][2]
model.textureList[x[1]]["filename"] = x[2].strip("\"")
if VERBOSE:
print(filePath, model.textureList[x[1]]["filename"])
model.textureList[x[1]]["texID"] = Texture(os.path.join(filePath, model.textureList[x[1]]["filename"]), False, True) # load from file
if "<CoordinateSystem>" in x[0]:
model.coordinateSystem = x[2].lower()
if "<Material>" in x[0]:
model.materialList[x[1]] = {}
for i in xrange(len(x[3])): model.materialList[x[1]][x[3][i][1]] = x[3][i][2]
if "<Group>" in x[0]:
groupDrill(x[3], x[1])
from pi3d.shape.Building import Building, corridor, SolidObject, Size, Position
from pi3d.util.Screenshot import screenshot
from pi3d.Light import Light
from pi3d.event.Event import InputEvents
# Setup display and initialise pi3d
DISPLAY = Display.create(x=150, y=150, background=(0.4, 0.8, 0.8, 1))
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
#############################
# Load textures
blockimg = Texture("textures/squareblocks4.png")
roofedgeimg = Texture("textures/roofedging.png")
roofimg = Texture("textures/Roof.png")
greenimg = Texture("textures/squareblocks4green.png")
ectex = loadECfiles("textures/ecubes", "sbox", "jpg")
myecube = EnvironmentCube(size=900.0, maptype="FACES")
myecube.set_draw_details(flatsh, ectex)
# Create elevation map
mapwidth=1000.0
mapdepth=1000.0
mapheight=60.0
floorimg = Texture("textures/dunes3_512.jpg")
bumpimg = Texture("textures/mudnormal.jpg")
mymap = ElevationMap(mapfile="textures/mountainsHgt2.png",
width=mapwidth, depth=mapdepth, height=mapheight,
