starting over

1 files changed, 295 insertions, 295 deletions

diff --git a/demo/sgi/gl_panel/flying/flying.py b/demo/sgi/gl_panel/flying/flying.py
index e6fd823..b51f466 100755
--- a/demo/sgi/gl_panel/flying/flying.py
+++ b/demo/sgi/gl_panel/flying/flying.py
@@ -7,369 +7,369 @@ import DEVICE, time
 import objectdef, light, panel, material
 
 def fixmatact (p) :
- p.diffR.fixact ()
- p.diffG.fixact ()
- p.diffB.fixact ()
- p.specR.fixact ()
- p.specG.fixact ()
- p.specB.fixact ()
- p.shine.fixact ()
+	p.diffR.fixact ()
+	p.diffG.fixact ()
+	p.diffB.fixact ()
+	p.specR.fixact ()
+	p.specG.fixact ()
+	p.specB.fixact ()
+	p.shine.fixact ()
 
 def fixlichtact (p) :
- p.R.fixact ()
- p.G.fixact ()
- p.B.fixact ()
- p.X.fixact ()
- p.Y.fixact ()
- p.Z.fixact ()
- p.local.fixact ()
+	p.R.fixact ()
+	p.G.fixact ()
+	p.B.fixact ()
+	p.X.fixact ()
+	p.Y.fixact ()
+	p.Z.fixact ()
+	p.local.fixact ()
 
 def cbsetlight (a) :
- p = a.back
- setlight (p, a.label)
+	p = a.back
+	setlight (p, a.label)
 
 def cbsetmaterial (a) :
- p = a.back
- setmaterial (p, a.label)
+	p = a.back
+	setmaterial (p, a.label)
 
 mater = [0]
 licht = [0]
 
 def setmaterial (p, mname) :
- #
- mater [0:1] = [material.materdict [mname]]
- #
- p.diffR.val = mater [0][1]
- p.diffG.val = mater [0][2]
- p.diffB.val = mater [0][3]
- #
- p.specR.val = mater [0][5]
- p.specG.val = mater [0][6]
- p.specB.val = mater [0][7]
- #
- p.shine.val = mater [0][9] / 128.0
- fixmatact (p)
+	#
+	mater [0:1] = [material.materdict [mname]]
+	#
+	p.diffR.val = mater [0][1]
+	p.diffG.val = mater [0][2]
+	p.diffB.val = mater [0][3]
+	#
+	p.specR.val = mater [0][5]
+	p.specG.val = mater [0][6]
+	p.specB.val = mater [0][7]
+	#
+	p.shine.val = mater [0][9] / 128.0
+	fixmatact (p)
 
 def setlight (p, mname) :
- #
- licht [0:1] = [material.lichtdict [mname]]
- #
- p.R.val = licht [0][1]
- p.G.val = licht [0][2]
- p.B.val = licht [0][3]
- #
- p.X.val = (licht [0][5] + 10.0) / 20.0
- p.Y.val = (licht [0][6] + 10.0) / 20.0
- p.Z.val = (licht [0][7] + 10.0) / 20.0
- #
- p.local.val = licht [0][8]
- #
- fixlichtact (p)
+	#
+	licht [0:1] = [material.lichtdict [mname]]
+	#
+	p.R.val = licht [0][1]
+	p.G.val = licht [0][2]
+	p.B.val = licht [0][3]
+	#
+	p.X.val = (licht [0][5] + 10.0) / 20.0 
+	p.Y.val = (licht [0][6] + 10.0) / 20.0
+	p.Z.val = (licht [0][7] + 10.0) / 20.0
+	#
+	p.local.val = licht [0][8]
+	#
+	fixlichtact (p)
 
 def cbmaterial (a) :
- #
- if mater[0] = 0 : return
- #
- p = a.back
- mater [0][5:8] = [p.diffR.val, p.diffG.val, p.diffB.val]
- mater [0][1:4] = [p.specR.val, p.specG.val, p.specB.val]
- mater [0][9:10] = [128.0 * p.shine.val]
- light.bindlight (0)
+	#
+	if mater[0] = 0 : return
+	#
+	p = a.back
+	mater [0][5:8] = [p.diffR.val, p.diffG.val, p.diffB.val]
+	mater [0][1:4] = [p.specR.val, p.specG.val, p.specB.val]
+	mater [0][9:10] = [128.0 * p.shine.val]
+	light.bindlight (0)
 
 def cblight (a) :
