Python 0.9.1 as posted in alt.sources

1 files changed, 375 insertions, 0 deletions

diff --git a/demo/sgi/gl_panel/flying/flying.py b/demo/sgi/gl_panel/flying/flying.py
new file mode 100755
index 0000000..e6fd823
--- /dev/null
+++ b/demo/sgi/gl_panel/flying/flying.py
@@ -0,0 +1,375 @@
+#! /ufs/guido/bin/sgi/python
+
+from gl import *
+from objdict import *
+from GL import *
+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 ()
+
+def fixlichtact (p) :
+ 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)
+
+def cbsetmaterial (a) :
+ 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)
+
+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)
+
+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)
+
+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)
+
+#
+# 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)
+ #
+
+#
+# drawit : draws the object with the given attributes.
+#
+# rfac : the rotation factor.
+# 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]]
+#
+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()
+
+def callbacksphere (a) :
+ putDict (objects, 'sphere', int (a.val))
+
+def callbackcylinder (a) :
+ putDict (objects, 'cylinder', int (a.val))
+
+def callbackcube (a) :
+ putDict (objects, 'cube', int (a.val))
+
+def callbackicecream (a) :
+ putDict (objects, 'icecream', int (a.val))
+
+def callbackdisk (a) :
+ putDict (objects, 'disk', int (a.val))
+
+def callbackdiamond (a) :
+ putDict (objects, 'diamond', int (a.val))
+
+def callbackglass (a) :
+ putDict (objects, 'glass', int (a.val))
+
+def callbackpyramid (a) :
+ putDict (objects, 'pyramid', int (a.val))
+
+def callbacktable (a) :
+ putDict (objects, 'table', int (a.val))
+
+def callbackflat (a) :
+ shademodel(FLAT)
+
+def callbackgouraud (a) :
+ shademodel(GOURAUD)
+
+def callbackwire (a) :
+ objectdef.putFunc ([bgnclosedline, endclosedline])
+
+def callbackfilled (a) :
+ objectdef.putFunc ([bgnpolygon, endpolygon])
+
+def callbackquit (a) :
+ 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()
+
+
+def callbackshowall (a) :
+ #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)
+
+#
+# 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()
+ #
+
+main()