def sphereshade():
lx, ly, lz = 700,100,0
vx, vy = 250, 250
Ia = (100, 100, 100)
Id = (255, 0, 0)
Is = (255, 150, 150)
Ks = (128, 128, 128)
zbuf = [[None for _ in xrange(500)] for _ in ge(500)]
tris = transform.T(250, 250, 0) * edgeMtx.sphere(200, .02)
sts = edgeMtx.edgemtx()
edgeMtx.addCircle(sts,0,0,0,500,.05)
sts = transform.T(250,250,0)*transform.R('y', -45)*transform.R('x', 90)*sts
sts = zip(*sts)[::2]
ke=0
for lx,ly,lz,_ in sts:
img = Image(500,500)
triList = []
for i in range(0, len(tris[0]) - 2, 3):
triList.append(tuple(tris[0][i : i + 3] + tris[1][i : i + 3] + tris[2][i : i + 3]))
triList.sort(key=lambda t: sum(t[6:9]))
print 'sorted lis'
for x1, x2, x3, y1, y2, y3, z1, z2, z3 in triList:
nx1, ny1, nz1 = normalize(x1 - 250, y1 - 250, z1)
nx2, ny2, nz2 = normalize(x2 - 250, y2 - 250, z2)
nx3, ny3, nz3 = normalize(x3 - 250, y3 - 250, z3)
shadePix = drawShadedTri(x1,y1,z1,x2,y2,z2,x3,y3,z3,nx1,ny1,nz1,nx2,ny2,nz2,nx3,ny3,nz3,lx,ly,lz,vx,vy,vz,Ia,Id,Is,Ka,Kd,Ks,a,zbuf)
img.setPixels(shadePix)
img.savePpm('shade/%d.ppm'%(ke))
if ke == 0: img.display()
ke+=1
print ke
def marioTest():
from time import time
tc = {}
chdir('mario')
triset = obj.parse('mario.obj','mario.mtl')
mat = transform.T(250, 400, 0) * transform.R('z', 180) * transform.S(1.5,1.5,1.5)
for i in range(len(triset)):
triset[i][0] = mat * triset[i][0]
img = Image(500,500)
mat = transform.T(250,400,0)*transform.R('y',5)*transform.T(-250,-400,0)
textureTriMtxs(triset,img,tc)
print len(tc)
img.display()
for i in range(72):
print 'making image...',
a = time()
img = Image(500,500)
print (time() - a) * 1000, 'ms'
print 'transforming...',
a = time()
for j in range(len(triset)):
triset[j][0] = mat * triset[j][0]
print (time() - a) * 1000, 'ms'
print 'texturing...',
a = time()
textureTriMtxs(triset, img,tc)
print (time() - a) * 1000, 'ms'
print 'saving...',
a = time()
img.savePpm('../animar/%d.ppm'%(i))
print (time() - a) * 1000, 'ms'
print i, 'drawn'
def addTorusPoints(m, x, y, z, r, R, mainStep=0.02, ringStep=0.05):
steps = int(math.ceil(1 / mainStep))
mCircle = edgemtx()
addPoint(mCircle, r, 0, 0)
addCircle(mCircle, 0, 0, 0, r, ringStep)
addPoint(mCircle, mCircle[0][-1], mCircle[1][-1], 0)
for theta in range(steps):
xOuter = x + R * math.cos(theta * 2 * math.pi / steps)
zOuter = z + R * math.sin(theta * 2 * math.pi / steps)
movedCircle = transform.T(xOuter, y, zOuter) * transform.R(
'y', -theta * 360. / steps) * mCircle
addToEdgeMtx(m, movedCircle)
return m
def runFrame(frame, commands):
step = 0.02
cstack = [TransMatrix()]
img = Image(500, 500)
objects = []
for command in commands:
inp = command[0]
args = command[1:]
if inp == 'line':
edges = edgemtx()
addEdge(edges, *command[1:7])
edges = cstack[-1] * edges
objects.append((EDGE, edges))
#drawEdges(cstack[-1] * edges, img)
elif inp == 'ident':
cstack[-1] = TransMatrix()
elif inp == 'scale':
kval = frame[args[3]]
cstack[-1] *= transform.S(*args[:3]) * transform.S(
kval, kval, kval) # scaling a scale with scale
elif inp == 'move':
kval = frame[args[3]]
cstack[-1] *= transform.T(*[i * kval for i in args[:3]])
elif inp == 'rotate':
kval = frame[args[2]]
cstack[-1] *= transform.R(args[0], args[1] * kval)
elif inp == 'circle':
edges = edgemtx()
addCircle(*(edges, ) + command[1:5] + (.01, ))
edges = cstack[-1] * edges
objects.append((EDGE, edges))
#drawEdges(cstack[-1] * edges, img)
elif inp == 'bezier':
edges = edgemtx()
addBezier(*(edges, ) + command[1:9] + (.01, ))
edges = cstack[-1] * edges
objects.append((EDGE, edges))
#drawEdges(cstack[-1] * edges, img)
elif inp == 'hermite':
edges = edgemtx()
addHermite(*(edges, ) + command[1:9] + (.01, ))
edges = cstack[-1] * edges
objects.append((EDGE, edges))
#drawEdges(cstack[-1] * edges, img)
elif inp == 'clearstack':
cstack = [TransMatrix()]
elif inp == 'box':
vxs = cstack[-1] * shape.genBoxPoints(*command[1:7])
tris = shape.genBoxTris()
shape.fixOverlaps(vxs, tris)
objects.append((POLY, flatTrisFromVT(vxs, tris)))
#polys = edgemtx()
#shape.addBox(*(polys,) + command[1:7])
#polys = cstack[-1] * polys
#objects.append((POLY, polys))
#drawTriangles(cstack[-1] * polys, img, wireframe=True)
elif inp == 'sphere':
vxs = cstack[-1] * shape.genSpherePoints(*command[1:5] + (step, ))
tris = shape.genSphereTris(step)
shape.fixOverlaps(vxs, tris)
objects.append((POLY, autoTrianglesFromVT(vxs, tris)))
#polys = edgemtx()
#shape.addSphere(*(polys,) + command[1:5] + (.05,))
#polys = cstack[-1] * polys
#objects.append((POLY, polys))
#drawTriangles(cstack[-1] * polys, img, wireframe=True)
elif inp == 'torus':
vxs = cstack[-1] * shape.genTorusPoints(*command[1:6] +
(step, step))
tris = shape.genTorusTris(step, step)
shape.fixOverlaps(vxs, tris)
objects.append((POLY, autoTrianglesFromVT(vxs, tris)))
#polys = edgemtx()
#shape.addTorus(*(polys,) + command[1:6] + (.05, .05))
#polys = cstack[-1] * polys
#objects.append((POLY, polys))
#drawTriangles(cstack[-1] * polys, img, wireframe=True)
elif inp == 'push':
cstack.append(cstack[-1].clone())
elif inp == 'pop':
cstack.pop()
return objects
def run(filename):
"""
This function runs an mdl script
"""
color = [255, 255, 255]
tmp = TransMatrix()
p = mdl.parseFile(filename)
#print p
if p:
(commands, symbols) = p
else:
print "Parsing failed."
return
frames = None
basename = 'anim'
varying = False
# pass 1
for command in commands:
cmd = command[0]
args = command[1:]
if cmd == 'frames':
frames = args[0]
elif cmd == 'basename':
basename = args[0]
elif cmd == 'vary':
varying = True
if varying:
if frames is None:
err('Frames not set.')
if basename == 'anim':
warn('Basename not set, using default of anim.')
# pass 2
upd = lambda d, n: 0 if d.update(n) else d
frameList = [
upd({k: v[1]
for k, v in symbols.iteritems() if v[0] == 'knob'}, {None: 1})
for _ in range(frames)
]
for command in commands:
cmd = command[0]
args = command[1:]
if cmd == 'set':
for frame in frameList:
frame[args[0]] = args[1]
elif cmd == 'setall':
for frame in frameList:
for key in frame.keys():
frame[key] = args[0]
elif cmd == 'vary':
val = args[3]
inc = (1. * args[4] - args[3]) / (args[2] - args[1])
for frid in range(args[1], args[2] + 1):
frameList[frid][args[0]] = val
val += inc
imgs = []
# pass for each frame
print 'Pass 2 complete, beginning image rendering...'
a = time.time()
for frame in frameList:
objects = runFrame(frame, commands)
img = Image(500, 500)
draw(objects, img)
imgs.append(img)
print 'Images rendered in %f ms' % (int(
(time.time() - a) * 1000000) / 1000.)
print 'Saving images...'
a = time.time()
for i in range(len(imgs)):
imgs[i].savePpm('anim/%s%03d.ppm' % (basename, i))
print 'Images saved in %f ms' % (int(
(time.time() - a) * 1000000) / 1000.)
print 'Creating animation... (converting to gif)'
a = time.time()
makeAnimation(basename, 'ppm')
print 'Animation created in %f ms' % (int(
(time.time() - a) * 1000000) / 1000.)
# clearAnim()
else:
cstack = [TransMatrix()]
frc = 0
img = Image(500, 500)
objects = []
for command in commands:
inp = command[0]
if inp == 'line':
edges = edgemtx()
addEdge(edges, *command[1:7])
edges = cstack[-1] * edges
objects.append((EDGE, edges))
#drawEdges(cstack[-1] * edges, img)
elif inp == 'ident':
cstack[-1] = TransMatrix()
elif inp == 'scale':
cstack[-1] *= transform.S(*command[1:4])
elif inp == 'move':
cstack[-1] *= transform.T(*command[1:4])
elif inp == 'rotate':
cstack[-1] *= transform.R(*command[1:3])
elif inp == 'display':
drawObjects(objects, img)
img.flipUD().display()
elif inp == 'save':
drawObjects(objects, img)
if inp[-4:] == '.ppm':
img.flipUD().savePpm(command[1])
else:
img.flipUD().saveAs(command[1])
elif inp == 'saveframe':
drawObjects(objects, img)
img.flipUD().savePpm('%s%d.ppm' % (command[1], frc))
frc += 1
elif inp == 'circle':
edges = edgemtx()
addCircle(*(edges, ) + command[1:5] + (.01, ))
edges = cstack[-1] * edges
objects.append((EDGE, edges))
#drawEdges(cstack[-1] * edges, img)
elif inp == 'bezier':
edges = edgemtx()
addBezier(*(edges, ) + command[1:9] + (.01, ))
edges = cstack[-1] * edges
objects.append((EDGE, edges))
#drawEdges(cstack[-1] * edges, img)
elif inp == 'hermite':
edges = edgemtx()
addHermite(*(edges, ) + command[1:9] + (.01, ))
edges = cstack[-1] * edges
objects.append((EDGE, edges))
#drawEdges(cstack[-1] * edges, img)
elif inp == 'clear':
img = Image(500, 500)
elif inp == 'clearstack':
cstack = [TransMatrix()]
elif inp == 'box':
polys = edgemtx()
shape.addBox(*(polys, ) + command[1:7])
polys = cstack[-1] * polys
objects.append((POLY, polys))
#drawTriangles(cstack[-1] * polys, img, wireframe=True)
elif inp == 'sphere':
polys = edgemtx()
shape.addSphere(*(polys, ) + command[1:5] + (.05, ))
polys = cstack[-1] * polys
objects.append((POLY, polys))
#drawTriangles(cstack[-1] * polys, img, wireframe=True)
elif inp == 'torus':
polys = edgemtx()
shape.addTorus(*(polys, ) + command[1:6] + (.05, .05))
polys = cstack[-1] * polys
objects.append((POLY, polys))
#drawTriangles(cstack[-1] * polys, img, wireframe=True)
elif inp == 'push':
cstack.append(cstack[-1].clone())
elif inp == 'pop':
cstack.pop()
addEdgesFromParam(m, lambda t: 250 + 100 * math.cos(t * 2 * math.pi),
lambda t: 250 + 100 * math.sin(t * 2 * math.pi),
lambda t: 0, 0.01)
img = Image(500, 500)
drawEdges(m, img)
img.display()
def circleTest2():
m = edgemtx()
for theta in range(36):
costheta = math.cos(theta)
def fx(t):
return 250 + 100 * math.cos(t * 2 * math.pi) * costheta
if __name__ == '__main__':
import transform
m = transform.T(250, 250, 0) * transform.R('x', 30) * transform.R(
'y', 30) * sphere(200, .05)
mat = transform.T(250, 250, 0) * transform.R('y', 5) * transform.T(
-250, -250, 0)
for i in range(72):
img = Image(500, 500)
drawTriangles(m, img)
m = mat * m
print i, 'iter'
img.savePpm('sphere/%d.ppm' % (i))
z + ai[2] + aj[2] + ak[2])
norm = [0, 0, 0]
dir = 1 - k * 2
norm[3 - i - j] = dir
addEdge(n, *norm * 2)
ak[3 - i - j] += dim[3 - i - j]
return m, n
if __name__ == '__main__':
from base import Image
import transform
cube = edgemtx()
addBoxPoints(cube, 125, 125, -125, 250, 250, 250)
m = edgemtx()
xTrans = transform.T(250, 250, 0) * transform.R('x', 18) * transform.T(
-250, -250, 0)
yTrans = transform.T(250, 250, 0) * transform.R('y', 18) * transform.T(
-250, -250, 0)
for d in 'xyz':
trans = transform.T(250, 250, 0) * transform.R(d, 15) * transform.T(
-250, -250, 0)
for i in range(24):
addToEdgeMtx(m, cube)
cube = trans * cube
cube = m
m = edgemtx()
cube = transform.T(250, 250, 0) * transform.R('y', 49) * transform.R(
'x', 67) * transform.R('z', 23) * transform.T(-250, -250, 0) * cube
img = Image(500, 500)
drawEdges(cube, img)
def camtest():
import shape
fov = 100
cam = Camera(0.5,0.5,0.8,0,0,0,0,0,1 / math.tan(fov / 2.))
camargs = [100,100,-50,-300]
camT = transform.C3(*camargs)*transform.T(-250, -250,-175)
print camT
ncamT = transform.C3invT(*camargs)
print ncamT
v = [250,250,1000]
lights = [Light(500,0,500,(20,20,20),(200,200,200),(255,255,255)),
Light(500,500,200,(20,20,20),(200,200,200),(255,255,255)),
Light(0,250,500,(20,20,20),(200,200,200),(255,255,255))
]
camlights = []
for l in lights:
x = dot4xyz(camT[0], l.x, l.y, l.z)
y = dot4xyz(camT[1], l.x, l.y, l.z)
z = dot4xyz(camT[2], l.x, l.y, l.z)
w = dot4xyz(camT[3], l.x, l.y, l.z)*1.
print x/w*250,y/w*250,z/w*250
camlights.append(Light(x/w*250, y/w*250, z/w*250,l.Ia,l.Id,l.Is))
tris, norms = shape.box(200,200,-100,100,100,200)
print norms
print ncamT * norms
print list(triIter(tris))
trot = transform.R('y',5)
nrot = transform.TransMatrix()
nrot.lst = matrix.transpose(transform.R('y',-5))
tmat = transform.T(250,250,0)*trot*transform.T(-250,-250,0)
tris = tmat*tmat*tmat*tris
norms= trot*trot*trot*norms
print norms
print ncamT*norms
amb = Texture(False, [255,0,0])
diff = Texture(False, [255,0,0])
spec = Texture(False, [255,150,150])
mat = Material(amb, diff, spec, 10)
for i in range(72):
#print tris
tricam = camT * tris
#print tricam
#tricam[3] = [1.] * len(tricam[3])
#tricam = transform.T(*v) * tricam
print 'trans done'
a = time()
zbuf = [[None]*500 for _ in range(500)]
img = Image(500,500)
trit = list(triIter(tricam))
#print trit,tricam
trit.sort(key=lambda tri: -tri[0][2] - tri[1][2] - tri[2][2])
normcam = ncamT*norms
normt = []
for j in range(len(normcam[0])):
sgn = (normcam[3][j] > 0) * 2 - 1
normt.append(normalize(normcam[0][j]*sgn, normcam[1][j]*sgn, normcam[2][j]*sgn))
print normt
#print len(trit), len(normt)
for j in range(len(trit)):
# (p1, p2, p3, mat, vx, vy, vz, lights, texcache, zbuf):
t = trit[j]
ps = []
for pt in t:
pt[0]+=250
pt[1]+=250
pt[2]+=0
print pt
ps.append(Point(*pt + normt[j] + [0,0]))
img.setPixels(renderTriangle(*ps + [mat] + v + [camlights, {}, zbuf]))
for t in trit:
l = line(*t[0][:2]+t[1][:2])
l += line(*t[0][:2]+t[2][:2])
l += line(*t[2][:2]+t[1][:2])
img.setPixels([p + ((0,0,0),) for p in l])
for j in range(len(trit)):
t = trit[j]
ps = []
for pt in t:
nls = line(pt[0] - 4, pt[1], pt[0] + 4, pt[1])
nls += line(pt[0], pt[1] - 4, pt[0], pt[1] + 4)
nls += line(pt[0] - 4, pt[1] - 4, pt[0] + 4, pt[1] + 4)
nls += line(pt[0] - 4, pt[1] + 4, pt[0] + 4, pt[1] - 4)
nls += line(pt[0], pt[1], pt[0] + normt[j][0]*20, pt[1] + normt[j][1]*20)
print normt[j][0], normt[j][1]
img.setPixels([p + ((0,255,0),) for p in nls])
img.savePpm('cube/%d.ppm'%(i))
tris = tmat * tris
norms = nrot * norms
print norms
print i, (time() - a) * 1000, 'ms'
def marioshadetest():
img = Image(500, 500)
# TODO implement lights, texcache, zbuf
lights = [Light(409.1, 409.1, 0, (30, 10, 10), (200, 50, 50), (255, 150, 150)),
Light(25, 250, 50, (5, 30, 10), (50, 200, 50), (150, 255, 150)),
Light(250, 25, 100, (10, 20, 30), (50, 50, 200), (150, 150, 255))]
fov = 90
cam = Camera(250, 250, 200, 0, 0, 0, -250,-250, 1 / math.tan(fov / 2.))
camT = transform.T(cam.x,cam.y,cam.z)*transform.C2(cam, 500, -500)
print matrix.toStr(camT)
lballs = []
sphere = edgeMtx.sphere(20, .1)
for l in lights:
lightball = transform.T(l.x, l.y, l.z) * sphere
lballs.append([lightball, l.Id])
texcache = {}
chdir('mario')
tris = obj.parse('mario.obj','mario.mtl')
mrot = transform.R('z', 180)*transform.R('y', 180)
m = transform.T(250,380,0)*transform.S(1.2, 1.2, 1.2)*mrot
apply(m, tris)
applyNorms(mrot, tris)
# ROTATE MARIO
# mrot = transform.R('y', 5)
# m = transform.T(250, 380, 0) * mrot * transform.T(-250, -380, 0)
# ROTATE LIGHTS
m = transform.T(250, 250, 0) * transform.R('z', 5) * transform.T(-250, -250, 0)
for i in range(72):
a = time()
zbuf = [[None]*500 for j in xrange(500)]
img = Image(500, 500)
for ball, col in lballs:
edgeMtx.drawTriangles(ball, img, col, col, False)
tricam = applied(camT, tris)
tricam.sort(key=lambda tri: -tri[0].z - tri[1].z - tri[2].z)
for tri in tricam:
#for j in xrange(3):
# pt = tri[j]
# pt.x += cam.x
# pt.y += cam.y
# pt.z += cam.z
img.setPixels(renderTriangle(*tri + [cam.vx, cam.vy, cam.vz, lights, texcache, zbuf]))
if i == 0:
img.display()
img.saveAs('proj.png')
img.savePpm('../marshade/%d.ppm' % (i))
# ROTATE MARIO
# apply(m, tris)
# applyNorms(mrot, tris)
# ROTATE LIGHTS
for ball in lballs:
ball[0] = m * ball[0]
for l in lights:
x = dot4xyz(m[0], l.x, l.y, l.z)
y = dot4xyz(m[1], l.x, l.y, l.z)
z = dot4xyz(m[2], l.x, l.y, l.z)
l.x = x
l.y = y
l.z = z
print i, 'in', (time() - a) * 1000, 'ms'
chdir('..')
img.display()
img.saveAs('marshade.png')