- #
- if licht[0] = 0 : return
- #
- p = a.back
- licht [0][1:4] = [p.R.val, p.G.val, p.B.val]
- licht [0][5:8] = [20.0 * p.X.val - 10.0, 20.0 * p.Y.val - 10.0, 20.0 * p.Z.val - 10.0]
- if p.local.val = 0.0 :
- licht [0][8:9] = [0.0]
- else:
- licht [0][8:9] = [1.0]
- #
- light.bindlight (0)
+	#
+	if licht[0] = 0 : return
+	#
+	p = a.back
+	licht [0][1:4] = [p.R.val, p.G.val, p.B.val]
+	licht [0][5:8] = [20.0 * p.X.val - 10.0, 20.0 * p.Y.val - 10.0, 20.0 * p.Z.val - 10.0]
+	if p.local.val = 0.0 :
+		licht [0][8:9] = [0.0]
+	else:
+		licht [0][8:9] = [1.0]
+	#
+	light.bindlight (0)
 
 #
 # initgl : initialize window, pipeline, light, viewing
 #
 def initgl () :
- #
- # init window
- #
- foreground ()
- keepaspect (1, 1)
- prefposition (100, 500, 100, 500)
- w = winopen ('flying objects')
- keepaspect (1, 1)
- winconstraints ()
- #
- # configure pipline
- #
- doublebuffer ()
- shademodel (GOURAUD)
- zbuffer (1)
- RGBmode ()
- gconfig ()
- #
- # init lighting
- #
- light.bindlight (1)
- #
- # set viewing
- #
- lookat (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0)
- #
+	#
+	# init window
+	#
+	foreground ()
+	keepaspect (1, 1)
+	prefposition (100, 500, 100, 500)
+	w = winopen ('flying objects')
+	keepaspect (1, 1)
+	winconstraints ()
+	#
+	# configure pipline 
+	#
+	doublebuffer ()
+	shademodel (GOURAUD)
+	zbuffer (1)
+	RGBmode ()
+	gconfig ()
+	#
+	# init lighting
+	#
+	light.bindlight (1)
+	#
+	# set viewing
+	#
+	lookat (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0)
+	#
 
 #
 # drawit : draws the object with the given attributes.
 #
 # rfac : the rotation factor.
-# mat : the material identification
-# attr : a list of attributes :
+# mat  : the material identification
+# attr : a list of attributes : 
 #
-# [[rotate vector ], [tranlate vector], [scale vector]]
-# i.e :
-# [[rX, rY, rZ], [tX, tY, tZ], [sX, sY, sZ]]
+#	[[rotate vector ], [tranlate vector], [scale vector]]
+#	i.e :
+#	[[rX, rY, rZ], [tX, tY, tZ], [sX, sY, sZ]]
 #
 def drawit(object, rfac, attr, mat) :
- pushmatrix()
- rot (attr[0][0] * float (rfac), 'X')
- rot (attr[0][1] * float (rfac), 'Y')
- rot (attr[0][2] * float (rfac), 'Z')
- translate(attr[1][0], attr[1][1], attr[1][2])
- scale(attr[2][0], attr[2][1], attr[2][2])
- lmbind(MATERIAL, mat)
- objectdef.drawobject(object)
- popmatrix()
+	pushmatrix()
+	rot (attr[0][0] * float (rfac), 'X')
+	rot (attr[0][1] * float (rfac), 'Y')
+	rot (attr[0][2] * float (rfac), 'Z')
+	translate(attr[1][0], attr[1][1], attr[1][2])
+	scale(attr[2][0], attr[2][1], attr[2][2])
+	lmbind(MATERIAL, mat)
+	objectdef.drawobject(object)
+	popmatrix()
 
 def callbacksphere (a) :
- putDict (objects, 'sphere', int (a.val))
+	putDict (objects, 'sphere', int (a.val))
 
 def callbackcylinder (a) :
- putDict (objects, 'cylinder', int (a.val))
+	putDict (objects, 'cylinder', int (a.val))
 
 def callbackcube (a) :
- putDict (objects, 'cube', int (a.val))
+	putDict (objects, 'cube', int (a.val))
 
 def callbackicecream (a) :
- putDict (objects, 'icecream', int (a.val))
+	putDict (objects, 'icecream', int (a.val))
 
 def callbackdisk (a) :
- putDict (objects, 'disk', int (a.val))
+	putDict (objects, 'disk', int (a.val))
 
 def callbackdiamond (a) :
- putDict (objects, 'diamond', int (a.val))
+	putDict (objects, 'diamond', int (a.val))
 
 def callbackglass (a) :
- putDict (objects, 'glass', int (a.val))
+	putDict (objects, 'glass', int (a.val))
 
 def callbackpyramid (a) :
- putDict (objects, 'pyramid', int (a.val))
+	putDict (objects, 'pyramid', int (a.val))
 
 def callbacktable (a) :
- putDict (objects, 'table', int (a.val))
+	putDict (objects, 'table', int (a.val))
 
 def callbackflat (a) :
- shademodel(FLAT)
+	shademodel(FLAT)
 
 def callbackgouraud (a) :
- shademodel(GOURAUD)
+	shademodel(GOURAUD)
 
 def callbackwire (a) :
- objectdef.putFunc ([bgnclosedline, endclosedline])
+	objectdef.putFunc ([bgnclosedline, endclosedline])
 
 def callbackfilled (a) :
- objectdef.putFunc ([bgnpolygon, endpolygon])
+	objectdef.putFunc ([bgnpolygon, endpolygon])
 
 def callbackquit (a) :
- import sys
- sys.exit (-1)
+	import sys
+	sys.exit (-1)
 
 def allObjects(p, val) :
- p.sphere.val = val
- p.sphere.fixact ()
- p.cube.val = val
- p.cube.fixact ()
- p.cylinder.val = val
- p.cylinder.fixact ()
- p.pyramid.val = val
- p.pyramid.fixact ()
- p.disk.val = val
- p.disk.fixact ()
- p.diamond.val = val
- p.diamond.fixact ()
- p.icecream.val = val
- p.icecream.fixact ()
- p.table.val = val
- p.table.fixact ()
- p.fixpanel()
-
+	p.sphere.val = val
+	p.sphere.fixact ()
+	p.cube.val = val
+	p.cube.fixact ()
+	p.cylinder.val = val
+	p.cylinder.fixact ()
+	p.pyramid.val = val
+	p.pyramid.fixact ()
+	p.disk.val = val
+	p.disk.fixact ()
+	p.diamond.val = val
+	p.diamond.fixact ()
+	p.icecream.val = val
+	p.icecream.fixact ()
+	p.table.val = val
+	p.table.fixact ()
+	p.fixpanel()
+	
 
 def callbackshowall (a) :
- #print objects
- for key in objects.keys () :
- #print key
- putDict (objects, key, 1)
- allObjects (a.back, 1.0)
+	#print objects
+	for key in objects.keys () :
+		#print key
+		putDict (objects, key, 1)
+	allObjects (a.back, 1.0)
 
 def callbackshownone (a) :
- for key in objects.keys () :
- putDict (objects, key, 0)
- allObjects (a.back, 0.0)
+	for key in objects.keys () :
+		putDict (objects, key, 0)
+	allObjects (a.back, 0.0)
 
 #
 # main : makeobjects, initialze graphics, and loop continuously.
 #
 def main () :
- #
- # iter keeps track of the iterations. It is used as the
- # (x, y, z) rotation increments to which the objects rotate.
- iter = 0
- #
- # make the objects. the objects are put in the odict dictionary
- #
- od = objectdef.makeobjects ()
- #
- # initialize gl
- #
- initgl ()
- #
- # initialize time and iterations per second
- #
- time0 = time.time () # epoch-time of previous second
- fps = 0 # frames per second
- #
- # initialize panels
- #
- panel.needredraw()
- panels = panel.defpanellist('flying.s') #XXX
- p = panels[0]
- p.sphere.upfunc = callbacksphere
- p.cylinder.upfunc = callbackcylinder
- p.cube.upfunc = callbackcube
- p.icecream.upfunc = callbackicecream
- p.disk.upfunc = callbackdisk
- p.diamond.upfunc = callbackdiamond
- # NOT YET IMPLEMENTED p.glass.upfunc = callbackglass
- p.pyramid.upfunc = callbackpyramid
- p.table.upfunc = callbacktable
- p.wire.upfunc = callbackwire
- p.filled.upfunc = callbackfilled
- p.flat.upfunc = callbackflat
- p.gouraud.upfunc = callbackgouraud
- p.quit.upfunc = callbackquit
- p.showall.upfunc = callbackshowall
- p.shownone.upfunc = callbackshownone
- p.showall.back = p
- p.shownone.back = p
- #
- qanels = panel.defpanellist('freeze.s') #XXX
- q = qanels[0]
- #
- ranels = panel.defpanellist('materials.s') #XXX
- r = ranels[0]
- r.m9.upfunc = cbsetmaterial
- r.m8.upfunc = cbsetmaterial
- r.m7.upfunc = cbsetmaterial
- r.m6.upfunc = cbsetmaterial
- r.m5.upfunc = cbsetmaterial
- r.m4.upfunc = cbsetmaterial
- r.m3.upfunc = cbsetmaterial
- r.m2.upfunc = cbsetmaterial
- r.m1.upfunc = cbsetmaterial
- r.specR.activefunc = cbmaterial
- r.specG.activefunc = cbmaterial
- r.specB.activefunc = cbmaterial
- r.diffR.activefunc = cbmaterial
- r.diffG.activefunc = cbmaterial
- r.diffB.activefunc = cbmaterial
- r.shine.activefunc = cbmaterial
- r.m9.back = r
- r.m8.back = r
- r.m7.back = r
- r.m6.back = r
- r.m5.back = r
- r.m4.back = r
- r.m3.back = r
- r.m2.back = r
- r.m1.back = r
- r.diffR.back = r
- r.diffG.back = r
- r.diffB.back = r
- r.specR.back = r
- r.specG.back = r
- r.specB.back = r
- r.shine.back = r
- #
- sanels = panel.defpanellist('light.s') #XXX
- s = sanels[0]
- s.X.back = s
- s.Y.back = s
- s.Z.back = s
- s.R.back = s
- s.G.back = s
- s.B.back = s
- s.light1.back = s
- s.light2.back = s
- s.local.back = s
- s.light1.upfunc = cbsetlight
- s.light2.upfunc = cbsetlight
- s.R.activefunc = cblight
- s.G.activefunc = cblight
- s.B.activefunc = cblight
- s.X.activefunc = cblight
- s.Y.activefunc = cblight
- s.Z.activefunc = cblight
- #
- while 1 :
- #
- act = panel.dopanel()
- #
- wid = panel.userredraw ()
- if wid :
- winset (wid)
- reshapeviewport()
- #
- # increment iter
- #
- if int (q.freeze.val) = 0 :
- iter = iter + 1
- fps = fps + 1
- if time.time() - time0 >= 1 :
- f = float(fps)/float(time.time()-time0)
- q.mystrip.val = f
- q.mystrip.fixact ()
- q.fixpanel()
- time0 = time.time()
- fps = 0
- #
- # clear the zbuffer and make the background light blue
- #
- zclear()
- c3i (LightBlue)
- clear()
- #
- # for each object in the objects dictionary
- #
- for key in objects.keys() :
- #
- # if the object should be displayed
- #
- if getDict (objects, key, 0) = ONE :
- loo = getDict (objects, key, 1)
- for o in loo :
- #
- # get attributes and materail
- #
- attr = o [1]
- mat = o [2]
- #
- # display the object
- #
- drawit(od[o[0]],iter,attr,mat)
- #
- swapbuffers()
- #
+	#
+	# iter keeps track of the iterations. It is used as the 
+	# (x, y, z) rotation increments to which the objects rotate.
+	iter = 0
+	#
+	# make the objects. the objects are put in the odict dictionary
+	#
+	od =  objectdef.makeobjects ()
+	#
+	# initialize gl
+	#
+	initgl ()
+	#
+	# initialize time and iterations per second
+	#
+	time0 = time.time () # epoch-time of previous second
+	fps = 0 # frames per second
+	#
+	# initialize panels
+	#
+	panel.needredraw()
+	panels = panel.defpanellist('flying.s') #XXX
+	p = panels[0]
+	p.sphere.upfunc = callbacksphere
+	p.cylinder.upfunc = callbackcylinder
+	p.cube.upfunc = callbackcube
+	p.icecream.upfunc = callbackicecream
+	p.disk.upfunc = callbackdisk
+	p.diamond.upfunc = callbackdiamond
+	# NOT YET IMPLEMENTED  p.glass.upfunc = callbackglass
+	p.pyramid.upfunc = callbackpyramid
+	p.table.upfunc = callbacktable
+	p.wire.upfunc = callbackwire
+	p.filled.upfunc = callbackfilled
+	p.flat.upfunc = callbackflat
+	p.gouraud.upfunc = callbackgouraud
+	p.quit.upfunc = callbackquit
+	p.showall.upfunc = callbackshowall
+	p.shownone.upfunc = callbackshownone
+	p.showall.back = p
+	p.shownone.back = p
+	#
+	qanels = panel.defpanellist('freeze.s') #XXX
+	q = qanels[0]
+	#
+	ranels = panel.defpanellist('materials.s') #XXX
+	r = ranels[0]
+	r.m9.upfunc = cbsetmaterial
+	r.m8.upfunc = cbsetmaterial
+	r.m7.upfunc = cbsetmaterial
+	r.m6.upfunc = cbsetmaterial
+	r.m5.upfunc = cbsetmaterial
+	r.m4.upfunc = cbsetmaterial
+	r.m3.upfunc = cbsetmaterial
+	r.m2.upfunc = cbsetmaterial
+	r.m1.upfunc = cbsetmaterial
+	r.specR.activefunc = cbmaterial
+	r.specG.activefunc = cbmaterial
+	r.specB.activefunc = cbmaterial
+	r.diffR.activefunc = cbmaterial
+	r.diffG.activefunc = cbmaterial
+	r.diffB.activefunc = cbmaterial
+	r.shine.activefunc = cbmaterial
+	r.m9.back = r
+	r.m8.back = r
+	r.m7.back = r
+	r.m6.back = r
+	r.m5.back = r
+	r.m4.back = r
+	r.m3.back = r
+	r.m2.back = r
+	r.m1.back = r
+	r.diffR.back = r
+	r.diffG.back = r
+	r.diffB.back = r
+	r.specR.back = r
+	r.specG.back = r
+	r.specB.back = r
+	r.shine.back = r
+	#
+	sanels = panel.defpanellist('light.s') #XXX
+	s = sanels[0]
+	s.X.back = s
+	s.Y.back = s
+	s.Z.back = s
+	s.R.back = s
+	s.G.back = s
+	s.B.back = s
+	s.light1.back = s
+	s.light2.back = s
+	s.local.back = s
+	s.light1.upfunc = cbsetlight
+	s.light2.upfunc = cbsetlight
+	s.R.activefunc = cblight
+	s.G.activefunc = cblight
+	s.B.activefunc = cblight
+	s.X.activefunc = cblight
+	s.Y.activefunc = cblight
+	s.Z.activefunc = cblight
+	#
+	while 1 :
+		#
+		act = panel.dopanel()
+		#
+		wid =  panel.userredraw ()
+		if wid :
+			winset (wid)
+			reshapeviewport()
+		#
+		# increment iter
+		#
+		if int (q.freeze.val) = 0 :
+			iter = iter +  1
+			fps = fps + 1
+			if time.time() - time0 >= 1 :
+				f = float(fps)/float(time.time()-time0)
+				q.mystrip.val = f
+				q.mystrip.fixact ()
+				q.fixpanel()
+				time0 = time.time()
+				fps = 0
+		#
+		# clear the zbuffer and make the background light blue
+		#
+		zclear()
+		c3i (LightBlue)
+		clear()
+		#
+		# for each object in the objects dictionary
+		#
+		for key in objects.keys() :
+			#
+			# if the object should be displayed
+			#
+			if getDict (objects, key, 0) = ONE :
+				loo = getDict (objects, key, 1)
+				for o in loo :
+					#
+					# get attributes and materail
+					#
+					attr = o [1]
+					mat  = o [2]
+					#
+					#  display the object
+					#
+					drawit(od[o[0]],iter,attr,mat)
+		#
+		swapbuffers()
+		#
 
 main()