irclog2html for #bzflag on 20030713

`00:00.28`	`captain_proton`	`shouldn't be`
`00:01.35`	`captain_proton`	`but that shouldn't cause glNewList to geek`
`00:02.16`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (3 files): Set up event dispatching for pygame events, viewportified the radar view`
`00:05.43`	`captain_proton`	`eh...maybe its just my imagination`
`00:05.51`	`sussudio`	`hmm`
`00:06.06`	`sussudio`	`looks like some projects are abandoning sf for "savannah"`
`00:06.25`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag (2 files in 2 dirs): clean up a bunch`
`00:15.01`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (3 files): Viewportified the ThreeDView`
`00:20.19`	`captain_proton`	`s`
`00:20.19`	`scanline`	`mwahaha`
`00:20.31`	`scanline`	`so.. I should probably add some sort of coding standard document`
`00:21.15`	`captain_proton`	`wow...`
`00:21.19`	`captain_proton`	`try resizing the 3d view`
`00:21.30`	`scanline`	`did I break something?`
`00:21.33`	`scanline`	`oh, it works`
`00:21.34`	`scanline`	`cool`
`00:21.40`	`captain_proton`	`doesn't work for me...`
`00:22.00`	`scanline`	`what happens?`
`00:22.03`	`captain_proton`	`keeps trying to shrink to 800x600`
`00:22.15`	`scanline`	`oh.. I know what's wrong`
`00:22.57`	`scanline`	`hmm.. or not`
`00:23.31`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (ThreeDView.py): damned whitespace`
`00:23.53`	`scanline`	`IIRC you have to set the SDL video mode after getting a resize event for the surface to actually be resized`
`00:24.02`	`scanline`	`so, that's what I was doing`
`00:24.13`	`scanline`	`if I remove that, the window resizes but the viewport doesn't`
`00:24.32`	`scanline`	`do other SDL apps resize for you? could be a bug between SDL and your WM`
`00:25.55`	`captain_proton`	`hmm...other sdl app you say`
`00:27.48`	`scanline`	`"When SDL_RESIZABLE is passed as a flag to SDL_SetVideoMode the user is allowed to resize the applications window. When the window is resized an SDL_VIDEORESIZE is report, with the new window width and height values stored in w and h, respectively. When an SDL_VIDEORESIZE is recieved the window should be resized to the new dimensions using SDL_SetVideoMode."`
`00:31.01`	`captain_proton`	`is there a way to pump the event queue and only respect the last resize event?`
`00:31.34`	`scanline`	`oh, you're using one of those continuously-resizing thingies, eh?`
`00:32.06`	`scanline`	`hmm... this is a flaw in SDL if there's no way to set the video mode after a resize event without forcing the window to re-resize`
`00:34.38`	`scanline`	`but, looks like that's the case..`
`00:35.22`	`*** join/#bzflag Carnage (strayer@dyn216-8-175-55.ADSL.mnsi.net)`
`00:36.14`	`captain_proton`	`sigh`
`00:36.27`	`scanline`	`I'm implementing the event queue thingy, hope that helps`
`00:36.38`	`captain_proton`	`hopefully`
`00:38.42`	`scanline`	`committed`
`00:39.08`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Viewport.py): Ignore all but the last resize event in the queue. Hopefully this will somewhat fix resizing on window managers that use solid resize.`
`00:39.43`	`captain_proton`	`=(`
`00:40.24`	`captain_proton`	`no love`
`00:40.29`	`scanline`	`hm`
`00:40.49`	`scanline`	`maybe it could delay the resize until the next frame?`
`00:41.47`	`scanline`	`or, I could just write a patch to SDL`
`00:42.15`	`scanline`	`wonder if this is already fixed in SDL's CVS`
`00:42.27`	`scanline`	`maybe captain_proton should do this patching, as he's the one the problem affects :)`
`00:42.50`	`captain_proton`	`but you're already familiar with the SDL code base =)`
`00:43.05`	`scanline`	`hm, true`
`00:43.15`	`scanline`	`maybe I should switch to sawfish temporarily to try this out myself`
`00:44.09`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Viewport.py): Remove resize event kludge, it didn't help`
`00:45.35`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Viewport.py): Whoops, we still need that 'import pygame'`
`00:45.49`	`scanline`	`is there any way to get rid of those Z-buffer artifacts short of CSG'ing the boxes together?`
`00:46.21`	`scanline`	`hmm...`
`00:46.40`	`scanline`	`you could do all the textureing relative to the world origin rather than the box origin`
`00:47.25`	`captain_proton`	`that would be a huge pain in the ass`
`00:48.03`	`scanline`	`oh? isn't there an opengl-thingy for generating texture coordinates...`
`00:48.53`	`scanline`	`GL_TEXTURE_GEN_*`
`00:50.04`	`scanline`	`never mind, that wouldn't really help.. either way you'd need a matrix to convert everything to world coords`
`00:56.36`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Super-nonlinear-mouse-wheel-fu`
`01:04.59`	`sussudio`	`when i set windows and bzflag both to 1024x768 120hz, i can switch between them without my monitor having to switch modes (which seems logical), but when i set both to 100hz, it does 3 or 4 switches when i exit bzflag....?`
`01:06.12`	`CIA`	`03micahjd * 12pybzflag/BZFlag (Drawable.py): Change the ground texture scale`
`01:08.54`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Fix window title for 3D view`
`01:13.03`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (2 files): Separate camera control from ThreeDView into a new ThreeDController class`
`01:14.09`	`*** join/#bzflag Carnage (strayer@dyn216-8-173-148.ADSL.mnsi.net)`
`01:14.56`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Move camera rotation too`
`01:22.33`	`CIA`	`03micahjd * 12pybzflag/BZFlag (3 files in 2 dirs): Added a Timekeeper class, now used in Game and ThreeDController`
`01:42.03`	`*** join/#bzflag MrApathyCream (dbrosius@balt-209-163-100-181.qis-dynamic-dialup.coretel.net)`
`01:45.23`	`MrApathyCream`	`only 3 more hours till the meeting`
`01:45.44`	`MrApathyCream`	`i wouldn't miss it for the world`
`01:45.51`	`scanline`	`:)`
`01:47.55`	`sussudio`	`another one?`
`01:48.17`	`learner`	`lol MAC`
`01:48.18`	`MrApathyCream`	`another one?`
`01:48.25`	`learner`	`hope your kidding :)`
`01:48.26`	`sussudio`	`...`
`01:48.38`	`learner`	`you missed it buddy`
`01:48.41`	`MrApathyCream`	`huh? nope i won't kid about that`
`01:48.46`	`MrApathyCream`	`haha`
`01:49.06`	`learner`	`it was about 10 hours ago`
`01:49.30`	`scanline`	`7 hours?`
`01:49.41`	`learner`	`well, ended 7 ago, started 9 ago`
`01:50.01`	`MrApathyCream`	`good one`
`01:50.09`	`MrApathyCream`	`had me goin' there for a while`
`01:50.11`	`MrApathyCream`	`<PROTECTED>`
`01:50.34`	`learner`	`no joke`
`01:51.01`	`learner`	`fiber is going to put the meeting notes up on the wiki at some point`
`01:51.08`	`scanline`	`they're up already`
`01:51.11`	`scanline`	`in the topic`
`01:51.14`	`learner`	`ah`
`01:52.10`	`sussudio`	`[21:02:00] <JBDiGriz> We're missing MAC and CobraA1`
`01:52.10`	`sussudio`	`[21:02:05] <TimRiker> it's time, so whoever is not here, please say something.`
`01:52.10`	`sussudio`	`(in other words let's start)`
`01:52.11`	`MrApathyCream`	`wow, nice spoof... that was alot of work comin' up with that`
`01:52.13`	`sussudio`	`:-\|`
`01:52.36`	`learner`	`er poor`
`01:53.23`	`MrApathyCream`	`sussudio: yup, just a few more hours`
`01:54.06`	`sussudio`	`MrApathyCream: it was 7PM UTC......`
`01:54.21`	`MrApathyCream`	`7am utc you mean`
`01:54.26`	`sussudio`	`nope`
`01:55.11`	`MrApathyCream`	`i gotta do something before the meeting.. but will certainly back in plenty of time....`
`01:55.14`	`sussudio`	`if it has been 7am UTC you'd be late about 20 hours`
`01:55.19`	`MrApathyCream`	`seechya`
`02:08.40`	`CIA`	`03micahjd * 12pybzflag/BZFlag (4 files in 2 dirs): Committing the scary animation code I have so far`
`02:24.48`	`captain_proton`	`http://jupiter.babylonia.flatirons.org/purdy.png`
`02:24.57`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag (3 files in 2 dirs): do blended polygons on a separate pass`
`02:26.06`	`captain_proton`	`damn...`
`02:26.14`	`captain_proton`	`i think thats the prettiest view i've ever done`
`02:26.24`	`captain_proton`	`(all my previous bzedits either didn't do blending or didn't do 2-pass)`
`02:29.01`	`CIA`	`03micahjd * 12pybzflag/BZFlag (2 files): Try out Animated.Vector and Animated.Velocity in the Player object`
`02:29.53`	`scanline`	`sweet`
`02:42.24`	`CIA`	`03micahjd * 12pybzflag/BZFlag (2 files in 2 dirs): Whee, the mouse wheel is smooth`
`02:52.48`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Add some keybindings to ThreeDController. 'f' toggles full-screen mode, 'q' quits.`
`03:07.34`	`*** join/#bzflag fiberchunks (~frobozzpf@237.14.252.64.snet.net)`
`03:08.58`	`*** join/#bzflag bzgirl (~brat@toronto-hs-64-26-176-100.s-ip.magma.ca)`
`03:11.51`	`CIA`	`03micahjd * 12pybzflag/BZFlag (3 files in 2 dirs): Add a spiffy little FrequencyCounter class to animated, use it in ThreeDView.attach() to give a FHz indicator`
`03:14.21`	`*** join/#bzflag JBDiGriz (~JBDiGriz@adsl-63-204-118-6.dsl.sndg02.pacbell.net)`
`03:27.05`	`*** join/#bzflag Michaelh (Mouse@172-66.dynamic.visi.com)`
`03:27.30`	`captain_proton`	`learner: i want a screenshot of the 3d view in osx`
`03:27.41`	`captain_proton`	`damn that mouse wheel is smooth`
`03:27.44`	`learner`	`which module is it`
`03:28.00`	`captain_proton`	`just run one of the bzflag things (like observer.py) with -u3D`
`03:29.02`	`Michaelh`	`does python work with opengl then?`
`03:29.13`	`captain_proton`	`yep`
`03:29.19`	`learner`	`bash-2.05a$ /usr/local/bin/python ./observer.py --server=brlcad.org:4242 -u3D`
`03:29.19`	`learner`	`Traceback (most recent call last):`
`03:29.19`	`learner`	`<PROTECTED>`
`03:29.19`	`learner`	`<PROTECTED>`
`03:29.19`	`learner`	`<PROTECTED>`
`03:29.19`	`learner`	`<PROTECTED>`
`03:29.21`	`learner`	`<PROTECTED>`
`03:29.23`	`captain_proton`	`you may need to install PyOpenGL`
`03:29.24`	`learner`	`<PROTECTED>`
`03:29.25`	`learner`	`AttributeError: 'module' object has no attribute 'attach'`
`03:30.20`	`scanline`	`is that the latest code?`
`03:30.41`	`scanline`	`you're probably getting that error because you don't have PyOpenGL, but it should give you a different error`
`03:30.43`	`captain_proton`	`scanline: that mouse wheel makes me very happy`
`03:30.48`	`scanline`	`captain_proton: hehe`
`03:30.57`	`learner`	`yes that is the latest code`
`03:31.06`	`scanline`	`captain_proton: I'll do similar things for moving the camera's target :)`
`03:31.25`	`learner`	`I'm supposed to have pyopengl already installed (it was a mega bundle package install)`
`03:31.25`	`scanline`	`it could be.. like jetstream's camera!`
`03:31.33`	`captain_proton`	`hehe`
`03:31.44`	`captain_proton`	`eek`
`03:31.47`	`captain_proton`	`no seasickness`
`03:31.51`	`scanline`	`learner: hmm.. can you get a python command line and run "import BZFlag.UI.ThreeDView" and see if you get an error?`
`03:32.01`	`scanline`	`(from the pybzflag directory)`
`03:32.18`	`learner`	`I'll try it`
`03:32.45`	`learner`	`>>> import BZFlag.UI.ThreeDView`
`03:32.45`	`learner`	`Traceback (most recent call last):`
`03:32.45`	`learner`	`<PROTECTED>`
`03:32.45`	`learner`	`<PROTECTED>`
`03:32.46`	`learner`	`<PROTECTED>`
`03:32.46`	`learner`	`ImportError: Bad magic number in BZFlag/World/Scene.pyc`
`03:33.17`	`scanline`	`oh, hrmph`
`03:33.34`	`learner`	`my build is from here: http://www.visionegg.org/install-macosx-details.html`
`03:33.35`	`scanline`	`you sure you updated with 'cvs up -Pd"?`
`03:33.39`	`learner`	`it does list pyopengl`
`03:33.53`	`learner`	`pygame, PyOpenGL, Pyro, SDL, and more`
`03:34.02`	`scanline`	`yes yes.. that doesn't appear to be the problem`
`03:34.07`	`scanline`	`it looks a lot like you're just running old code`
`03:34.16`	`scanline`	`cvs up -Pd`
`03:34.42`	`learner`	`brace for spam:`
`03:34.43`	`learner`	`bash-2.05a$ pwd`
`03:34.43`	`learner`	`bash-2.05a$ cvs update -dP`
`03:34.43`	`learner`	`? .DS_Store`
`03:34.43`	`learner`	`cvs server: Updating .`
`03:34.43`	`learner`	`cvs server: Updating .svn`
`03:34.44`	`learner`	`cvs server: Updating .svn/prop-base`
`03:34.46`	`learner`	`cvs server: Updating .svn/props`
`03:34.48`	`learner`	`cvs server: Updating .svn/text-base`
`03:34.50`	`learner`	`cvs server: Updating .svn/wcprops`
`03:34.52`	`learner`	`cvs server: Updating BZFlag`
`03:34.54`	`learner`	`cvs server: Updating BZFlag/.svn`
`03:34.56`	`learner`	`cvs server: Updating BZFlag/.svn/prop-base`
`03:34.58`	`Michaelh`	`?`
`03:34.59`	`learner`	`cvs server: Updating BZFlag/.svn/props`
`03:35.00`	`learner`	`cvs server: Updating BZFlag/.svn/text-base`
`03:35.01`	`captain_proton`	`umm`
`03:35.02`	`captain_proton`	`#flood`
`03:35.02`	`Michaelh`	`?`
`03:35.02`	`learner`	`cvs server: Updating BZFlag/.svn/wcprops`
`03:35.04`	`learner`	`cvs server: Updating BZFlag/Client`
`03:35.06`	`learner`	`cvs server: Updating BZFlag/Flag`
`03:35.08`	`Michaelh`	`stop......`
`03:35.08`	`learner`	`cvs server: Updating BZFlag/Meta`
`03:35.10`	`learner`	`cvs server: Updating BZFlag/Protocol`
`03:35.11`	`Michaelh`	`in the name ......`
`03:35.12`	`learner`	`cvs server: Updating BZFlag/Protocol/.svn`
`03:35.13`	`Michaelh`	`of love .....`
`03:35.14`	`learner`	`cvs server: Updating BZFlag/Protocol/.svn/prop-base`
`03:35.16`	`learner`	`cvs server: Updating BZFlag/Protocol/.svn/props`
`03:35.18`	`Michaelh`	`before you break`
`03:35.18`	`learner`	`cvs server: Updating BZFlag/Protocol/.svn/text-base`
`03:35.19`	`Michaelh`	`.......`
`03:35.20`	`learner`	`cvs server: Updating BZFlag/Protocol/.svn/wcprops`
`03:35.20`	`Michaelh`	`my heart`
`03:35.22`	`learner`	`cvs server: Updating BZFlag/Server`
`03:35.24`	`learner`	`cvs server: Updating BZFlag/UI`
`03:35.26`	`*** kick/#bzflag [learner!~blardebla@12-203-245-57.client.attbi.com] by captain_proton (enough!)`
`03:35.26`	`learner`	`cvs server: Updating BZFlag/UI/Objects`
`03:35.28`	`learner`	`cvs server: Updating BZFlag/World`
`03:35.30`	`learner`	`cvs server: Updating BZFlag/optik`
`03:35.32`	`learner`	`cvs server: Updating data`
`03:35.33`	`Michaelh`	`doh`
`03:35.33`	`captain_proton`	`ugh`
`03:35.34`	`*** mode/#bzflag [+n] by captain_proton`
`03:35.36`	`Michaelh`	`heh`
`03:35.55`	`Michaelh`	`want to see my directory listing --`
`03:35.56`	`Michaelh`	`?`
`03:35.58`	`*** join/#bzflag learner (sean@chr160dhcp1675.chrchv01.md.comcast.net)`
`03:36.00`	`Michaelh`	`:)`
`03:36.06`	`captain_proton`	`learner: #flood exists for a reason`
`03:36.21`	`learner`	`never heard of it.. :(`
`03:36.21`	`scanline`	`#flood or not, what makes you think anyone wants the entire output from cvs up?`
`03:36.35`	`learner`	`my font was much smaller..`
`03:36.44`	`learner`	`looked like 10 lines`
`03:36.45`	`learner`	`ikes`
`03:37.01`	`learner`	`I'll be more careful`
`03:37.13`	`Michaelh`	`you bad......`
`03:37.28`	`learner`	`did those tick off one at a time or what?`
`03:37.35`	`captain_proton`	`yeah`
`03:37.37`	`learner`	`ah`
`03:37.37`	`JBDiGriz`	`sounds like luke in the cantina scene ;-)`
`03:37.52`	`learner`	`that sucks`
`03:37.56`	`learner`	`really sorry`
`03:38.02`	`Michaelh`	`wzzzzzup with this.. no more DeadPlayer.cxx ? sniff`
`03:38.23`	`*** part/#bzflag learner (sean@chr160dhcp1675.chrchv01.md.comcast.net)`
`03:38.35`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (__init__.py): Remove the silly automatic UI module detection code, it generates confusing erorr messages when a UI module doesn't import`
`03:39.11`	`Michaelh`	`so is pythbzflag under a different tag or module or whatever?`
`03:39.16`	`scanline`	`module`
`03:39.43`	`Michaelh`	`is that like a different directory.. basically?`
`03:39.48`	`scanline`	`yep`
`03:40.53`	`Michaelh`	`the only email I get now is bzspam`
`03:41.19`	`scanline`	`captain_proton: ah... teleporters don't have an options byte`
`03:41.31`	`scanline`	`er, wait`
`03:41.37`	`scanline`	`they do, but it's after the border, not before`
`03:41.46`	`scanline`	`Michaelh: isn't that what procmail is for?`
`03:42.25`	`*** join/#bzflag learner (sean@chr160dhcp1675.chrchv01.md.comcast.net)`
`03:42.44`	`learner`	`different error now, but still no good`
`03:43.11`	`scanline`	`did you update with that change to UI/__init__.py that I just made?`
`03:43.17`	`learner`	`ImportError: Bad magic number in /Volumes/Home/Archive/BZ/pybzflag/BZFlag/World/Scene.pyc`
`03:43.18`	`learner`	`yes`
`03:43.23`	`scanline`	`that's not going to fix anything, that change is so that the error message is better`
`03:43.29`	`scanline`	`ok, delete that .pyc file (and probably any others)`
`03:43.40`	`scanline`	`it looks like you have a somehow broken python installation`
`03:44.08`	`*** join/#bzflag bzgirl (~brat@toronto-hs-64-26-176-100.s-ip.magma.ca)`
`03:44.09`	`learner`	`ImportError: cannot import name Scene`
`03:44.19`	`Michaelh`	`<-- windows......... I do have filters on my netscrape`
`03:44.38`	`CIA`	`03micahjd * 12pybzflag/BZFlag/Protocol (WorldObjects.py): Fix teleporter binary packing. The protocol document had border and options in the wrong order.`
`03:51.34`	`scanline`	`learner: give a couple lines above that.. Scene doesn't exist any more, so nothing should be trying to import it`
`03:52.23`	`learner`	`<PROTECTED>`
`03:52.23`	`learner`	`<PROTECTED>`
`03:52.23`	`learner`	`<PROTECTED>`
`03:53.00`	`scanline`	`ahhhhh`
`03:53.10`	`captain_proton`	`oops :)`
`03:53.16`	`scanline`	`ThreeDView does still contain an import for Scene, but both captain_proton and I still have the .pyc files for that laying around`
`03:54.16`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): No more scene`
`03:55.37`	`Michaelh`	`what's up with the huge countdown for bad flags on xmission?`
`03:56.11`	`scanline`	`captain_proton: would you be totally heartbroken if I put the fist down on 4-space indentation for pybzflag?`
`03:56.57`	`captain_proton`	`scanline: not so long as you do the indentation fixing ;)`
`03:57.04`	`scanline`	`alrighty`
`03:57.10`	`Michaelh`	`isn't it supposed to be 2?`
`03:57.14`	`Michaelh`	`and it isn`
`03:57.16`	`Michaelh`	`t ?`
`03:57.20`	`scanline`	`Michaelh: this is python`
`03:57.26`	`scanline`	`2 spaces looks butt-ugly in python`
`03:57.36`	`captain_proton`	`eh, sortof`
`03:57.44`	`captain_proton`	`i don't see much difference between 2 and 4`
`03:57.51`	`Michaelh`	`so which way is the fist leaning?`
`03:58.05`	`captain_proton`	`Michaelh: scanline says what goes with pybzflag`
`03:58.09`	`scanline`	`:)`
`03:58.38`	`scanline`	`so you still technically have the fist for those files`
`03:58.44`	`captain_proton`	`eh`
`03:58.50`	`captain_proton`	`feel free to take copyright on those`
`03:58.53`	`captain_proton`	`it doesn't really matter to me`
`03:59.16`	`captain_proton`	`learner: poke?`
`03:59.34`	`learner`	`yes`
`03:59.43`	`captain_proton`	`does the updated one work for ya?`
`03:59.47`	`learner`	`wha?`
`03:59.53`	`learner`	`ah, lemme check`
`04:00.27`	`*** join/#bzflag SGI (~sgi-tank@pcp01642968pcs.sothfd01.mi.comcast.net)`
`04:00.34`	`SGI`	`hi all`
`04:00.53`	`scanline`	`captain_proton: I could do what I do with picogui, and take copyright on everything but encourage people to add themselves to a contributors section`
`04:00.57`	`learner`	`whadayaknow...`
`04:01.01`	`learner`	`isn't that purdy`
`04:01.16`	`scanline`	`learner: I'd ask you to try the mouse wheel, but you're on a mac :)`
`04:01.39`	`captain_proton`	`screenshot!`
`04:01.40`	`scanline`	`after... coffee!`
`04:01.57`	`SGI`	`coffeeeeeeee`
`04:02.02`	`SGI`	`i love coffeee`
`04:02.43`	`learner`	`are there any keybindings or a trackball to spin the sucker`
`04:03.05`	`captain_proton`	`there's zoom, but its bound to the mouse wheel`
`04:03.24`	`learner`	`eek, resize definately doesn't work right`
`04:03.27`	`scanline`	`I was about to start camera panning/spinning with the mouse, but I can add keyboard zooming real quick`
`04:03.45`	`scanline`	`SDL handles resize kind of badly no matter what`
`04:03.46`	`learner`	`yay, quit works :)`
`04:03.51`	`captain_proton`	`scanline: eh - let me to the spinning/etc`
`04:03.53`	`scanline`	`I don't think there's anything we can do to get around it`
`04:03.56`	`scanline`	`captain_proton: okeydokey`
`04:03.59`	`captain_proton`	`so i can make it consistent with earlier versions of bzedit`
`04:04.10`	`learner`	`not likely cap -- WindowServer != X :)`
`04:04.31`	`scanline`	`learner: it's a bug in SDL's design, not just the X backend`
`04:08.07`	`JBDiGriz`	`scanline: I'm on a mac, and the mouse wheel works fine, thank you! ;-)`
`04:08.48`	`JBDiGriz`	`I'll have to get the python utils running and try it with them.`
`04:09.00`	`scanline`	`JBDiGriz: I know they work fine with an external mouse, but learner mentioned earlier he had no right button, so I assumed he had a stock mouse`
`04:09.43`	`*** join/#bzflag Noodleman (~tuckerm@bc183148.bendcable.com)`
`04:09.56`	`learner`	`http://brlcad.ord/tmp/observer3d.png`
`04:10.22`	`JBDiGriz`	`learner: Never play bzflag with a stock Apple mouse! :-)`
`04:10.30`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): New zoom keybindings, a stub for mouse handling`
`04:10.34`	`learner`	`heh, why jb?`
`04:10.54`	`learner`	`I can actually manage it a little`
`04:11.00`	`scanline`	`hmm, is brlcad.org's DNS dead?`
`04:11.12`	`sussudio`	`it's pining for the fjords`
`04:11.17`	`scanline`	`:)`
`04:11.20`	`learner`	`hrm`
`04:11.32`	`scanline`	`zooming has gimp-style keybindings now :)`
`04:11.39`	`Michaelh`	`this DNS is dead!`
`04:12.09`	`learner`	`hrm, I'm not showing any problems on this side`
`04:12.38`	`captain_proton`	`learner: scp it to me? i'll throw it on a reliable server ;-)`
`04:12.40`	`scanline`	`It's worse than dead, Jim. It's brain is gone.`
`04:12.52`	`captain_proton`	`=D`
`04:12.58`	`learner`	`hey!`
`04:13.02`	`JBDiGriz`	`brlcad.org is responding as 68.33.166.139`
`04:13.02`	`scanline`	`er.. remove one of those apostrophies`
`04:13.05`	`learner`	`no png for you!`
`04:13.07`	`Michaelh`	`brlcad works for me`
`04:13.23`	`Michaelh`	`whoo.. exactly owns brlcad? :)`
`04:13.33`	`learner`	`why?`
`04:13.43`	`captain_proton`	`EnterPasswordYouMonkeyYou`
`04:13.47`	`JBDiGriz`	`Michaelh: learn how to use whois`
`04:13.48`	`Michaelh`	`curious who's website it is....`
`04:13.55`	`learner`	`heh, you're not going to get to it that way, cap :)`
`04:14.05`	`scanline`	`learner: is that on a vhost? it's asking for a password if you use the IP`
`04:14.16`	`captain_proton`	`ah, it loaded now`
`04:14.31`	`captain_proton`	`woo`
`04:14.34`	`scanline`	`pff, still not loading here`
`04:14.38`	`captain_proton`	`its a shame its not all happy and antialiased`
`04:14.45`	`learner`	`I added the menu just for added effect`
`04:14.59`	`scanline`	`hmm, I should turn on FSAA and try this`
`04:15.02`	`scanline`	`captain_proton: what was that env var?`
`04:15.21`	`captain_proton`	`http://jupiter.babylonia.flatirons.org/observer3d.png`
`04:15.24`	`captain_proton`	`__GL_FSAA_MODE`
`04:15.31`	`captain_proton`	`i usually set it to 5 (best you can do on a 3)`
`04:15.39`	`scanline`	`whee, cute screenshot`
`04:15.56`	`captain_proton`	`now we need a windows screenshot`
`04:16.11`	`JBDiGriz`	`The brlcad URL wasn't a problem once I changed .ord to .org. I know that learner isn't in Chicago!`
`04:16.14`	`scanline`	`after my brother goes to bed I could try it on his machine`
`04:16.23`	`learner`	`hehehe, oops.. :)`
`04:16.28`	`learner`	`can't you guys read?`
`04:16.29`	`scanline`	`doh`
`04:16.32`	`sussudio`	`ord? chr? hex?`
`04:16.55`	`scanline`	`woobeedoo! this looks really nice with FSAA`
`04:17.04`	`JBDiGriz`	`Oooh, a pascal person!`
`04:17.19`	`sussudio`	`:-\|`
`04:17.30`	`captain_proton`	`http://jupiter.babylonia.flatirons.org/purdy.png <-- i'm still fond of this one`
`04:17.52`	`scanline`	`so now I know why captain_proton's screenies always look better than mine :)`
`04:18.20`	`captain_proton`	`>:)`
`04:19.16`	`scanline`	`so.. how about that camera panning/rotation?`
`04:20.41`	`captain_proton`	`hang on, folding laundry`
`04:20.56`	`learner`	`cap, is that all you wanted from me`
`04:21.15`	`captain_proton`	`yep`
`04:25.38`	`*** join/#bzflag chatelaine (brat@chr160dhcp1675.chrchv01.md.comcast.net)`
`04:25.44`	`scanline`	`captain_proton: is Camera.isFocused really necessary? seems like you could just rename focus to position, then use distance=0 for a 1st person camera and distance!=0 for a 3rd person camera`
`04:27.02`	`*** join/#bzflag Noodleman (~tuckerm@bc183148.bendcable.com)`
`04:29.54`	`Michaelh`	`what kind of agp cards can I use on a asus P2b -- seems like it only has AGP 1x`
`04:30.59`	`captain_proton`	`scanline: thats sort of a turd left over from bzedit`
`04:31.05`	`scanline`	`ah, ok`
`04:31.10`	`captain_proton`	`where it could focus on an object`
`04:33.02`	`sussudio`	`Michaelh: they're backwards compatible`
`04:33.18`	`scanline`	`captain_proton: also, we might want to standardize on radians or degrees.. it's rather mixed at the moment`
`04:34.01`	`Michaelh`	`hmmm... so any AGP works on my old AGP .. but older cards will not work on newer motherboards, right?`
`04:34.17`	`sussudio`	`well not agp pro boards`
`04:34.43`	`Michaelh`	`some guy brought an old AGP board in said it wouldn't work with his new mb...`
`04:34.54`	`*** part/#bzflag chatelaine (brat@chr160dhcp1675.chrchv01.md.comcast.net)`
`04:35.05`	`sussudio`	`i think there's a voltage and/or wattage thing`
`04:35.18`	`sussudio`	`and some p4's have issues`
`04:38.13`	`JBDiGriz`	`learner: Check out this new release http://pyobjc.sourceforge.net/`
`04:38.39`	`sussudio`	`Michaelh: not that's there's much performance to gain with AGP1x over PCI.....`
`04:39.09`	`Michaelh`	`I just figure most cards are agp in general`
`04:39.37`	`sussudio`	`you can still get pci versions for a bunch of cards`
`04:39.52`	`Michaelh`	`you're thinking they're more compatible?`
`04:40.35`	`sussudio`	`well i'm just saying it won't matter much, except you won't have the issues agp can give`
`04:40.50`	`sussudio`	`p2b is intel pentium, right`
`04:40.56`	`Michaelh`	`I'm just pondering something to make bzflag run a little better.. TNT riva / 450 Celeron`
`04:41.05`	`Michaelh`	`pII`
`04:41.10`	`sussudio`	`riva sorta sux`
`04:41.21`	`sussudio`	`but you can try it anyway`
`04:41.35`	`*** join/#bzflag sgi_ (~sgi@pcp01642968pcs.sothfd01.mi.comcast.net)`
`04:41.40`	`Michaelh`	`I am already running it with the TNT riva....`
`04:41.45`	`captain_proton`	`scanline: i temporarily commented out the FHz counter because it was causing too big a delay`
`04:41.55`	`sussudio`	`Michaelh: google is your friend`
`04:42.03`	`Michaelh`	`ah so`
`04:42.16`	`sussudio`	`~google for asus p2b tnt riva agp`
`04:42.22`	`SGI`	`to many sgi`
`04:42.23`	`scanline`	`captain_proton: hehe`
`04:42.47`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag (2 files in 2 dirs): camera rotation/elevation`
`04:43.51`	`Michaelh`	`well it's not as if I was looking to buy the video card I already own.......`
`04:44.44`	`*** join/#bzflag creeperz (~creeperz@host-11-76-220-24.midco.net)`
`04:45.19`	`captain_proton`	`scanline: as far as panning, what modifier keys do you suggest?`
`04:48.30`	`scanline`	`I was thinking left mouse button and middle mouse button`
`04:48.33`	`scanline`	`sort of blender style`
`04:48.52`	`scanline`	`in blender, left mouse rotates, middle pans, and right selects`
`04:49.13`	`scanline`	`er, wait`
`04:49.24`	`scanline`	`darnit, it's been too long since I've blended`
`04:49.51`	`scanline`	`yeah.. middle rotates, shift-middle pans`
`04:49.59`	`scanline`	`left positions the cursor`
`04:54.20`	`*** join/#bzflag MrApathyCream (dbrosius@balt-209-163-100-142.qis-dynamic-dialup.coretel.net)`
`04:54.56`	`CIA`	`03micahjd * 12pybzflag/doc (3 files): Directory /cvsroot/bzflag/pybzflag/doc added to the repository`
`04:54.58`	`captain_proton`	`i'll do alt+middle for panning up&down`
`04:55.17`	`scanline`	`ok, I'm about to give you a few update conflicts :)`
`04:55.54`	`scanline`	`whoops, looks like you already gave me some`
`04:56.53`	`scanline`	`grr, I hate trying to figure out diffs where all the whitespace has changed`
`04:58.01`	`Michaelh`	`happy fun whitespace changing time :)`
`04:59.17`	`sussudio`	`dont taunt happy fun whitespace ball`
`04:59.22`	`CIA`	`03micahjd * 12pybzflag/ (7 files in 3 dirs): Added a coding guidelines document, made some modifications to enforce it`
`04:59.27`	`scanline`	`hehe`
`05:00.22`	`Michaelh`	`Isn't it fun when someone goes and changes all the whitespace....`
`05:00.40`	`Michaelh`	`wind up with some huge diff.. most of it whitespace changes...`
`05:00.50`	`scanline`	`well, I was the somewone`
`05:00.54`	`scanline`	`er, someone`
`05:02.23`	`CIA`	`03micahjd * 12pybzflag/doc (AUTHORS): Adding an AUTHORS file`
`05:04.11`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI/Objects (3 files): Removing obsolete Objects package`
`05:06.21`	`*** join/#bzflag sgi (~sgi@pcp01642968pcs.sothfd01.mi.comcast.net)`
`05:07.54`	`*** join/#bzflag Patlabor221 (~jeffm@adsl-64-173-106-69.dsl.lsan03.pacbell.net)`
`05:07.54`	`*** mode/#bzflag [+o Patlabor221] by ChanServ`
`05:08.30`	`CIA`	`03micahjd * 12pybzflag/BZFlag (2 files in 2 dirs): Whitespace changes`
`05:12.30`	`scanline`	`guess a matrix would come in handy :)`
`05:12.37`	`captain_proton`	`who needs a matrix?`
`05:12.52`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Texture.py): Whitespace changes`
`05:13.06`	`scanline`	`:)`
`05:13.26`	`captain_proton`	`there's this great tool i forgot to tell you about`
`05:13.28`	`captain_proton`	`its called trig`
`05:13.36`	`Patlabor221`	`coudl ya do it all with out openGL, cus I don't think that works on linux`
`05:13.41`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Texture.py): Oops, more whitespace changes. Respect the guidelines for blank lines.`
`05:13.54`	`*** join/#bzflag sgi (~sgi@pcp01642968pcs.sothfd01.mi.comcast.net)`
`05:13.56`	`captain_proton`	`Patlabor221: this -should- run on windows ;-)`
`05:14.05`	`captain_proton`	`in fact, you should try it`
`05:14.08`	`scanline`	`captain_proton: but trig is so much more fun with matrices`
`05:14.11`	`Patlabor221`	`well if it uses openGL it won't run on linux`
`05:14.15`	`Patlabor221`	`not here at least`
`05:14.27`	`captain_proton`	`Patlabor221: install python, pygame & pyopengl on your windows machine`
`05:14.29`	`scanline`	`Patlabor221: there's one view that doesn't use OpenGL, and two that do`
`05:14.31`	`sgi`	`where are you`
`05:14.49`	`scanline`	`and PIL`
`05:16.52`	`Patlabor221`	`I'll have to get a python implementation`
`05:16.58`	`Patlabor221`	`least windows installers actualy work`
`05:17.42`	`scanline`	`feel free to write a view that uses Direct3D`
`05:17.52`	`captain_proton`	`hehe`
`05:17.53`	`Patlabor221`	`no direct X on linux`
`05:18.01`	`Patlabor221`	`GL works perfectly on my windows machine`
`05:18.14`	`scanline`	`so go back to using windows and stop complaining`
`05:18.47`	`Patlabor221`	`isn't that what you tell linux people when they complain about windows :)`
`05:19.06`	`Patlabor221`	`how do I make it go?`
`05:19.10`	`scanline`	`I think the important part of it is the not complaining part`
`05:19.23`	`Patlabor221`	`naw complaining is fun`
`05:19.32`	`scanline`	`:)`
`05:19.59`	`Patlabor221`	`tho it seems on my 750th install of linux I am geting much much farther.`
`05:20.32`	`Patlabor221`	`what file to I run to start it?`
`05:20.42`	`captain_proton`	`have you installed all the libraries?`
`05:20.52`	`Patlabor221`	`I installed the python thingy`
`05:20.55`	`Patlabor221`	`what else is needed`
`05:21.07`	`captain_proton`	`pygame, pyopengl, pil`
`05:21.15`	`Patlabor221`	`oh my`
`05:21.19`	`Patlabor221`	`rather lot that is`
`05:21.53`	`scanline`	`it's really the standard 3 libs you have to do for any real graphics in python`
`05:22.00`	`scanline`	`s/do/have/`
`05:22.07`	`Patlabor221`	`makes sense`
`05:22.34`	`scanline`	`you can run the non-graphical parts of PyBZFlag with just python's standard lib`
`05:22.44`	`Patlabor221`	`coo`
`05:22.53`	`*** join/#bzflag SGI (~SGI@pcp01642968pcs.sothfd01.mi.comcast.net)`
`05:22.56`	`Patlabor221`	`icky pyopengl uses glut?`
`05:23.03`	`captain_proton`	`it can`
`05:23.18`	`captain_proton`	`we're using it with sdl (pygame)`
`05:23.23`	`Patlabor221`	`cept for the glut_Teapot()`
`05:23.24`	`Patlabor221`	`:)`
`05:25.21`	`Patlabor221`	`ok got those 3`
`05:25.31`	`captain_proton`	`lets go for the big one first :)`
`05:25.39`	`Patlabor221`	`they all came with nice fluffy installers :)`
`05:25.40`	`CIA`	`03micahjd * 12pybzflag/BZFlag (2 files in 2 dirs): More cleanups`
`05:25.57`	`captain_proton`	`observer.py -sbrlcad.org:4242 -cYay -u3D`
`05:26.03`	`Patlabor221`	`what file do I tell pythion to run?`
`05:26.15`	`captain_proton`	`you need to do command line`
`05:26.20`	`Patlabor221`	`ok`
`05:26.28`	`scanline`	`hrm`
`05:26.41`	`scanline`	`that little cleanup I just did appears to have slowed it down a good bit`
`05:26.49`	`Patlabor221`	`ok got a python command line`
`05:26.56`	`captain_proton`	`eek, not a python command line`
`05:27.00`	`captain_proton`	`dos :)`
`05:27.04`	`captain_proton`	`then run the command i gave above`
`05:27.08`	`Patlabor221`	`ok I got a normal`
`05:28.52`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Store draw functions rather than drawables in ThreeDView to avoid subclassing overhead`
`05:29.58`	`captain_proton`	`any progress typing in that command?`
`05:30.24`	`Patlabor221`	`ohh didn't see it, thought it was a comit :)`
`05:30.54`	`MrApathyCream`	`where are the libs from?`
`05:31.08`	`Patlabor221`	`problems in ui = 'overhead').parse() and other stuff`
`05:31.38`	`Patlabor221`	`some socket problems too`
`05:31.46`	`captain_proton`	`can you paste the errors?`
`05:33.12`	`CIA`	`03micahjd * 12pybzflag/BZFlag (3 files in 3 dirs): Move Drawable to join its friends Texture and ThreeDView in the UI package`
`05:33.36`	`scanline`	`hrmph, something that changed recently made it slow`
`05:33.43`	`Patlabor221`	`let me dump them to a file`
`05:34.25`	`Patlabor221`	`no I can't paste them`
`05:34.35`	`captain_proton`	`...obviously`
`05:35.12`	`Patlabor221`	`it wouldn't even redirect`
`05:35.12`	`Patlabor221`	`wierd`
`05:35.21`	`captain_proton`	`ummm`
`05:35.24`	`scanline`	`it's probably stderr rather than stdout`
`05:35.24`	`*** join/#bzflag SGI (~SGI@pcp01642968pcs.sothfd01.mi.comcast.net)`
`05:35.32`	`captain_proton`	`the dos shell program thingy has a paste button`
`05:35.32`	`Patlabor221`	`ahhh yeah`
`05:35.43`	`Patlabor221`	`it dosn't have a copy button`
`05:35.45`	`Patlabor221`	`that's the problem`
`05:35.48`	`Patlabor221`	`can't select the text`
`05:35.49`	`captain_proton`	`it should`
`05:35.55`	`scanline`	`you drag a box around the text and press enter, that copies`
`05:35.55`	`*** join/#bzflag SGI (~SGI@pcp01642968pcs.sothfd01.mi.comcast.net)`
`05:36.08`	`Patlabor221`	`oooooooo they changed it`
`05:36.08`	`Patlabor221`	`C:\Documents and Settings\JeffM\Desktop\asdfasdf\pybzflag>observer.py -sbrlcad.o`
`05:36.08`	`Patlabor221`	`rg:4242 -cYay -u3D>barf.txt`
`05:36.08`	`Patlabor221`	`Traceback (most recent call last):`
`05:36.08`	`Patlabor221`	`<PROTECTED>`
`05:36.08`	`Patlabor221`	`line 6, in ?`
`05:36.10`	`Patlabor221`	`<PROTECTED>`
`05:36.12`	`Patlabor221`	`<PROTECTED>`
`05:36.14`	`Patlabor221`	`Line.py", line 115, in parse`
`05:36.16`	`Patlabor221`	`<PROTECTED>`
`05:36.18`	`Patlabor221`	`<PROTECTED>`
`05:36.20`	`Patlabor221`	`.py", line 347, in setOptions`
`05:36.22`	`Patlabor221`	`<PROTECTED>`
`05:36.24`	`Patlabor221`	`<PROTECTED>`
`05:36.26`	`Patlabor221`	`y", line 63, in __call__`
`05:36.28`	`Patlabor221`	`<PROTECTED>`
`05:36.30`	`Patlabor221`	`<PROTECTED>`
`05:36.32`	`Patlabor221`	`Base.py", line 47, in setOptions`
`05:36.34`	`Patlabor221`	`<PROTECTED>`
`05:36.36`	`Patlabor221`	`<PROTECTED>`
`05:36.37`	`MrApathyCream`	`Patlabor221: right click the menu and enable quick edit mode`
`05:36.38`	`Patlabor221`	`Base.py", line 64, in connect`
`05:36.40`	`Patlabor221`	`<PROTECTED>`
`05:36.42`	`Patlabor221`	`<PROTECTED>`
`05:36.44`	`Patlabor221`	`.py", line 76, in connect`
`05:36.46`	`Patlabor221`	`<PROTECTED>`
`05:36.48`	`Patlabor221`	`<PROTECTED>`
`05:36.50`	`Patlabor221`	`socket.error: (10035, 'The socket operation could not complete without blocking'`
`05:36.56`	`Patlabor221`	`that's what I just found`
`05:36.58`	`Patlabor221`	`had to hit "mark"`
`05:37.00`	`captain_proton`	`oog`
`05:37.00`	`Patlabor221`	`that's new in XP`
`05:37.04`	`scanline`	`Argh, damn`
`05:37.12`	`MrApathyCream`	`quick edit mode allows you to drag the hilite`
`05:37.13`	`Patlabor221`	`phear my long ass nasty pathnames :)`
`05:37.19`	`Patlabor221`	`so does mark`
`05:37.22`	`scanline`	`ok, every platform seems to have a different way of determining if a nonblocking socket is doing the nonblocking thing`
`05:37.38`	`Patlabor221`	`I don't have a "quickedit" thingy`
`05:37.58`	`scanline`	`but.. hmm...`
`05:38.06`	`scanline`	`wait.. does this mean windows doesn't support nonblocking connect?`
`05:38.37`	`MrApathyCream`	`Options tab, bottom right`
`05:38.38`	`*** part/#bzflag creeperz (~creeperz@host-11-76-220-24.midco.net)`
`05:38.45`	`scanline`	`I could wait until after connection to turn off blocking, but that sucks`
`05:38.56`	`scanline`	`anyway, try something that doesn't need network, like worldviewer`
`05:39.09`	`Patlabor221`	`ahh I see it now`
`05:39.31`	`scanline`	`it's a traceback, the error itself is at the bottom`
`05:39.54`	`captain_proton`	`./worldviewer random -u3D`
`05:39.59`	`captain_proton`	`sans ./ =)`
`05:40.24`	`captain_proton`	`and + .py`
`05:41.03`	`Patlabor221`	`ohh it did NOT like that`
`05:41.19`	`captain_proton`	`hm?`
`05:41.29`	`Patlabor221`	`let me get to a shorter path`
`05:41.42`	`scanline`	`just give the last 3 lines or so`
`05:41.51`	`*** join/#bzflag SGI (~SGI@pcp01642968pcs.sothfd01.mi.comcast.net)`
`05:42.14`	`Patlabor221`	`C:\pybzflag>worldviewer.py random -u3D`
`05:42.14`	`Patlabor221`	`Traceback (most recent call last):`
`05:42.14`	`Patlabor221`	`<PROTECTED>`
`05:42.14`	`Patlabor221`	`<PROTECTED>`
`05:42.14`	`Patlabor221`	`<PROTECTED>`
`05:42.14`	`Patlabor221`	`y", line 243, in run`
`05:42.16`	`Patlabor221`	`BZFlag.Errors.ConnectionLost`
`05:42.39`	`scanline`	`oh poppycock...`
`05:42.50`	`scanline`	`is your windows networking really that broken?`
`05:43.07`	`scanline`	`it probably can't handle a select() with three empty lists`
`05:43.09`	`MrApathyCream`	`my pythons impl`
`05:43.20`	`MrApathyCream`	`maybe pythons impl`
`05:43.58`	`Patlabor221`	`I got python 2.2.3`
`05:44.09`	`scanline`	`well, python has to wrap winsock to look like something posix-ish`
`05:45.59`	`CIA`	`03micahjd * 12pybzflag/BZFlag (Event.py): Don't select() on three empty lists, should fix non-networked pybzflag apps under windows`
`05:48.30`	`CIA`	`03micahjd * 12pybzflag/BZFlag (Network.py): Don't enable nonblocking mode until after a listen(), connect(), or accept(). This should fix networked pybzflag apps on win32's half-baked socket library that can't handle a nonblocking connect()`
`05:48.56`	`scanline`	`ok, try it all now`
`05:49.11`	`scanline`	`whoops`
`05:49.16`	`Patlabor221`	`C:\pybzflag>worldviewer.py random -u3D`
`05:49.16`	`Patlabor221`	`Traceback (most recent call last):`
`05:49.16`	`Patlabor221`	`<PROTECTED>`
`05:49.16`	`Patlabor221`	`<PROTECTED>`
`05:49.16`	`Patlabor221`	`<PROTECTED>`
`05:49.16`	`Patlabor221`	`y", line 243, in run`
`05:49.16`	`scanline`	`need to fix one more thing...`
`05:49.18`	`Patlabor221`	`BZFlag.Errors.ConnectionLost`
`05:50.01`	`captain_proton`	`scanline: well - winsock looks like bsd a bit`
`05:50.16`	`scanline`	`captain_proton: except they messed it up`
`05:50.25`	`captain_proton`	`yep`
`05:50.34`	`Patlabor221`	`this is why I allways use libs :)`
`05:51.14`	`CIA`	`03micahjd * 12pybzflag/BZFlag (Event.py): unbreak the event loop`
`05:51.55`	`Patlabor221`	`there it goes`
`05:52.03`	`Patlabor221`	`well world viewer`
`05:52.11`	`scanline`	`neat`
`05:52.15`	`captain_proton`	`screenshot!`
`05:52.26`	`scanline`	`load something more interesting than random :)`
`05:52.31`	`Patlabor221`	`observer works too`
`05:52.35`	`scanline`	`hooray`
`05:52.49`	`Patlabor221`	`tho seems noone is there`
`05:53.06`	`captain_proton`	`3d views only draw the world at the moment`
`05:53.12`	`Patlabor221`	`ahhh`
`05:53.24`	`scanline`	`the 'radar' and 'overhead' views draw players`
`05:53.30`	`scanline`	`only the overhead view draws flags`
`05:53.33`	`scanline`	`nothing draws shots yet`
`05:53.38`	`Patlabor221`	`wow realy suckin up the CPU there aren't ya`
`05:54.13`	`scanline`	`heh`
`05:54.28`	`scanline`	`right now it just tries to keep a constant frame rate, there's no code to shut that off when nothing is changing`
`05:54.29`	`Patlabor221`	`seems to hold between 95 and 98%`
`05:54.41`	`captain_proton`	`(screenshot)`
`05:54.48`	`Patlabor221`	`yeah uploading now`
`05:55.14`	`Patlabor221`	`http://www.bakadigital.com/python.jpg`
`05:55.30`	`captain_proton`	`yay`
`05:55.31`	`scanline`	`hehe`
`05:55.59`	`Patlabor221`	`now if I could just get linux to work that easy`
`05:56.15`	`captain_proton`	`it makes me happy to see the same opengl code working on all platforms`
`05:56.46`	`scanline`	`and the networking code works, with only two small concessions to winsock's braindeadness!`
`05:57.52`	`MrApathyCream`	`does ms decide on bugs?`
`05:58.02`	`MrApathyCream`	`at our company we can get them without any meetings`
`05:58.20`	`MrApathyCream`	`i thought we were doing something wrong`
`05:58.57`	`CIA`	`03micahjd * 12pybzflag/BZFlag (Network.py):`
`05:58.58`	`CIA`	`Add a note about connect() to BaseSocket.setBlocking's doc string,`
`05:58.58`	`CIA`	`so I don't try to fix this later and break windows support.`
`05:59.01`	`MrApathyCream`	`Patlabor221: osx-skin?`
`05:59.55`	`Patlabor221`	`visual style yes`
`06:00.18`	`captain_proton`	`hmm scanline`
`06:00.21`	`captain_proton`	`that is a lot slower`
`06:00.31`	`scanline`	`yep.. not sure why yet`
`06:00.47`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (ThreeDView.py): pan up & down`
`06:01.24`	`Patlabor221`	`won't work on the linux machine`
`06:01.58`	`scanline`	`captain_proton: only thing using a notable amount of CPU is the draw() function... which is as it should be`
`06:02.20`	`scanline`	`maybe just moving the draw function from the individual classes to a base class made it slower?`
`06:03.25`	`*** join/#bzflag Patlabor22Busted (~jeffm@adsl-64-173-106-69.dsl.lsan03.pacbell.net)`
`06:04.15`	`scanline`	`captain_proton: maybe when I reindented I broke something causing it to render some things too many times?`
`06:04.24`	`captain_proton`	`possible`
`06:05.23`	`Patlabor22Busted`	`<PROTECTED>`
`06:05.24`	`Patlabor22Busted`	`<PROTECTED>`
`06:05.24`	`Patlabor22Busted`	`NameError: name 'True' is not defined`
`06:05.58`	`captain_proton`	`huh`
`06:06.01`	`scanline`	`hmm, where are you seeing that?`
`06:06.11`	`Patlabor221`	`when I run worldviewer`
`06:06.16`	`scanline`	`what version of python?`
`06:06.25`	`Patlabor221`	`2.2 I think`
`06:06.30`	`scanline`	`I would bet it isn't`
`06:06.45`	`Patlabor221`	`how do I find out?`
`06:06.50`	`Patlabor221`	`--version didn't seem to do it`
`06:06.51`	`scanline`	`run python`
`06:06.59`	`scanline`	`it gives you the version when it starts up`
`06:06.59`	`captain_proton`	`python -V`
`06:07.04`	`MrApathyCream`	`Patlabor221 said 2.2.3 at the beginning`
`06:07.15`	`Patlabor221`	`that was on windows`
`06:07.29`	`MrApathyCream`	`ah`
`06:07.31`	`Patlabor221`	`linux says 2.1.3`
`06:07.37`	`scanline`	`yeah, this requires 2.2`
`06:07.42`	`scanline`	`for several reasons`
`06:08.06`	`scanline`	`only ones I remember off the top of my head are True/False and list comprehensions though`
`06:08.10`	`Patlabor221`	`seems I do have 2.2`
`06:08.16`	`Patlabor221`	`just need to make it use it`
`06:08.24`	`Patlabor221`	`it has bth installed`
`06:08.37`	`scanline`	`you could edit the #! line at the top of the script, or you could just explicitly type python22 before the script name`
`06:08.47`	`learner`	`is there a windows screenshot now?`
`06:08.55`	`scanline`	`or python2.2, whatever`
`06:09.00`	`Patlabor221`	`that is what I did`
`06:09.03`	`scanline`	`learner: http://www.bakadigital.com/python.jpg`
`06:09.18`	`Patlabor221`	`but seems it didn't install pygame for 2.2`
`06:09.44`	`learner`	`cool.`
`06:09.51`	`scanline`	`that's silly... the distro probably has a separate package for pygame on 2.2 though`
`06:09.54`	`Patlabor221`	`nope no pygame in apt :(`
`06:09.56`	`learner`	`now we just need... sgi`
`06:10.06`	`Patlabor221`	`not for woddy`
`06:10.08`	`captain_proton`	`learner: i'll get that on monday ;-)`
`06:10.16`	`Patlabor221`	`it's pygame package dosn't have a version`
`06:10.31`	`learner`	`;-)`
`06:10.34`	`scanline`	`Patlabor221: heh, that's why nobody uses debian woody... so,you'll have to compile it`
`06:10.50`	`learner`	`I'd be surprised if you find pygame/pyopengl for sgi, cap..`
`06:10.53`	`Patlabor221`	`I'm gonna update to testing here in a sec`
`06:11.28`	`scanline`	`learner: pygame/pyopengl are just wrappers around SDL and OpenGL with a bucket full of bells and whistles.. I wouldn't be surprised`
`06:11.33`	`captain_proton`	`learner: i can build them`
`06:11.54`	`learner`	`and cross fingers :)`
`06:12.02`	`captain_proton`	`shouldn't be too bad`
`06:12.07`	`learner`	`one would hope`
`06:12.18`	`captain_proton`	`i've got sdl already from the sgi freeware`
`06:12.36`	`captain_proton`	`and i got python 2.2 built the other day`
`06:12.39`	`learner`	`ah.. didn't know that existed -- that's most of the work. cool`
`06:12.41`	`MrApathyCream`	`WOOWOO it works!!`
`06:12.46`	`captain_proton`	`=)`
`06:13.01`	`scanline`	`hehe`
`06:14.08`	`Patlabor221`	`linux realy does hate me`
`06:14.14`	`scanline`	`"91 objects in world, 329 drawables rendered"`
`06:14.20`	`scanline`	`er`
`06:14.28`	`scanline`	`cut off a 1, that's supposed to be 191 objects`
`06:14.49`	`captain_proton`	`scanline: yeup =)`
`06:15.54`	`MrApathyCream`	`http://bzflag.mebigfatguy.com/pyd46.jpg`
`06:16.16`	`captain_proton`	`but with AA =)`
`06:16.26`	`scanline`	`yipes, it's XP`
`06:16.36`	`Patlabor221`	`are your normals on the pyramids bad cap, they look horibly lit`
`06:16.56`	`scanline`	`I don't think it's doing any lighting yet`
`06:17.49`	`captain_proton`	`Patlabor221: i don't think so - feel free to take a look`
`06:17.52`	`Patlabor221`	`ooo don't resize the window`
`06:17.59`	`Patlabor221`	`it goes BAD`
`06:18.10`	`scanline`	`Patlabor221: as far as I can tell it's an SDL bug`
`06:18.11`	`learner`	`:)`
`06:18.22`	`captain_proton`	`sdl really needs a soft resize thingy`
`06:18.40`	`Patlabor221`	`patch it on up :)`
`06:18.42`	`scanline`	`I should read the source and see if there's anything that's supposed to prevent the problem`
`06:19.09`	`captain_proton`	`for people who can't do (setq resize-outline-mode 'box)`
`06:19.22`	`learner`	`I've done resizing with sdl in other apps; is this something python-specific?`
`06:19.22`	`scanline`	`or who don't want to.. it'd be nice to have smooth resize`
`06:19.30`	`scanline`	`except in the overhead view where resizing is really slow`
`06:19.38`	`scanline`	`learner: it could be`
`06:20.47`	`MrApathyCream`	`http://bzflag.mebigfatguy.com/pyheart.jpg`
`06:20.55`	`Michaelh`	`wad is sdl`
`06:21.16`	`Patlabor221`	`Simple Directmedia Layer`
`06:21.25`	`scanline`	`captain_proton: it looks like we have no lighting at all`
`06:21.32`	`Patlabor221`	`it has much coolness`
`06:21.33`	`MrApathyCream`	`yes`
`06:21.38`	`Michaelh`	`sort of a cross platform directx?`
`06:21.48`	`scanline`	`Michaelh: sort of`
`06:21.54`	`Patlabor221`	`and more`
`06:21.56`	`MrApathyCream`	`more object oriented`
`06:21.59`	`Patlabor221`	`gl bindings and stuff`
`06:22.02`	`MrApathyCream`	`higher level`
`06:22.02`	`Patlabor221`	`yeah cleaner API`
`06:22.18`	`scanline`	`SDL really just handles events, video init, and blitting`
`06:22.18`	`Patlabor221`	`well DX has high level utils too`
`06:22.40`	`Patlabor221`	`sdlmixer can do sound too`
`06:22.40`	`scanline`	`you use other libraries on top of it or beside it usually.. like OpenGL for 3D, various others for 2D primitives`
`06:22.46`	`Michaelh`	`who ever came up with the funky com interface and thought it was a good idea`
`06:22.57`	`Patlabor221`	`well there is 1 good thing about com`
`06:23.01`	`Patlabor221`	`and 1 only`
`06:23.06`	`Michaelh`	`backwards compatibility?`
`06:23.07`	`captain_proton`	`scanline: hrm, thats odd`
`06:23.11`	`Patlabor221`	`yeah`
`06:23.13`	`Patlabor221`	`that's it`
`06:23.20`	`Patlabor221`	`there implementation sucks`
`06:23.45`	`scanline`	`captain_proton: all the pyramid and box sizes are the exact same color, so either we have no lighting or it's a directional light coming straight down`
`06:24.03`	`scanline`	`s/sizes/sides/`
`06:24.07`	`Patlabor221`	`on windows SDL just calls DX for a lot of it's stuff`
`06:24.24`	`scanline`	`right.. and on unixes it calls X..`
`06:24.38`	`scanline`	`unlike DX which does all the hardware interfacing itself`
`06:24.40`	`Patlabor221`	`and whatever it does on the mac`
`06:24.41`	`captain_proton`	`there's one light overhead and one in a corner`
`06:25.05`	`Patlabor221`	`SDL makes it real easy to get a window up and GL hooked into it`
`06:25.11`	`MrApathyCream`	`observer.py -sbrlcad.org:4242 -cYay -u3D works for me btw`
`06:25.27`	`MrApathyCream`	`Connected.`
`06:25.27`	`MrApathyCream`	`UDP link established, local port 17200`
`06:25.27`	`MrApathyCream`	`Downloading world...`
`06:25.27`	`MrApathyCream`	`World loaded.`
`06:25.27`	`MrApathyCream`	`Entered the game.`
`06:25.28`	`MrApathyCream`	`Added player 0 (0-0)[0] : Yay (PyBZFlag)`
`06:25.30`	`MrApathyCream`	`<server> BZFlag server 1.9a0, http://BZFlag.org/`
`06:25.32`	`MrApathyCream`	`<0> Shoot the White Rabbit; This is a test server; Test data is logged to http://brlcad.org/server.l`
`06:25.33`	`MrApathyCream`	`og (learner@brlcad.org)`
`06:25.45`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Hmm, we shouldn't enable GL_LIGHTING twice in one function`
`06:26.31`	`scanline`	`hey look, a BZFlag client`
`06:26.50`	`MrApathyCream`	`ninja joined`
`06:26.59`	`*** join/#bzflag lurgy (~lurgyman@161.97.199.99)`
`06:27.17`	`Patlabor221`	`can't rotate it anymore`
`06:27.24`	`captain_proton`	`middle mouse button`
`06:27.36`	`Patlabor221`	`ahh`
`06:27.47`	`MrApathyCream`	`Added player 0 (0-0)[0] : ninjasox (PyBZFlag)`
`06:27.47`	`MrApathyCream`	`Added player 0 (0-0)[0] : Sir I (Michael Hoffman@Michael Hoffman)`
`06:27.50`	`* topic/#bzflag by learner -> http://BZFlag.org/ \|\| http://list.BZFlag.org/ \|\| http://stats.BZFlag.org/ \|\| forums http://bzbb.bzflag.org \|\| put javadoc-style / comments */ in headers! \|\| cvs snapshots: http://sfsnap.babylonia.flatirons.org/ \|\| Network Meeting Notes @ http://www.bzflag.org/wiki/NetMeeting`
`06:27.53`	`MrApathyCream`	`two player 0's`
`06:28.25`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (2 files): Don't hardcode pi, it might change`
`06:28.26`	`scanline`	`that's not the player number, it's the score`
`06:28.31`	`MrApathyCream`	`ah`
`06:28.35`	`captain_proton`	`scanline: hehe`
`06:28.38`	`MrApathyCream`	`wow mouse wheel support`
`06:28.44`	`scanline`	`=)`
`06:28.45`	`captain_proton`	`smoooooth mouse wheel support`
`06:29.31`	`Michaelh`	`the bzpython client got setup as the rabbit even though you never joined the gmae`
`06:29.40`	`scanline`	`it does join the game`
`06:29.46`	`scanline`	`just doesn't send MsgAlive`
`06:29.53`	`captain_proton`	`MrApathyCream: hm?`
`06:29.54`	`Michaelh`	`hmmmm`
`06:30.03`	`Michaelh`	`but that's kind of an issue`
`06:30.15`	`scanline`	`Michaelh: join as an observer`
`06:30.18`	`MrApathyCream`	`i zoom in and out, but also rotate so now i'm looking almost straight down`
`06:30.18`	`Michaelh`	`server issue perhaps`
`06:30.36`	`scanline`	`Michaelh: if you don't join the game at all you don't get player position updates, messages, or pretty much anything`
`06:30.53`	`captain_proton`	`hrm`
`06:30.54`	`scanline`	`Michaelh: if it is joining as an observer and still becoming rabbit, that's a server bug`
`06:30.55`	`MrApathyCream`	`what are the controls?`
`06:30.57`	`captain_proton`	`wheel should just bee zoom`
`06:31.08`	`Michaelh`	`is it joining as an observer?`
`06:31.09`	`captain_proton`	`middle button+drag is rotate`
`06:31.15`	`*** join/#bzflag creeperz (~creeperz@host-11-76-220-24.midco.net)`
`06:31.16`	`MrApathyCream`	`ah.... hm...`
`06:31.20`	`scanline`	`Michaelh: use a nick starting with @`
`06:31.28`	`Michaelh`	`but him.......`
`06:31.34`	`captain_proton`	`usually the wheel is the button (click it)`
`06:31.37`	`Michaelh`	`he.... was he an observer?`
`06:31.48`	`MrApathyCream`	`i was kicked for idleing to long :)`
`06:31.55`	`captain_proton`	`did he have an @ in front of his name? :P`
`06:32.01`	`Michaelh`	`nope`
`06:32.09`	`captain_proton`	`ergo, he was not an observer`
`06:32.18`	`scanline`	`pybzflag supports the JAFO mode, but doesn't use it because it's broken in bzfs`
`06:32.37`	`Michaelh`	`oohh so if you didn't join as a non-observer you'd miss motion updates, etc..`
`06:32.44`	`scanline`	`?`
`06:32.50`	`scanline`	`observers get motion updates`
`06:32.55`	`Michaelh`	`doh`
`06:32.59`	`MrApathyCream`	`ah, ok, i got it`
`06:32.59`	`captain_proton`	`Michaelh: there's a difference between joining and becoming alive`
`06:33.04`	`scanline`	`it's supposed to be joining as an observer, that's the default`
`06:33.24`	`Michaelh`	`JAFO mode?`
`06:33.46`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Reenable the FHz indicator, I need it for profiling`
`06:34.07`	`MrApathyCream`	`hmmm zoom stops working after a while (zoom in)`
`06:34.15`	`scanline`	`stops working?`
`06:34.22`	`*** part/#bzflag creeperz (~creeperz@host-11-76-220-24.midco.net)`
`06:34.23`	`MrApathyCream`	`well, like at the center of the map`
`06:34.35`	`MrApathyCream`	`i can't zoom into the corner`
`06:35.07`	`captain_proton`	`thats because the focus is at the center of the map`
`06:35.07`	`scanline`	`it zooms relative to a point the camera is centered on, you can't zoom past that point`
`06:35.11`	`captain_proton`	`i'm working on panning`
`06:35.22`	`MrApathyCream`	`how do you change the focus?`
`06:35.38`	`captain_proton`	`alt+middle button moves up & down`
`06:35.46`	`captain_proton`	`horizontal panning is trickier`
`06:36.11`	`scanline`	`alt or shift?`
`06:36.20`	`MrApathyCream`	`alt`
`06:36.35`	`scanline`	`alt+middle did nothing for me, shift+middle gave me a ZeroDivisionError`
`06:36.41`	`MrApathyCream`	`Traceback (most recent call last):`
`06:36.41`	`MrApathyCream`	`<PROTECTED>`
`06:36.41`	`MrApathyCream`	`<PROTECTED>`
`06:36.41`	`MrApathyCream`	`<PROTECTED>`
`06:36.41`	`MrApathyCream`	`<PROTECTED>`
`06:36.42`	`MrApathyCream`	`<PROTECTED>`
`06:36.44`	`MrApathyCream`	`<PROTECTED>`
`06:36.46`	`MrApathyCream`	`<PROTECTED>`
`06:36.48`	`MrApathyCream`	`<PROTECTED>`
`06:36.52`	`MrApathyCream`	`<PROTECTED>`
`06:36.54`	`MrApathyCream`	`<PROTECTED>`
`06:36.56`	`MrApathyCream`	`<PROTECTED>`
`06:36.58`	`MrApathyCream`	`<PROTECTED>`
`06:37.00`	`MrApathyCream`	`<PROTECTED>`
`06:37.02`	`MrApathyCream`	`<PROTECTED>`
`06:37.03`	`scanline`	`urggg`
`06:37.04`	`MrApathyCream`	`<PROTECTED>`
`06:37.06`	`MrApathyCream`	`<PROTECTED>`
`06:37.07`	`captain_proton`	`only need the last few lines :P`
`06:37.08`	`MrApathyCream`	`<PROTECTED>`
`06:37.08`	`scanline`	`we don't need the whole flippin traceback`
`06:37.10`	`MrApathyCream`	`<PROTECTED>`
`06:37.12`	`MrApathyCream`	`<PROTECTED>`
`06:37.15`	`MrApathyCream`	`<PROTECTED>`
`06:37.16`	`MrApathyCream`	`ZeroDivisionError: float division`
`06:37.43`	`captain_proton`	`you -had- to use the shift key`
`06:37.56`	`scanline`	`MrApathyCream: 90% of the time the last three lines are enough to find the problem`
`06:37.59`	`scanline`	`and if not we'll ask for more`
`06:38.22`	`learner`	`yay, I'm not alone :P`
`06:38.54`	`MrApathyCream`	`you only get so many lines in one day's chat session after all.. better not waste-em`
`06:39.11`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (ThreeDView.py): get rid of div0, but its still borked`
`06:40.30`	`scanline`	`captain_proton: you don't need to keep track of modifiers yourself, there's a pygame thingy to do it`
`06:41.33`	`scanline`	`pygame.key.get_mods()`
`06:42.07`	`scanline`	`captain_proton: I wonder if this would count as the first real 3D app done with pygame? :)`
`06:42.20`	`scanline`	`I haven't been able to find many examples of OpenGL python code`
`06:42.53`	`*** join/#bzflag creeperz (~creeperz@host-11-76-220-24.midco.net)`
`06:43.21`	`captain_proton`	`it might be`
`06:43.35`	`scanline`	`hmm`
`06:43.47`	`scanline`	`I changed the order of some of the calls in Drawable, maybe that is causing this`
`06:44.06`	`scanline`	`psyco has almost no effect on the frame rate, which indicates it's probably an opengl issue`
`06:44.15`	`scanline`	`like maybe I'm changing state in the middle of a display list`
`06:44.30`	`MrApathyCream`	`trepan:)`
`06:44.36`	`*** join/#bzflag learnerTesting (sean@chr160dhcp1675.chrchv01.md.comcast.net)`
`06:44.50`	`learnerTesting`	`quit`
`06:45.01`	`captain_proton`	`that shouldn't cause such a huge drop in framerate`
`06:46.03`	`MrApathyCream`	`well, i guess this meeting isn't gonna happen today, maybe tomorrow, off to bed`
`06:46.12`	`captain_proton`	`hehe`
`06:46.25`	`scanline`	`captain_proton: well, it's definitely in Drawable.py.. I just pulled out an old version of it and my frame rate gets happy`
`06:46.25`	`*** join/#bzflag SGI (~SGI@pcp01642968pcs.sothfd01.mi.comcast.net)`
`06:47.31`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Drawable.py): Reverting to old Drawable, will make the changes one at a time to see what's causing the huge performance hit`
`06:49.56`	`*** join/#bzflag [STC]_creeperz (~creeperz@host-11-76-220-24.midco.net)`
`06:50.26`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (ThreeDView.py): welp, its a little less broken`
`06:51.50`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Drawable.py): Reperformed all the changes to Drawable except for refactoring the actual display list creation code. Still no speed hit.`
`06:51.56`	`scanline`	`ohhhh`
`06:52.02`	`scanline`	`:-/`
`06:52.13`	`captain_proton`	`hm?`
`06:52.20`	`scanline`	`it was loading the textures between glNewList and glEndList`
`06:52.24`	`captain_proton`	`ewwww`
`06:52.51`	`scanline`	`but never fear, the code in CVS now is both cleanish and fast!`
`06:53.06`	`*** join/#bzflag f\|zzy (freckles@chr160dhcp1675.chrchv01.md.comcast.net)`
`06:53.07`	`captain_proton`	`i was planning to split out the display list creation stuff into its own function`
`06:53.12`	`captain_proton`	`to rebuild it on an update`
`06:53.18`	`scanline`	`well, now we have a DisplayList class`
`06:53.30`	`scanline`	`that's exactly what I did, but I missed the texture stuff`
`06:53.38`	`scanline`	`now that I know what to be careful of I'll do it again :)`
`06:53.49`	`*** part/#bzflag [STC]_creeperz (~creeperz@host-11-76-220-24.midco.net)`
`06:54.02`	`captain_proton`	`the texture build should be in the ctor`
`06:54.18`	`captain_proton`	`since the textures won't change`
`06:54.20`	`scanline`	`yes. I can add a textureName attribute to the class`
`06:55.13`	`captain_proton`	`textureName? why not just texture`
`06:55.23`	`captain_proton`	`when i add a texture cache, we'll only have one texture object per texture loaded`
`06:55.38`	`scanline`	`well, texture is for the texture object`
`06:55.53`	`captain_proton`	`oh - just store the gl id?`
`06:55.57`	`scanline`	`I'm talking about a textureName that can be defined in the class itself, not the __init__`
`06:56.12`	`scanline`	`then the base class' __init__ actually loads the texture`
`06:56.20`	`scanline`	`that keeps things like data directory code in one place`
`06:56.42`	`scanline`	`I'm also adding a Util.dataFile function that will be a stuf for making the data dir configurable later`
`06:56.49`	`scanline`	`s/stuf/stub/`
`07:00.58`	`captain_proton`	`whats wrong with this:`
`07:01.00`	`captain_proton`	`<PROTECTED>`
`07:01.35`	`learner`	`if it were c-code it would be your usage of bitwise operators.. :)`
`07:01.49`	`scanline`	`captain_proton: looks fine to me. what error are you getting?`
`07:01.53`	`captain_proton`	`...oh?`
`07:02.02`	`captain_proton`	`scanline: no error. its always returning true`
`07:02.17`	`scanline`	`learner: what's wrong with it bitwisely?`
`07:02.42`	`learner`	`if pygame.K_... have any value, it'll always be true, bitwise`
`07:03.01`	`captain_proton`	`....how?`
`07:03.26`	`learner`	`true == !0`
`07:03.37`	`learner`	`but you're in python`
`07:03.39`	`scanline`	`captain_proton: oh, I found your team base problem. you had most of the function indented under the 'f self.team == "purple"'`
`07:03.44`	`learner`	`i didn't think python had bitwise`
`07:03.57`	`scanline`	`learner: python's bitwise works just like C's`
`07:04.09`	`captain_proton`	`but there's an and in there`
`07:04.12`	`scanline`	`learner: and that still looks like good bitwise logic`
`07:04.21`	`scanline`	`captain_proton: try printing the mods you get in hex`
`07:04.29`	`learner`	`hrmm....`
`07:06.20`	`captain_proton`	`how to print in hex?`
`07:06.36`	`scanline`	`print "0x%08X" % 1234`
`07:06.50`	`*** join/#bzflag f\|zzy (freckles@chr160dhcp1675.chrchv01.md.comcast.net)`
`07:06.52`	`scanline`	`it's like printf, in an amazingly compressed space`
`07:07.15`	`captain_proton`	`0x00001100`
`07:07.19`	`captain_proton`	`i believe thats with lalt`
`07:07.49`	`scanline`	`hm.. I guess you've tried pressing and releasing the mods, to see if they're stuck on?`
`07:07.55`	`captain_proton`	`yep`
`07:08.04`	`scanline`	`strange`
`07:08.22`	`scanline`	`maybe it has them mapped wrong..?`
`07:08.27`	`scanline`	`like one of those is numlock? :)`
`07:08.45`	`captain_proton`	`numlock isn't a modifier`
`07:08.51`	`scanline`	`it is in SDL`
`07:09.43`	`captain_proton`	`ohh`
`07:09.47`	`captain_proton`	`i think i see my error`
`07:11.01`	`captain_proton`	`KMOD_LSHIFT, not K_LSHIFT`
`07:11.02`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (ThreeDView.py): use get_mods() instead of hand-tracking modifier state`
`07:11.24`	`scanline`	`ahh`
`07:11.29`	`scanline`	`yes, that would do it`
`07:12.02`	`*** join/#bzflag molney (~molney@ppp123-246.lns1.syd2.internode.on.net)`
`07:12.34`	`scanline`	`whee`
`07:12.36`	`CIA`	`03micahjd * 12pybzflag/BZFlag (2 files in 2 dirs): Reniftify the display list code, without making any dumb mistakes that will screw up the frame rate`
`07:12.50`	`scanline`	`now all the objects are subclasses of DisplayList, that define a textureName and a drawToList function`
`07:12.58`	`captain_proton`	`neat`
`07:13.07`	`captain_proton`	`fixed team bases?`
`07:13.15`	`scanline`	`probably, but haven't tested it`
`07:13.36`	`scanline`	`yep!`
`07:13.52`	`scanline`	`eye-piercing unlit red and blue polygons`
`07:15.34`	`lurgy`	`scanline: can you remember how much hard disks were when you we were discussing last?`
`07:15.54`	`scanline`	`hm.. $120 I think?`
`07:16.05`	`lurgy`	`k`
`07:16.18`	`captain_proton`	`looks like they're at $114`
`07:16.24`	`lurgy`	`yep`
`07:16.27`	`lurgy`	`at this rate`
`07:16.46`	`lurgy`	`maybe below $110 by the time we actually need them`
`07:16.50`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/Protocol (WorldObjects.py): draw base structure when z != 0`
`07:16.52`	`lurgy`	`which saves us $50 or so`
`07:17.03`	`scanline`	`captain_proton: hm... the team bases actually seem to intermittently not work`
`07:17.31`	`captain_proton`	`hm?`
`07:17.49`	`scanline`	`or maybe I'm going crazy`
`07:18.12`	`lurgy`	`not scanline`
`07:18.28`	`lurgy`	`scanline + crazy = 0`
`07:18.55`	`scanline`	`captain_proton: yeah... I run it, I get team bases.. I run it again, I get none`
`07:20.24`	`captain_proton`	`bwahahahaha`
`07:20.32`	`scanline`	`uh oh`
`07:20.53`	`scanline`	`suppose we need a good way to pass command line options to the view`
`07:21.26`	`captain_proton`	`eh`
`07:21.38`	`captain_proton`	`i was thinking of subclassing the 3dview`
`07:22.15`	`scanline`	`ah.. and add a new module with a new attach() function, so we get "-u anaglyph" or something? :)`
`07:22.25`	`captain_proton`	`yep =)`
`07:22.33`	`bzgirl`	`captain_proton: is ther a console irc client on asgard?`
`07:22.41`	`captain_proton`	`bzgirl: i dunno`
`07:23.01`	`captain_proton`	`if you wanna grab an rpm of irssi i'll install it for you`
`07:23.11`	`bzgirl`	`ok cool`
`07:23.19`	`bzgirl`	`RH 8?`
`07:23.24`	`scanline`	`captain_proton: that'd be harder to do though once we have a system for hooking up multiple views and viewports.. or even for toggling it on and off while in the editor or game`
`07:23.25`	`captain_proton`	`iirc yes`
`07:23.29`	`captain_proton`	`cat /etc/redhat-release`
`07:24.02`	`scanline`	`captain_proton: hmm, or.. we just need a good way to switch around views at runtime :)`
`07:24.20`	`scanline`	`so you could swap out the ThreeDView for a RadarView, or anaglyph, wireframe, terminal emulator...`
`07:24.30`	`captain_proton`	`terminal emulator? =)`
`07:24.36`	`scanline`	`cough`
`07:26.56`	`scanline`	`hmm...`
`07:27.01`	`scanline`	`your ambient light values look awfully high`
`07:27.19`	`scanline`	`ah, that's the problem`
`07:27.30`	`scanline`	`we have lighting, but it's all boring lighting`
`07:28.09`	`captain_proton`	`hehe`
`07:28.13`	`scanline`	`and it looks like the lights are always relative to the camera`
`07:28.26`	`captain_proton`	`we could put red, green and blue lights at opposite corners`
`07:28.33`	`captain_proton`	`maybe move them around a little`
`07:28.37`	`scanline`	`ooh!`
`07:29.07`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Turn down the ambient lighting to levels that won't make crystalspace developers cringe`
`07:31.26`	`captain_proton`	`heh`
`07:32.06`	`bzgirl`	`captain_proton: its in /mnt/bfoj/public_html/irssi-0.8.6-2.i386.rpm`
`07:32.34`	`scanline`	`http://navi.picogui.org/~micah/tmp/i_cant_believe_its_not_bzflag.png`
`07:32.54`	`*** part/#bzflag learner (sean@chr160dhcp1675.chrchv01.md.comcast.net)`
`07:33.45`	`captain_proton`	`bzgirl: installed`
`07:33.54`	`bzgirl`	`you da man`
`07:33.58`	`bzgirl`	`ty`
`07:34.15`	`*** join/#bzflag learner (sean@chr160dhcp1675.chrchv01.md.comcast.net)`
`07:35.04`	`scanline`	`that lighting is still in camera coords it seems`
`07:35.31`	`*** part/#bzflag bzgirl (~brat@toronto-hs-64-26-176-100.s-ip.magma.ca)`
`07:37.33`	`captain_proton`	`scanline: how do i add anaglyph to the available uis?`
`07:38.19`	`scanline`	`captain_proton: there's a map of short names to module names in UI/__init__.py, add it there`
`07:41.22`	`captain_proton`	`hrm...`
`07:41.26`	`captain_proton`	`where does the 3d view clear the buffers?`
`07:42.10`	`scanline`	`OpenGLViewport's onSetupFrame handler`
`07:42.33`	`scanline`	`it needs to go in the viewport not in the view, so things don't go wonky when you have multiple views in one viewport`
`07:43.29`	`scanline`	`there could be a needClear flag in the viewport that starts out True but can be cleared by any view`
`07:45.45`	`captain_proton`	`hehe`
`07:45.52`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (2 files): add anaglyph stereo mode`
`07:46.00`	`captain_proton`	`that was sickeningly easy`
`07:50.14`	`CIA`	`03brlcad * 12bzflag/include (WordFilter.h): dewormed badness`
`07:51.42`	`*** join/#bzflag MrCooper (~daenzer@dclient80-218-118-173.hispeed.ch)`
`07:53.05`	`captain_proton`	`scanline: can you repost this on navi:`
`07:53.15`	`captain_proton`	`http://jupiter.babylonia.flatirons.org/retro.png`
`07:53.33`	`scanline`	`=)`
`07:55.25`	`scanline`	`http://navi.picogui.org/images/bzflag/`
`07:56.08`	`scanline`	`hmm, I bet diablo will complain about the size of that file too`
`07:57.25`	`captain_proton`	`likely`
`07:59.54`	`scanline`	`there, and now all them windows and OS X screenies are ther too`
`08:05.28`	`scanline`	`captain_proton: getting this thing ready for the Onyx? :)`
`08:05.36`	`captain_proton`	`indeedy`
`08:07.20`	`captain_proton`	`none of the #commits clowns has gotten scared at that screenshot :P`
`08:12.20`	`scanline`	`sad, isn't it`
`08:13.24`	`captain_proton`	`nesting display lists?`
`08:13.38`	`scanline`	`is that bad?`
`08:13.56`	`captain_proton`	`not necessarily`
`08:14.06`	`captain_proton`	`i was just asking to make sure i understood what you were talking about`
`08:14.20`	`scanline`	`ah, ok`
`08:14.28`	`scanline`	`well, I'm only committing this if it gives a speed boost`
`08:15.05`	`captain_proton`	`would add some additional overhead when changing the world`
`08:15.18`	`scanline`	`yes`
`08:15.28`	`scanline`	`though I tried something similar to this in picogui once`
`08:15.44`	`scanline`	`and compiling display lists turned out to be very decently fast`
`08:19.06`	`scanline`	`well, my frame rate doubled, but it's not actually outputting anything :)`
`08:20.00`	`captain_proton`	`hehe`
`08:28.11`	`scanline`	`wow...`
`08:28.22`	`scanline`	`on this one map I go from 14FHz to 45`
`08:28.37`	`captain_proton`	`with the display list hack?`
`08:28.40`	`scanline`	`yes`
`08:29.11`	`scanline`	`oh hmm..`
`08:29.29`	`scanline`	`when viewing the world from far away it's faster, but viewing it from the inside it's extremely slow`
`08:29.48`	`captain_proton`	`ah, that makes sense`
`08:29.52`	`scanline`	`yep`
`08:30.23`	`captain_proton`	`perhaps we should eventually do some sort of bsp of display lists >=)`
`08:30.30`	`scanline`	`hehe`
`08:30.56`	`captain_proton`	`hmm`
`08:30.58`	`captain_proton`	`that'd be damn fast`
`08:31.09`	`scanline`	`it's interesting though, the profiler showed almost all the time being spent in draw(), which just calls some display lists`
`08:31.16`	`scanline`	`so I doubt there's much overhead to using python`
`08:32.11`	`captain_proton`	`hehe`
`08:32.15`	`captain_proton`	`anaglyph makes me happy`
`08:32.25`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Drawable.py): A little more flexibility in subclassing DisplayList`
`08:32.27`	`scanline`	`the anaglyph view is indeed simple :)`
`08:32.49`	`captain_proton`	`it felt like cheating after i finished it`
`08:32.53`	`captain_proton`	`"that was too easy"`
`08:33.07`	`scanline`	`well, it won't work for 1st person the way you did the offsets`
`08:33.22`	`scanline`	`but the clean rendering architecture seems to help :)`
`08:33.27`	`captain_proton`	`no`
`08:33.39`	`captain_proton`	`but i should clean up the eyeball stuff anyway`
`08:33.42`	`captain_proton`	`to do some real calcs`
`08:33.59`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (AnaglyphView.py): whoops, comments backwards`
`08:34.14`	`captain_proton`	`so`
`08:34.29`	`captain_proton`	`for the onyx, i need the view to have two side-by-side panes`
`08:35.16`	`scanline`	`ahh yes`
`08:35.47`	`captain_proton`	`ahh`
`08:35.47`	`captain_proton`	`perfect`
`08:35.49`	`scanline`	`I could write that and you could fix the lighting :)`
`08:36.59`	`captain_proton`	`ok`
`08:37.10`	`captain_proton`	`i'll be going to bed pretty soon, so it probably won't get completely fixed tonight`
`08:37.16`	`scanline`	`okey`
`08:37.38`	`scanline`	`hmm, would be really easy to do that rear-view-in-a-config-file thing with this code`
`08:39.05`	`captain_proton`	`it seems like for the most part, as far as views are concerned, its pretty easy to do just about anything`
`08:39.15`	`captain_proton`	`ok, here's a question for ya`
`08:39.20`	`captain_proton`	`you'd wrap a view`
`08:39.48`	`captain_proton`	`in my case, i'd want to capture the mouse inside one of them`
`08:39.52`	`captain_proton`	`and share camera data between the two`
`08:40.48`	`scanline`	`hmm, will need a good way to specify how events are divided up`
`08:49.21`	`captain_proton`	`hmm`
`08:49.30`	`captain_proton`	`perhaps panning & rotation should use the logarithmic evaluator widget`
`08:49.40`	`scanline`	`:)`
`08:51.22`	`CIA`	`03davidtrowbridge * 12pybzflag/doc (TODO): reminders for tomorrow`
`08:51.29`	`captain_proton`	`'night`
`08:51.33`	`scanline`	`g'night`
`08:52.43`	`CIA`	`03micahjd * 12pybzflag/doc (TODO): Remove thumbnailing from TODO, it's done`
`08:57.49`	`*** join/#bzflag Chikorita (Chikorita@AC8903C7.ipt.aol.com)`
`08:58.14`	`Chikorita`	`hello`
`08:58.47`	`molney`	`Hi.`
`08:58.55`	`Chikorita`	`HI!!`
`08:59.20`	`Chikorita`	`wow sum1 iz actually in here (besides mee)`
`08:59.36`	`Chikorita`	`how r u molney ? :)`
`09:00.13`	`Chikorita`	`wassup?`
`09:00.16`	`Chikorita`	`heehe`
`09:01.00`	`Chikorita`	`lemme test sumtin..`
`09:01.10`	`Chikorita`	`~fishslap molney`
`09:01.15`		`ACTION slaps molney up side the head with a wet fish.`
`09:01.24`	`Chikorita`	`heh okies it werks`
`09:01.46`	`Chikorita`	`~slap learner`
`09:02.16`	`Chikorita`	`~bishslap fiberchunks`
`09:02.37`	`Chikorita`	`~dict bish`
`09:02.56`	`Chikorita`	`~sci-fi du jour`
`09:02.57`		`It's some kind of ionized anti-photon inversion field in 10-forward, commander kirk`
`09:03.51`	`Chikorita`	`o i skeered molney away :(`
`09:03.59`	`Chikorita`	`~d`
`09:04.45`	`Chikorita`	`~ducati`
`09:05.09`	`Chikorita`	`damm u ibot`
`09:05.17`	`Chikorita`	`>:(`
`09:05.22`	`Chikorita`	`sighs`
`09:05.29`	`scanline`	`hi Chikorita`
`09:05.38`	`Chikorita`	`hi scan!`
`09:05.43`	`scanline`	`http://navi.picogui.org/images/bzflag/`
`09:05.46`	`Chikorita`	`ooH`
`09:05.48`	`Chikorita`	`kewl`
`09:05.54`	`Chikorita`	`oikes i go check it out`
`09:05.58`	`Chikorita`	`thnx`
`09:05.59`	`Chikorita`	`brb`
`09:06.01`	`scanline`	`=)`
`09:08.03`	`*** join/#bzflag iLLf8d (~neener@user-0can1b0.cable.mindspring.com)`
`09:08.07`	`iLLf8d`	`hey all`
`09:08.13`	`scanline`	`hi`
`09:08.19`	`iLLf8d`	`is AUTOKICK: Tank moving too fast a real message?`
`09:08.25`	`iLLf8d`	`or is it something a cheats making me see?`
`09:08.49`	`scanline`	`I don't know if that's the exact text, but the server does automatically kick tanks that go too fast`
`09:08.55`	`iLLf8d`	`I had highspeed`
`09:09.08`	`iLLf8d`	`thats bogus`
`09:09.12`	`iLLf8d`	`I got the stock debian client`
`09:09.15`	`scanline`	`it tries to account for that, but sometimes it gets messed up by lag`
`09:09.17`	`iLLf8d`	`that needs to be addressed`
`09:09.38`	`iLLf8d`	`altho I have thought it a bit fast at times`
`09:09.42`	`iLLf8d`	`even w/out the flag`
`09:09.50`	`iLLf8d`	`wasn't sure why either`
`09:10.08`	`iLLf8d`	`first time its ever happened tho`
`09:13.23`	`Chikorita`	`wow those r sum nice screenshots scanline`
`09:13.43`	`Chikorita`	`i esp. like da 3D shot of xmissions`
`09:13.45`	`scanline`	`that's the little project I started about a week ago. captain_proton and I have been working on it recently`
`09:13.53`	`Chikorita`	`ooH`
`09:14.31`	`Chikorita`	`it would be kewl if u could do 3D maps in 360degree quicktime ;)`
`09:15.02`	`Chikorita`	`LoL dat iz a funny map "purdy" , itz like da dining room table`
`09:15.04`	`scanline`	`hm, that'd be possible if you hooked up a movie recorder type thingy to the output`
`09:16.17`	`Chikorita`	`i tho bout makin a "conference room" kinda map , so mee an mah CTF yeammates could meet an chat bout matches an stuff..`
`09:16.36`	`Chikorita`	`*teammates`
`09:17.05`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (3 files): Except for some OpenGL state bloopers, the GameView that renders both ThreeDView and RadarView works`
`09:17.20`	`Chikorita`	`each of our tanks could sit in their own chairs ;) heehe :P`
`09:17.39`	`scanline`	`ha`
`09:17.50`	`scanline`	`that'd be more useful if someone wrote this teleporting-between-servers dealy`
`09:18.28`	`Chikorita`	`wow teleporting thru servers!`
`09:18.32`	`Chikorita`	`neato!`
`09:18.44`	`Chikorita`	`dat iz a kewl idea`
`09:18.47`	`scanline`	`it's been talked about, but there would be a lot of tricky issues to resolve in implementing it`
`09:18.53`	`Chikorita`	`ya i bet`
`09:19.01`	`Chikorita`	`soundz tricky indeed`
`09:19.12`	`Chikorita`	`buh not impossible ;)`
`09:19.37`	`Chikorita`	`wormholes?!!`
`09:19.38`	`Chikorita`	`LoL`
`09:19.53`	`scanline`	`hmm.. could stick an animated vortex texture on the teleporter :)`
`09:20.16`	`Chikorita`	`give it an effect like in asherons call transpoting..`
`09:20.59`	`Chikorita`	`ya ...it like going thru a vortex like u sed`
`09:21.26`	`Chikorita`	`reallly kewl sfx`
`09:22.48`	`Chikorita`	`i often server hop so i prolly use dat feature alot if it eva came about`
`09:26.43`	`Chikorita`	`it b kewl too if server-teleporters popped up only at certain specific times , or was on sum sorta timer thingie, an took u to a special server place dats only accessible by dat specific teleporter`
`09:27.18`	`Chikorita`	`mmm spray candy`
`09:27.39`	`Chikorita`	`has any1 eva tried spray candy?`
`09:27.44`	`Chikorita`	`it iz so good`
`09:27.53`	`Chikorita`	`if u can find it 4 sale`
`09:28.16`	`Chikorita`	`anywayzzzzz im goin 2 sleep now...`
`09:28.22`	`Chikorita`	`itz like 5am here`
`09:28.41`	`Chikorita`	`gnite all`
`09:29.34`	`scanline`	`g'night`
`09:32.06`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (3 files): Hooray, we can show a radar view and a 3D view at the same time`
`09:46.05`	`*** join/#bzflag daBomb (dalskdjald@215-bem-10.acn.waw.pl)`
`09:47.43`	`*** part/#bzflag daBomb (dalskdjald@215-bem-10.acn.waw.pl)`
`09:56.19`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (3 files): Draw a background rectangle thingy for the HUD area`
`09:59.39`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Drawable.py): Add a normal for Ground`
`10:00.45`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Drawable.py): Fix the sign of the pyramid Y- normal`
`10:22.23`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (3 files): Fix nested viewport regions`
`10:31.26`	`CIA`	`03micahjd * 12pybzflag/ (2 files in 2 dirs): Fix ThreeDView in cases when it is attached after the world is already loaded`
`10:40.29`	`CIA`	`03micahjd * 12pybzflag/doc (TODO): Add window resizing bug to TODO`
`10:49.44`	`CIA`	`03micahjd * 12pybzflag/ (7 files in 2 dirs): Move frame rate indicator from individual views into worldviewer.py`
`11:02.53`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (2 files): Added support for lazy evaluation of region sizes. Combined with the mighty lambda operator, this makes dynamically sized HUD regions really easy.`
`11:24.56`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (3 files): Fix radar and HUD color problems`
`11:25.55`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (RadarView.py): Full scale on the radar should be a little larger than the world so we can see the walls and objects that extend past them a little.`
`11:32.49`	`CIA`	`03micahjd * 12pybzflag/doc (TODO): Some items to work on tomorrow`
`11:35.21`	`CIA`	`03micahjd * 12pybzflag/doc (TODO): More items to think about before sleep`
`11:38.31`	`CIA`	`03micahjd * 12pybzflag/ (worldgrabber.py): Fix worldgrabber`
`11:48.08`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (Viewport.py): Don't let subviewports set the root viewport's caption`
`11:51.12`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (ThreeDView.py): Don't hardcode pi, it might change`
`11:58.45`	`CIA`	`03micahjd * 12pybzflag/BZFlag/Protocol (3 files): Convert all the protocol to work in degrees as much as possible, rather than radians. This will make worlds look really funky until all the views are updated.`
`12:45.13`	`*** join/#bzflag Mayhem (~Mayhem@dsl-217-155-141-174.zen.co.uk)`
`14:02.44`	`CIA`	`03micahjd * 12pybzflag/ (7 files in 3 dirs): New layout system based on a callable rectangle class that builds functions for lazily evaluating layout operators`
`14:08.51`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (2 files): All arguments to layout operators can now be callables, use this to keep the radar square`
`14:11.56`	`scanline`	`huzzah`
`14:11.57`	`scanline`	`http://navi.picogui.org/images/bzflag/proto-hud.jpeg`
`14:14.20`	`*** join/#bzflag orchid (freckles@chr160dhcp1675.chrchv01.md.comcast.net)`
`14:44.11`	`*** join/#bzflag orchid (freckles@chr160dhcp1675.chrchv01.md.comcast.net)`
`14:55.07`	`Chestal`	`hmm, I wonder what this 's' is supposed to mean`
`14:55.11`	`Chestal`	`I cannot read my own notes`
`15:03.05`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (5 files): Small boatload of HUD, radar, and layout tweaks`
`15:12.07`	`*** join/#bzflag fiberchunks (~frobozzpf@237.14.252.64.snet.net)`
`15:12.44`	`fiberchunks`	`moin`
`15:15.48`	`scanline`	`hi`
`15:15.57`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (2 files): Wire up an Animated.LogApproach to the HUD size just for fun`
`15:16.42`	`fiberchunks`	`what new python goodness have you involved yourself in now scanline? you gonna whip up some bot code later this afternoon? ;)`
`15:17.08`	`scanline`	`dunno.. so far just doing random tweaks and such in the views and animation`
`15:17.19`	`scanline`	`http://navi.picogui.org/images/bzflag/proto-hud.jpeg`
`15:17.54`	`fiberchunks`	`man, that is uber-sweet - all in python?`
`15:18.03`	`scanline`	`there's a nice little system for attaching multiple views to sub-viewports, and it had a little layout system that can dynamically resize thigns`
`15:18.12`	`scanline`	`yep`
`15:18.51`	`fiberchunks`	`now lemme ask you something -- is the rapidity at which you're doing this a function of your wizardry, or a function of pythons 'ease of coding'?`
`15:19.02`	`fiberchunks`	`or both? ;)`
`15:19.21`	`scanline`	`fiberchunks: both probably :)`
`15:19.59`	`fiberchunks`	`here's another question: what are some things that python _cannot_ or _should not_ do (do to it's interpreted nature`
`15:20.05`	`fiberchunks`	`s/do/due`
`15:20.27`	`scanline`	`anything that has to manipulate data in bulk`
`15:20.50`	`fiberchunks`	`what, like network code, or image manipulation?`
`15:21.02`	`fiberchunks`	`you mean size of data, or amount of data?`
`15:21.09`	`scanline`	`python has some nice libraries that let you have all the fun of bulk data manipulation without the CPU cost, like Numeric.. but if you have to process data in bulk you need to write C or something`
`15:21.32`	`fiberchunks`	`so a python database would be a bad idea?`
`15:21.50`	`scanline`	`er`
`15:22.11`	`scanline`	`a python database would be fine as long as you had a C module doing all the hard work`
`15:22.17`	`fiberchunks`	`remember that /me is a code twit -- and is fuzzy on the definition of 'bulk data' in this sense`
`15:22.18`	`fiberchunks`	`ah, ic`
`15:22.34`	`scanline`	`to get the most out of python, you want to use it as a high level language to easily control the brute force of some lower level code`
`15:22.55`	`scanline`	`the Numeric module does this beautifully by giving you easy python primitives for doing numeric computations on large arrays of data`
`15:23.05`	`scanline`	`python code has to set up the calculation, but it's actually performed by C code`
`15:23.26`	`scanline`	`that's similar to how in pybzflag, python code is setting up the rendering but it's actually being performed almost entirely in the OpenGL implementation`
`15:24.09`	`fiberchunks`	`now what about pyopengl module? could that handle the openGL stuff (I dunno if that module is written in low-level language)`
`15:24.26`	`scanline`	`this is with pyopengl`
`15:24.34`	`scanline`	`pyopengl is just a wrapper for opengl so you can use it from python`
`15:24.43`	`fiberchunks`	`oh, ic`
`15:28.09`	`fiberchunks`	`I spent a good chunk of time reading yesterday -- but I am wondering what kind of apps python (by itself) cannot handle -- hence the questions :)`
`15:28.46`	`scanline`	`by itself python is nearly useless.. but it comes with a lot of good modules, and a lot of good ones are available`
`15:29.33`	`scanline`	`there's speed of course, but mainly it just depends on what you're trying to accomplish`
`15:29.43`	`fiberchunks`	`did you use the same general ideas in jetstream?`
`15:30.27`	`scanline`	`python is good for systems where you want a lot of flexibility, and it's alright to prove robustness through unit testing rather than through strict types and scope`
`15:30.43`	`scanline`	`fiberchunks: eh, not really. jetstream was a whole different bucket of fish`
`15:31.48`	`scanline`	`we ended up doing almost all of jetstream in C++ because we wanted the absolute most speed possible, then just doing a very high level control interface in python`
`15:31.58`	`scanline`	`eventually we'd have all the game logic in python, but it never turned into a game`
`15:32.08`	`fiberchunks`	`ah`
`15:32.27`	`scanline`	`jetstream's rendering was a lot more complex than bzflag will (probably) ever be`
`15:32.53`	`scanline`	`it defined worlds using parametric surfaces, which would be dynamically converted to triangles to achieve a particular level of detail`
`15:33.22`	`fiberchunks`	`hence the smooth ground textures and what not?`
`15:33.39`	`fiberchunks`	`or rather, smooth ground surfaces, not textures`
`15:34.24`	`scanline`	`yes, basically. The idea was you could define an entire planet or universe using pseudoranodm-number-generator-based functions, so that only the part of the universe you needed to view would get calculated`
`15:34.40`	`scanline`	`but using the same model functions, you could get as much or as little detail as you wanted`
`15:35.05`	`*** join/#bzflag MrCooper (~daenzer@dclient80-218-118-173.hispeed.ch)`
`15:35.15`	`scanline`	`so you could fly around on one planet and enjoy the leaves and blades of grass, then achieve escape velocity and marvel at similar but distinct grass on a planet at the other side of the solar system`
`15:35.22`	`fiberchunks`	`what was that UI that you coded up -- picoGUI?`
`15:35.38`	`scanline`	`yes.. picoGUI has sort of been my big project of the past 3 years`
`15:35.50`	`scanline`	`we used it in jetstream`
`15:36.49`	`fiberchunks`	`yah, that's where I remembered it from`
`15:41.38`	`CIA`	`03micahjd * 12pybzflag/BZFlag (Animated.py): Add an epsilon value for snapping LogApproach to its target when it gets 'close enough'`
`16:04.17`	`*** join/#bzflag larsl_56k (~larsl@md46909d1.utfors.se)`
`16:04.30`	`larsl_56k`	`Agg.`
`16:04.42`	`larsl_56k`	`Did anyone else have DNS problems with the freenode hosts?`
`16:05.02`	`fiberchunks`	`nope`
`16:05.03`	`scanline`	`I didn't, but there was a global notice to that effect`
`16:05.24`	`scanline`	`-Md- [Global Notice] Due to still a still unclear DNS registration problem, .freenode.net domains are currently not resolving. Please use .freenode.org until this will be fixed, thank you.`
`16:05.33`	`larsl_56k`	`It was extremely odd. I couldn't even get irc.debian.org.`
`16:05.52`	`larsl_56k`	`I had to SSH to SourceForge to get an IP.`
`16:17.21`	`*** join/#bzflag bzgirl (~brat@toronto-hs-64-26-176-100.s-ip.magma.ca)`
`16:27.34`	`CIA`	`03micahjd * 12pybzflag/BZFlag (2 files in 2 dirs): Add a SigmoidApproach evaluator to Animated`
`16:29.08`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (GameView.py): Add a SigmoidApproach evaluator to Animated`
`16:31.30`	`CIA`	`03micahjd * 12pybzflag/BZFlag (2 files in 2 dirs): Fix keyboard toggle for HUD`
`16:40.52`	`CIA`	`03micahjd * 12pybzflag/ (5 files in 3 dirs): Starting a font engine`
`16:51.22`	`fiberchunks`	`oooo, fonts spiffy :)`
`16:52.51`	`scanline`	`heh, yeah.. MAC has been wanting this for a while, though he probably had C++ in mind`
`16:53.29`	`fiberchunks`	`in your opinion, how much of bz could be practically redone in python?`
`16:53.49`	`scanline`	`depending on what you mean by practically, all of it`
`16:53.49`	`fiberchunks`	`not that we'd want to, but I'm curious how much of a game like this python could handle`
`16:54.02`	`fiberchunks`	`well, without major hits in speed, fps, etc`
`16:54.09`	`fiberchunks`	`so it's still just as playable`
`16:54.12`	`fiberchunks`	`as it is now`
`16:54.22`	`*** join/#bzflag Patlabor221 (~jeffm@adsl-64-172-198-77.dsl.lsan03.pacbell.net)`
`16:54.22`	`*** mode/#bzflag [+o Patlabor221] by ChanServ`
`16:54.49`	`scanline`	`I don't know, I've never done this before. So far it looks like it would be possible to do the whole thing in python and it would still be playable, as long as you don't use maps that are too complex`
`16:54.54`	`fiberchunks`	`Patlabor221> my gf and I were rolling around on the floor last night watching the first 7 epis of bloodgulch - mand that is some funny stuff :)`
`16:55.05`	`Patlabor221`	`that it is`
`16:55.11`	`fiberchunks`	`scanline> really? wow, that's interesting`
`16:55.14`	`Patlabor221`	`I put up ep 12 yesterday`
`16:55.33`	`fiberchunks`	`scanline> the map thing being related to processing big data like you explained earlier, correct?`
`16:56.03`	`scanline`	`yes`
`16:56.34`	`scanline`	`I'm also not sure what sort of optimizations would help this, as I haven't done any real profiling yet`
`16:56.40`	`fiberchunks`	`but python (or pygame) is plenty robust / fast enough to handle the network code and such?`
`16:56.52`	`scanline`	`oh yeah, robustness is no problem`
`16:56.58`	`scanline`	`the networking works fine`
`16:57.00`	`fiberchunks`	`neat`
`16:57.05`	`Patlabor221`	`pygame is just sdl bindings`
`16:57.18`	`fiberchunks`	`that's true`
`16:58.17`	`scanline`	`fiberchunks: just try to think of python as just another programming language.. like any language, you can do pretty much anything in it, but there are some things it does better than others`
`16:58.50`	`Patlabor221`	`it's a newer language so it's got some slickness in some parts`
`16:59.07`	`fiberchunks`	`well, I guess I'm from the school of thought (if incorrect, slap me around) where an interpreted language is not as robust/fast as a compiled language (and being a code twit doesn't help)`
`16:59.26`	`scanline`	`fiberchunks: well I have no clue what you mean by robust`
`16:59.35`	`Patlabor221`	`yeah a lang is a lang`
`16:59.57`	`Patlabor221`	`python may make some more fuction hits for some stuff cus of it's interpretedness`
`16:59.58`	`scanline`	`of course an interpreted language can't be as fast as a compiled language, but what most people seem to glaze over is that speed doesn't really matter in most computing problems`
`17:00.04`	`Patlabor221`	`but maybe less for some others`
`17:00.15`	`scanline`	`and the ones where speed does matter, the CPU-intensive parts are being done by code that's already been written and optimized`
`17:00.41`	`Patlabor221`	`scanline your puting all the objects in display lists right?`
`17:00.52`	`fiberchunks`	`scanline> that's what I'm learning now (concerning speed and computing), is that, upon more thought, there really isn't that much that 'requires' great deals of speediness`
`17:01.26`	`scanline`	`Patlabor221: yea, it does one display list per world object per texture right now. I tried combining all the world objects into one big display list.. it worked nicely when rendering the whole world from far away, but close up it seemed to mess up culling and it ran really slow`
`17:01.44`	`Patlabor221`	`yeah it would mess up culling`
`17:01.49`	`Patlabor221`	`how are you culling?`
`17:01.49`	`scanline`	`fiberchunks: right. Optimization is nice, but it's a step that comes after design, implementation, and testing`
`17:02.02`	`scanline`	`Patlabor221: it just lets OpenGL do the culling`
`17:02.18`	`Patlabor221`	`ahh so none`
`17:02.27`	`scanline`	`until we have octrees or something similar, that's the fastest option`
`17:02.27`	`Patlabor221`	`no wonder its so slow`
`17:02.37`	`scanline`	`doesn't bzflag do the exact same thing?`
`17:02.44`	`Patlabor221`	`not quite`
`17:02.53`	`Patlabor221`	`it does ojbect sphere to frustum cull`
`17:03.04`	`Patlabor221`	`before it sends it to GL`
`17:03.11`	`Patlabor221`	`it's just the same stuff from the maps`
`17:03.12`	`fiberchunks`	`scanline> I suppose when I say robust, that I really mean (perhaps erroneously), the difference between a language like C and a language like C++ (garbage collection, dangling pointers and such)`
`17:03.37`	`fiberchunks`	`but I am probably entirely incorrect in my assumption of what 'robustness' should mean with regard to a language`
`17:03.40`	`Patlabor221`	`gl will do culling on a per tri basis, post transform, it's realy slow`
`17:04.06`	`scanline`	`fiberchunks: your concept of 'robustness' really doesn't make any sense. You have to evaluate the language's features with regard to a particular application`
`17:04.25`	`fiberchunks`	`ah, good point`
`17:04.31`	`Patlabor221`	`I should implement my frustum cull in there for you guys`
`17:04.34`	`scanline`	`Patlabor221: well, what I wanted to do was to do culling on octrees or quadtrees`
`17:04.48`	`Patlabor221`	`that would be a lot better then what BZ does now`
`17:04.59`	`scanline`	`patches welcome`
`17:05.02`	`Patlabor221`	`now it's bottlenecked on the testing of every single object to the frustum`
`17:05.29`	`Patlabor221`	`you gonna do your lighting the same way as BZ?`
`17:05.48`	`scanline`	`I'm not sure how BZ does it.. right now captain_proton has it using two GL lights`
`17:06.12`	`scanline`	`and the lighting is a bit broke.. the lights are being positioned relative to the camera instead of the world right now`
`17:06.13`	`Patlabor221`	`yeah I know, that's not right`
`17:06.18`	`Patlabor221`	`ohh`
`17:06.20`	`Patlabor221`	`headlight mode`
`17:06.26`	`scanline`	`well, it's not supposed to do that`
`17:06.27`	`scanline`	`it's a bug`
`17:06.30`	`Patlabor221`	`BZ does some wierd stuff`
`17:06.41`	`Patlabor221`	`like for the shot glows and stuff`
`17:07.05`	`scanline`	`yeah, I remember seeing that.. it subdivides the nearby geometry, right?`
`17:07.16`	`Patlabor221`	`yeah`
`17:07.19`	`Patlabor221`	`then puts a GL light there`
`17:07.24`	`scanline`	`oh yeah.. captain_proton and I were also trying to figure out how to keep everything from Z-buffer fighting`
`17:07.28`	`Patlabor221`	`so realy you only get 8 shot glows max`
`17:07.44`	`Patlabor221`	`you have to set your depth range just right :)`
`17:07.49`	`scanline`	`hah`
`17:07.58`	`scanline`	`that's silly`
`17:08.29`	`scanline`	`though that won't help overlapping teleporters`
`17:08.57`	`Patlabor221`	`it's not a texture thing, it's a zbuffer resoulution thing`
`17:09.04`	`scanline`	`I know`
`17:09.05`	`Patlabor221`	`the Zbuffer is not liniar to distance`
`17:09.15`	`scanline`	`but if you have the same texture on both boxes, you don't notice any z-buffer artifacts`
`17:09.21`	`Patlabor221`	`yeah`
`17:10.17`	`Patlabor221`	`but then your not exactly the same as BZ`
`17:10.37`	`scanline`	`besides coplanar boxes, the only z-buffer problem we have is overlapping teleporters, since that surface is blended`
`17:10.50`	`Patlabor221`	`ohhh, that's easy to fix`
`17:10.51`	`scanline`	`not sure how to go about that other than to detect overlapping teleporters and only render the surface from one`
`17:11.03`	`Patlabor221`	`naw there is a cheap ass way to fix it :)`
`17:11.07`	`scanline`	`oh?`
`17:11.12`	`Patlabor221`	`draw them last`
`17:11.19`	`scanline`	`uh.. we already do that`
`17:11.27`	`Patlabor221`	`and have them not write to the z buffer`
`17:11.28`	`scanline`	`need to for the blending to work right at all`
`17:11.45`	`Patlabor221`	`that usualy gets you close engought`
`17:11.52`	`Patlabor221`	`more then that you have to z sort them`
`17:11.57`	`Patlabor221`	`BZ zsorts them`
`17:12.31`	`scanline`	`hm.. I'll have to ask captain_proton if he had a reason in mind for using the z-buffer on blended polys instead of z-sorting`
`17:12.45`	`scanline`	`doesn't make much sense`
`17:12.51`	`Patlabor221`	`what file does the drawing?`
`17:13.36`	`scanline`	`BZFlag/UI/ThreeDView.py is the actual rendering code, BZFlag/UI/Drawable.py generates display lists for different objects`
`17:15.28`	`Patlabor221`	`yeah your not even calling glDepthRange`
`17:15.54`	`scanline`	`oh, the opengl initialization isn't in that file`
`17:16.00`	`scanline`	`check Viewport.yp`
`17:16.02`	`scanline`	`er, .py`
`17:16.15`	`scanline`	`it doesn't use glDepthRange IIRC, but it does set the clipping planes via gluPerspective`
`17:16.15`	`Patlabor221`	`well there is some init here`
`17:16.37`	`scanline`	`that initializes the viewport-specific settings, not global OpenGL settings`
`17:16.41`	`Patlabor221`	`that sets the frustum, but not the zbuffer`
`17:17.03`	`Patlabor221`	`glpersectice sets the matrix that's it`
`17:17.08`	`scanline`	`I was under the impression that the zbuffer got automatically scaled to the frustum`
`17:17.14`	`scanline`	`ok`
`17:18.17`	`Patlabor221`	`what is the command line to run the observer again?`
`17:18.37`	`scanline`	`observer.py -s brlcad.org:4242 -u 3D`
`17:18.45`	`scanline`	`or you could try worldviewer...`
`17:18.52`	`scanline`	`worldviewer.py random -u 3D`
`17:18.57`	`scanline`	`or replace random with a .bzw file`
`17:19.33`	`scanline`	`world names actually have a pretty rich format.. you can tell it how many boxes to put in the random world, how big, how high the walls should be`
`17:19.42`	`scanline`	`even has a built-in image to world converter just for the hell of it :)`
`17:22.49`	`Patlabor221`	`hmm it dosn't like glDepthRange`
`17:23.37`	`fiberchunks`	`scanline> is worldviewer what you used to grab that image link you pasted earlier?`
`17:24.02`	`scanline`	`yes.. though you can use the exact same UI with several of the pybzflag apps`
`17:24.04`	`scanline`	`even bzfs`
`17:24.12`	`fiberchunks`	`neat`
`17:24.25`	`scanline`	`the link with the HUD was from the 'game' UI rather than the '3D' UI`
`17:24.44`	`scanline`	`there's even an 'anaglyph' UI that captain_proton wrote :)`
`17:24.44`	`Patlabor221`	`do I have to do anything to tell it to rebuild? cus it don't like every single Edit I make]`
`17:25.09`	`scanline`	`Patlabor221: um, no... what exactly does not liking involve?`
`17:25.27`	`Patlabor221`	`GL.glDepthRange(0.01,2000)`
`17:25.31`	`Patlabor221`	`ohh not that`
`17:26.06`	`*** join/#bzflag Patlabor221 (~jeffm@adsl-64-172-198-77.dsl.lsan03.pacbell.net)`
`17:26.07`	`*** mode/#bzflag [+o Patlabor221] by ChanServ`
`17:26.11`	`Patlabor221`	`opps`
`17:26.31`	`scanline`	`do you really want to be the third person here today that has pissed off captain_proton and/or me by pasting a 30 line traceback?`
`17:26.43`	`Patlabor221`	`I didn't mean to`
`17:26.48`	`Patlabor221`	`I was trying to just do this`
`17:26.53`	`Patlabor221`	`<PROTECTED>`
`17:26.53`	`Patlabor221`	`glDepthMask(0)`
`17:26.53`	`Patlabor221`	`<PROTECTED>`
`17:27.13`	`scanline`	`Patlabor221, you have to indent correctly`
`17:27.25`	`Patlabor221`	`it wants spaces dosn't it?`
`17:27.39`	`scanline`	`I think it works with tabs too, but my coding standard says spaces onyl`
`17:27.41`	`scanline`	`er, only`
`17:27.51`	`Patlabor221`	`I see`
`17:27.57`	`Patlabor221`	`yeah that fixes it`
`17:28.04`	`Patlabor221`	`wow that is kinda lame`
`17:29.03`	`scanline`	`enforcing readable code and eliminating extra block syntax is lame?`
`17:29.20`	`scanline`	`it works really nicely if you have a halfway decent editor`
`17:29.51`	`Patlabor221`	`well the fact that it looks the same in an editor but wont' compile, I understand wy`
`17:30.14`	`Patlabor221`	`and I don't think the block sytax is bad, disk space is cheap these days`
`17:30.28`	`scanline`	`this halfway decent editor I speak of wouldn't have just inserted a tab by itself`
`17:30.39`	`scanline`	`and it's not about disk space, it's about style`
`17:30.42`	`Patlabor221`	`dude, it's just how I have it configured`
`17:30.52`	`Patlabor221`	`I can make it put auto indents as spaces`
`17:31.07`	`Patlabor221`	`yeah it is a bout style and readability, that's why I like the block syntax`
`17:31.15`	`Patlabor221`	`like I like to indent for more then just blocks`
`17:31.31`	`Patlabor221`	`I indent my stuff betwenn glBegin and glEnd just so I can see`
`17:31.59`	`scanline`	`like I said, it's about style`
`17:32.07`	`Patlabor221`	`tabsize 4 or 2?`
`17:32.16`	`Patlabor221`	`well you have a language that forces a style`
`17:32.53`	`*** join/#bzflag fiberchunks (~frobozzpf@237.14.252.64.snet.net)`
`17:33.53`	`fiberchunks`	`brad[]: hrm, I compiled it with USE="gtk2" emerge xchat -- odd`
`17:33.53`	`scanline`	`Patlabor221: if you are going to be in the 'I hate python because it indents funny' camp, that's fine`
`17:34.10`	`Patlabor221`	`naw, I don't realy hate antying :)`
`17:34.13`	`Patlabor221`	`things just hate me`
`17:34.20`	`scanline`	`hmm, yes...`
`17:34.22`	`scanline`	`like opengl? :)`
`17:34.56`	`fiberchunks`	`gonna recompile this thang, bbiab`
`17:35.11`	`Patlabor221`	`no openGL likes me, linux does not`
`17:36.08`	`Patlabor221`	`well you still got some z fighting on boxes that go outside the edges of the woorld`
`17:36.14`	`Patlabor221`	`but the porter stuff seems better now`
`17:36.29`	`Patlabor221`	`I didn't see where you asked for your sdl context`
`17:36.42`	`scanline`	`all that stuff's in Viewport.py`
`17:37.08`	`scanline`	`PygameViewport, which gets subclassed into OpenGLViewport`
`17:39.51`	`*** join/#bzflag fiberchunks (~frobozzpf@237.14.252.64.snet.net)`
`17:46.27`	`Patlabor221`	`hmm it dosn't say what depth buffer size pygame asks for`
`17:46.38`	`Patlabor221`	`and SDL makes it kinda funky to even ask`
`17:46.59`	`scanline`	`this depth buffer solution of yours seems really disgusting`
`17:47.10`	`Patlabor221`	`?`
`17:47.13`	`scanline`	`why not just texture map relative to the world?`
`17:47.15`	`Patlabor221`	`your suposed to set it`
`17:47.28`	`Patlabor221`	`what do you do when textures mismatch?`
`17:47.39`	`Patlabor221`	`like a box and the outside wall`
`17:47.49`	`scanline`	`when textures mismatch you get Z-buffer artifacts. There's no good solution for that`
`17:48.22`	`scanline`	`I'm mostly just interested in fixing intersecting boxes and teleporters`
`17:48.24`	`Patlabor221`	`it depends why you are geting Z buffer artifacts, if it's cus the range is wrong, or the res on the buffer is wrong then sure there is nothing you can do`
`17:49.06`	`scanline`	`the point I'm trying to make is that messing with the depth buffer isn't the right way to try to fix z-buffer artifacts in coplanar polygons`
`17:49.07`	`Patlabor221`	`turning off depth writes for transperant thigns does seem cheap but it looks good enough usualy, it's common in particle systems`
`17:49.43`	`Patlabor221`	`and the other stuff is just seting up the buffer so it's optimal to your scene`
`17:50.16`	`scanline`	`I don't see how using glDepthRange makes anything optimal, since you'd only be using it to restrict the range of the z-buffer you use`
`17:50.17`	`Patlabor221`	`cus in your teleporter case, the porter field, dosn't even have a texture`
`17:50.28`	`Patlabor221`	`it dosnt' restrict it`
`17:50.42`	`Patlabor221`	`it sets it so you get 32 bits of percision between near and far`
`17:50.49`	`scanline`	`the default is to use the entire buffer, and you can't use more than the entire buffer... so you're restricting it`
`17:51.08`	`Patlabor221`	`this just sets what the ends of the entire buffer is`
`17:51.09`	`Patlabor221`	`that's all`
`17:51.13`	`scanline`	`the size of the z-buffer is set elsewhere, in platform dependent SDL code that we don't care about`
`17:51.30`	`Patlabor221`	`well you don't, I do`
`17:51.43`	`Patlabor221`	`I've seen it pick a 16 bit when a 32 is avalable`
`17:51.50`	`Patlabor221`	`SDL lest you say you would like a 32 bit one`
`17:52.13`	`scanline`	`why does z-buffer resolution matter for such a simple scene?`
`17:52.26`	`Patlabor221`	`like I say it's non liniar`
`17:52.34`	`scanline`	`I know it's nonlinear`
`17:52.51`	`Patlabor221`	`the complexity donsn't mater much mostly just it's depth range`
`17:53.01`	`scanline`	`but adding resolution won't fix z-buffer artifacts from coplanar polygons, only from polygons that are close enough the z-buffer can't tell them apart`
`17:53.18`	`Patlabor221`	`if they are truly coplanar yes`
`17:53.40`	`Patlabor221`	`but for the transperant fields of teleporters your texture thing won't do a damn thing`
`17:54.02`	`scanline`	`I wasn't talking about the teleporters, I was talking about boxes`
`17:54.10`	`scanline`	`for teleporters we'll probably have to disable depth writes`
`17:54.20`	`Patlabor221`	`that's what I was talking about :)`
`17:54.22`	`Patlabor221`	`heh`
`17:54.40`	`scanline`	`I never disagreed with you about the teleporters, just about this depth buffer stuff`
`17:55.03`	`Patlabor221`	`I agree if they are truly coplanar then you are kinda screwd`
`17:55.24`	`Patlabor221`	`making the textures all repeat from one origin would take care of it in that one case where they were teh same`
`17:55.31`	`Patlabor221`	`and problably be easy to hook up`
`17:55.46`	`Patlabor221`	`tho then you will look a bit difrent from BZ :)`
`17:56.08`	`scanline`	`it's the most common case of z-buffer fighting I've seen in bzflag..`
`17:56.18`	`scanline`	`well, like I said, the 3D view is captain_proton's thing, so bug him about it`
`17:56.22`	`Patlabor221`	`yeah cus all the textures are the same`
`17:56.43`	`scanline`	`bbl`
`17:58.24`	`CIA`	`03jeffm2501 * 12pybzflag/BZFlag/UI (2 files): Turn off depth writes for transperant teleporter fields`
`17:58.34`	`Patlabor221`	`or I just fix it for him :)`
`17:59.42`	`Patlabor221`	`it's much nicer on the old CPU now`
`17:59.46`	`Patlabor221`	`very cool :)`
`18:03.29`	`*** join/#bzflag sussudio (Suss@81.68.132.217)`
`18:17.28`	`CIA`	`03jeffm2501 * 12pybzflag/BZFlag/UI (ThreeDView.py): Made light relitive to world not cam.`
`18:18.31`	`fiberchunks`	`ha -- that'd do it`
`18:20.50`	`Patlabor221`	`that it would`
`19:12.45`	`*** join/#bzflag JBDiGriz (~JBDiGriz@adsl-63-204-118-6.dsl.sndg02.pacbell.net)`
`19:19.54`	`fiberchunks`	`JBDiGriz> did you get a chance to check my notes?`
`19:19.59`	`fiberchunks`	`for accuracy and such?`
`19:23.58`	`fiberchunks`	`morning`
`19:28.31`	`captain_proton`	`hm, i see pat has been busy fixing all my quick hack graphics`
`19:29.13`	`fiberchunks`	`and threatening this: Patlabor221 should piss them off and make a MFC version of there project :) << :)`
`19:29.44`	`captain_proton`	`uhhuh`
`19:29.52`	`captain_proton`	`i don't think there are MFC bindings for python`
`19:29.58`	`captain_proton`	`but he's free to do it if he wants`
`19:30.04`	`fiberchunks`	`heh`
`19:32.16`	`captain_proton`	`eventually he won't be able to resist the ability to write code that doesn'`
`19:32.19`	`captain_proton`	`t require porting`
`19:33.24`	`fiberchunks`	`:)`
`19:36.39`	`captain_proton`	`scanline: the 'game' view is quite cute =)`
`19:37.52`	`JBDiGriz`	`fiberchunks: I checked them, and changed the times to UTC. Mostly it looked good!`
`19:38.06`	`fiberchunks`	`good, wanted to make sure that the info there was accurate`
`19:38.38`	`JBDiGriz`	`We'll find out more when Chestal and TimRiker look them over. Then we'll have to compare against the log! :)`
`19:38.39`	`fiberchunks`	`and representative of what was decided -- I think I may just chop out that last section of it though -- it's kinda useless`
`19:38.48`	`CIA`	`03davidtrowbridge * 12pybzflag/ (2 files in 2 dirs): random stuff`
`19:41.56`	`JBDiGriz`	`I might add a feedback section to the notes. so far only Chestal has responded and he felt the meeting was useful.`
`19:45.08`	`fiberchunks`	`there, chopped it out, now it's more useful`
`19:45.29`	`fiberchunks`	`I suppose we could make the last section the pertinent parts of the log ?`
`19:45.37`	`captain_proton`	`sheesh, there's a sigmoid approach?`
`19:46.20`	`captain_proton`	`hahahaha thats so neat`
`19:47.12`	`captain_proton`	`any of you have a working pybzflag tree?`
`19:47.29`	`fiberchunks`	`I don't, but would like one`
`19:47.38`	`fiberchunks`	`is sfsnap snapping that module as well?`
`19:47.50`	`captain_proton`	`no`
`19:48.20`	`fiberchunks`	`thx`
`19:52.47`	`captain_proton`	`there ya go`
`19:53.11`	`fiberchunks`	`whoo, new snappage`
`19:54.50`	`fiberchunks`	`jeezus, what kind of pipe is sfsnap hosted on? is that your own machine or school thing?`
`19:55.03`	`captain_proton`	`my old high school`
`19:55.12`	`fiberchunks`	`wow, spiffy`
`19:55.20`	`captain_proton`	`t1 total, but nobody is using it right now`
`19:55.44`	`captain_proton`	`eh - its quite a bit slower during the year`
`19:55.50`	`fiberchunks`	`oops, subversion I meant ;)`
`19:55.54`	`captain_proton`	`and it probably wouldn't go over too well if i used up a lot of their bandwidth`
`19:55.58`	`*** join/#bzflag david_v (~david_v@c213-200-135-241.cm-upc.chello.se)`
`19:58.33`	`fiberchunks`	`ah shoot, no ebuild for pil`
`19:59.25`	`captain_proton`	`yes there is`
`19:59.34`	`captain_proton`	`emerge Imaging`
`19:59.44`	`fiberchunks`	`ah, how intuitive :\`
`20:00.23`	`david_v`	`ah Gentoo people around :)`
`20:00.46`	`david_v`	`only i don't like the name of that software, reminds of the Windows program... hehe`
`20:00.48`	`fiberchunks`	`captain_proton> whats the diff between Imaging and Imaging-py21? i.e. which one is newer?`
`20:00.55`	`captain_proton`	`Imaging is newer`
`20:01.00`	`captain_proton`	`-py21 is for python 2.1`
`20:01.01`	`fiberchunks`	`k, thx`
`20:01.25`	`fiberchunks`	`phoot, emerge erro`
`20:01.26`	`fiberchunks`	`r`
`20:07.40`	`fiberchunks`	`captain_proton> can you give me a sample command line for worldviewer.py?`
`20:08.40`	`captain_proton`	`./worldviewer <filename> -u3D`
`20:08.49`	`captain_proton`	`or -ugame, -uanaglyph, -uradar, etc`
`20:09.33`	`fiberchunks`	`ah .bzw files? or does it matter?`
`20:09.40`	`captain_proton`	`bzw works`
`20:09.51`	`captain_proton`	`worlds from your cache work if you give it binary:file`
`20:10.02`	`captain_proton`	`do ./worldviewer.py help`
`20:10.11`	`captain_proton`	`it'll tell you all about the world stuff`
`20:10.36`	`captain_proton`	`or you're feeling funny`
`20:10.44`	`captain_proton`	`./worldviewer http://jupiter.babylonia.flatirons.org/decks -u3D`
`20:10.45`	`captain_proton`	`=)`
`20:16.35`	`fiberchunks`	`hrm, I get a traceback -- does ./worldviewer depend on PIL?`
`20:16.54`	`captain_proton`	`shouldn't`
`20:17.01`	`captain_proton`	`what are the last 3 items & the error in the traceback?`
`20:17.14`	`captain_proton`	`well - it may or may not depend on it, depend on the view`
`20:17.22`	`fiberchunks`	`ImportError: No module named Image <<< looks like it does`
`20:17.27`	`captain_proton`	`ah, yep`
`20:17.38`	`fiberchunks`	`which view does not require PIL?`
`20:17.44`	`captain_proton`	`radar might now`
`20:17.45`	`captain_proton`	`not*`
`20:17.50`	`fiberchunks`	`until I get that emerge Imaging problem resolved`
`20:18.27`	`fiberchunks`	`what does FHz stand for in this context?`
`20:18.36`	`captain_proton`	`frame hertz!`
`20:18.43`	`fiberchunks`	`ah :)`
`20:21.10`	`david_v`	`hehe`
`20:21.26`	`david_v`	`rotating frames? cool ;)`
`20:21.39`	`captain_proton`	`who said anything about rotating?`
`20:22.06`	`CIA`	`03davidtrowbridge * 12pybzflag/ (4 files in 3 dirs): whitespace cleanup`
`20:22.08`	`david_v`	`not rotating exactly, but swinging. Hz implies swinging per second`
`20:22.27`	`david_v`	`oh, no`
`20:22.33`	`david_v`	`actually not :)`
`20:22.42`	`captain_proton`	`hz implies cycles per second`
`20:22.53`	`captain_proton`	`we just decided that FPS was too common`
`20:23.01`	`david_v`	`hehe. sounds geeky :)`
`20:28.22`	`captain_proton`	`sheesh`
`20:28.31`	`captain_proton`	`patlabor221 made it really inefficient`
`20:30.05`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (2 files): don't ctor lights in the draw function`
`20:30.29`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (AnaglyphView.py): no reason to import glu here`
`20:34.00`	`*** join/#bzflag Carnage (strayer@dyn216-8-172-111.ADSL.mnsi.net)`
`20:37.00`	`learner`	`anyone see a problem here: for (std::set<filter_t, expressionCompare>::iterator i=prefixes.begin(); i != prefixes.end(); ++i) {`
`20:37.00`	`learner`	`<PROTECTED>`
`20:37.07`	`learner`	`}`
`20:37.27`	`learner`	`I'm getting a const warning`
`20:37.30`	`learner`	`<PROTECTED>`
`20:38.29`	`learner`	`Here's the warning I get:`
`20:38.29`	`captain_proton`	`whats the warning?`
`20:38.32`	`learner`	warning: passing `const std::string' as `this' argument of
`20:38.32`	`learner`	`<PROTECTED>`
`20:38.32`	`learner`	`<PROTECTED>`
`20:38.32`	`learner`	`<PROTECTED>`
`20:38.33`	`learner`	`<PROTECTED>`
`20:39.00`	`learner`	`i->word should be non-const, yet it's complaining like it is`
`20:39.20`	`captain_proton`	`is i->expression const?`
`20:39.48`	`learner`	`I mean't expression`
`20:39.52`	`learner`	`no, it's not..`
`20:40.35`	`learner`	`it's acting like the iterator is const`
`20:42.04`	`fiberchunks`	`-uoverhead seems to be busted: AttributeError: PygameViewport instance has no attribute 'evalViewport'`
`20:44.41`	`david_v`	`guys, do you have any hints for playing DVDs that have a crack going right through the disc? :) (hired movie) let me guess : don't`
`20:44.54`	`david_v`	`it is broken somehow, not just a crack`
`20:45.44`	`fiberchunks`	`david_v> I have actually heard of people boiling cds / dvds to remove imperfections in the disc -- I have no idea how to do it though`
`20:46.09`	`david_v`	`fiberchunks: well, this one is almost in two parts, if you see what i mean`
`20:46.19`	`fiberchunks`	`hah -- then don't play it :)`
`20:46.30`	`david_v`	`maybe if i put some tape on it ;)`
`20:46.36`	`fiberchunks`	`lol`
`20:46.47`	`fiberchunks`	`and keep whoever it was that broke it away from your dvds :)`
`20:46.54`	`david_v`	`but even if i'd get it to play the movie would stop playing about every minute heh`
`20:47.06`	`david_v`	`hehe :) it's hired`
`20:47.28`	`captain_proton`	`fiberchunks: overhead view requires PIL, iirc`
`20:47.43`	`fiberchunks`	`captain_proton> PIL in here now -- all the views work cept for overhead now`
`20:48.09`	`captain_proton`	`hm, i get the same`
`20:48.12`	`captain_proton`	`scanline musta busted it`
`20:48.15`	`fiberchunks`	`:)`
`20:48.15`	`david_v`	`other one looks ok. curious, though, the cracked one hit the ground first, could it possibly have been used enough to break like that all of a sudden? hm :\|`
`20:48.18`	`captain_proton`	`like the anaglyph view? =)`
`20:48.37`	`fiberchunks`	`it's all dark to me -- is that how it's supposed to be?`
`20:48.51`	`captain_proton`	`get the latest snap`
`20:48.53`	`captain_proton`	`i fixed that`
`20:48.57`	`fiberchunks`	`ah`
`20:49.01`	`fiberchunks`	`one second then`
`20:49.02`	`captain_proton`	`patlabor had messed up the lighting`
`20:49.51`	`fiberchunks`	`what the hell is a psyco?`
`20:50.00`	`fiberchunks`	`ImportError: No module named psyco`
`20:50.05`	`captain_proton`	`ohh`
`20:50.06`	`captain_proton`	`whoops`
`20:50.27`	`captain_proton`	`psyco is a JIT`
`20:50.31`	`captain_proton`	`speeds things up a bit`
`20:50.31`	`CIA`	`03davidtrowbridge * 12pybzflag/ (worldviewer.py): don't includ psyco`
`20:50.41`	`fiberchunks`	`generating new snappage?`
`20:50.57`	`captain_proton`	`should be automatic once the mailing list pops through`
`20:51.04`	`fiberchunks`	`ah, then I'll wait a bit`
`20:51.25`	`CIA`	`03brlcad * 12bzflag/ (2 files in 2 dirs): things are back in a functional state, new methods and optimized bin-hashing completed`
`20:52.11`	`captain_proton`	`should be snapped now`
`20:52.16`	`fiberchunks`	`is that a python module capt? or some external lib?`
`20:52.27`	`captain_proton`	`its a module`
`20:53.16`	`fiberchunks`	`3d glasses view eh?`
`20:53.17`	`fiberchunks`	`:)`
`20:53.20`	`captain_proton`	`>:)`
`20:53.42`	`fiberchunks`	`neat -- wish I had some of them cheap glasses to look at that`
`20:54.57`	`fiberchunks`	`be nice if you could click a different mouse button than the middle to rotate the thing, seeing as how scroll-wheel dudes have to click and roll and move to do thangs`
`20:55.16`	`captain_proton`	`scroll wheel is also a button`
`20:56.38`	`captain_proton`	`>:)`
`20:56.58`	`fiberchunks`	`yeah, I know that -- that's what I mean, I have to click the scroll to rotate / move the mouse to rotate, but also roll the scroll to zoom -- it's a lot for one finger to do :)`
`20:57.29`	`captain_proton`	`heh`
`20:57.46`	`fiberchunks`	`you guys don't trap ESC to kill the app?`
`20:57.52`	`fiberchunks`	`or some other key?`
`20:59.45`	`captain_proton`	`q`
`21:01.33`	`fiberchunks`	`ah, thx`
`21:01.34`	`fiberchunks`	`:)`
`21:05.51`	`*** part/#bzflag david_v (~david_v@c213-200-135-241.cm-upc.chello.se)`
`21:07.06`	`fiberchunks`	`wow, this stuff is incredibly cool, and useful (esp the worldgrabber module`
`21:07.57`	`fiberchunks`	`ah, cept you can't grab worlds from old servers`
`21:08.14`	`captain_proton`	`nope, it uses the 1.9 protocol`
`21:08.32`	`fiberchunks`	`yuppers, ah well`
`21:15.29`	`CIA`	`03davidtrowbridge * 12pybzflag/doc (README): mention & link to pyopengl`
`21:24.09`	`*** join/#bzflag bzgirl (~brat@toronto-hs-64-26-176-100.s-ip.magma.ca)`
`21:36.21`	`Chestal`	`hi bzg`
`21:39.13`	`*** join/#bzflag Tupone (~Tupone@ppp-62-11-19-250.dialup.tiscali.it)`
`21:40.42`	`bzgirl`	`hi Chestal`
`21:51.05`	`*** part/#bzflag Tupone (~Tupone@ppp-62-11-19-250.dialup.tiscali.it)`
`21:53.07`	`*** join/#bzflag Tupone (~Tupone@ppp-62-11-19-250.dialup.tiscali.it)`
`21:56.08`	`*** join/#bzflag Tupone (~Tupone@ppp-62-11-19-250.dialup.tiscali.it)`
`21:56.16`	`*** join/#bzflag Tupone_ (~Tupone@ppp-62-11-19-250.dialup.tiscali.it)`
`21:56.23`	`*** part/#bzflag Tupone_ (~Tupone@ppp-62-11-19-250.dialup.tiscali.it)`
`22:00.15`	`*** join/#bzflag SGI (~SGI@pcp01642968pcs.sothfd01.mi.comcast.net)`
`22:09.03`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (AnaglyphView.py): do some Real Math[tm] for determining camera angles`
`22:12.12`	`*** part/#bzflag Tupone (~Tupone@ppp-62-11-19-250.dialup.tiscali.it)`
`22:12.20`	`CIA`	`03davidtrowbridge * 12pybzflag/BZFlag/UI (3 files): random fixes, beginning of texture cache`
`22:45.37`	`*** join/#bzflag Patlabor221 (~jeffm@adsl-64-172-198-77.dsl.lsan03.pacbell.net)`
`22:45.37`	`*** mode/#bzflag [+o Patlabor221] by ChanServ`
`22:48.38`	`captain_proton`	`sussudio: here's a tip`
`22:48.44`	`captain_proton`	`calling the developers cheaters is not very nice`
`22:48.53`	`captain_proton`	`especially when they're not cheating`
`22:48.54`	`sussudio`	`what?`
`22:49.03`	`captain_proton`	`you were 'when bunnies attack', no?`
`22:49.09`	`sussudio`	`i'm watching tv`
`22:49.57`	`captain_proton`	`Patlabor221: checked out the omg hot hot anaglyph mode? =)`
`22:50.20`	`sussudio`	`when bunnies attack`
`22:50.20`	`sussudio`	`Last seen on Jul 13 2003 10:47PM (GMT) at bzflag.intermip.net:5155.`
`22:50.26`	`sussudio`	`hrmpf`
`22:50.27`	`Patlabor221`	`I just got home`
`22:50.40`	`Patlabor221`	`and I don't have classes`
`22:50.58`	`Patlabor221`	`I fixed your light problem for you tho`
`22:51.03`	`captain_proton`	`sorta`
`22:51.13`	`captain_proton`	`you were constructing the lights in the draw function (inefficient)`
`22:51.15`	`Patlabor221`	`well I made it not move with the cam`
`22:51.20`	`Patlabor221`	`ahhh`
`22:51.22`	`Patlabor221`	`I thought so`
`22:51.29`	`Patlabor221`	`don't know much python`
`22:52.09`	`Patlabor221`	`realy just need to call the pos func after the camera transform`
`22:54.06`	`sussudio`	`~intermip`
`22:54.07`		`rumour has it, intermip is see bzfquery bzflag.intermip.net:5155`
`22:54.12`	`captain_proton`	`thats what i did`
`22:54.29`	`Patlabor221`	`cooleo`
`22:54.47`	`sussudio`	`ibot intermip is see bzfquery bzflag.intermip.net:5155`
`22:54.47`		`sussudio: okay`
`22:54.50`	`sussudio`	`~intermip`
`22:54.50`		`i heard intermip is see bzfquery bzflag.intermip.net:5155`
`22:54.54`	`sussudio`	`????`
`22:54.59`	`sussudio`	`~literal d`
`22:54.59`		`d is <reply> see bzfquery ducati.bzflag.org:5156`
`22:55.07`	`sussudio`	`hm`
`22:55.10`	`sussudio`	`~forget intermip`
`22:55.10`		`sussudio: i forgot intermip`
`22:55.18`	`sussudio`	`ibot intermip is <reply> see bzfquery bzflag.intermip.net:5155`
`22:55.19`		`okay, sussudio`
`22:55.21`	`sussudio`	`~intermip`
`22:56.12`	`*** join/#bzflag JBDiGriz (~JBDiGriz@adsl-63-204-118-6.dsl.sndg02.pacbell.net)`
`23:00.05`	`*** join/#bzflag bryjen (1000@ky-owensboro1a-242.owboky.adelphia.net)`
`23:00.06`	`captain_proton`	`mornin' scanline`
`23:00.18`	`captain_proton`	`i fixed the eye separation`
`23:00.22`	`captain_proton`	`so fewer headaches`
`23:00.23`	`scanline`	`ooh`
`23:00.47`	`scanline`	`ah, I see`
`23:00.52`	`scanline`	`looks much less headachey now`
`23:00.59`	`Patlabor221`	`I should hook up my shutter glasses and see how it looks`
`23:01.34`	`captain_proton`	`scanline: i wrote a very simple texture cache class, but i'm not quite sure how to hook it up`
`23:01.41`	`scanline`	`hmm, so no more z-buffer fighting on the teleporter in decks`
`23:02.23`	`captain_proton`	`its in Texture.py`
`23:02.24`	`scanline`	`so, what'd I break while I was asleep?`
`23:02.34`	`captain_proton`	`overhead view`
`23:02.52`	`scanline`	`whoops`
`23:04.39`	`scanline`	`brb`
`23:05.23`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (4 files): Unborkify the overhead view`
`23:09.14`	`scanline`	`ah, hehe.. so it was reloading the texture for each object?`
`23:09.39`	`captain_proton`	`yeup`
`23:09.51`	`scanline`	`wow... so this should make it a good bit faster`
`23:10.55`	`Patlabor221`	`this AM when I ran it, it was much easyer on the old CPU usage`
`23:11.45`	`captain_proton`	`not really faster`
`23:11.49`	`captain_proton`	`just a lot less memory intensive`
`23:11.54`	`captain_proton`	`faster at loading the world`
`23:12.00`	`scanline`	`what about texture binding?`
`23:12.09`	`scanline`	`wow`
`23:12.10`	`scanline`	`frame rate just doubled`
`23:12.18`	`captain_proton`	`ohhhh`
`23:12.19`	`captain_proton`	`right`
`23:12.20`	`captain_proton`	`=)`
`23:12.39`	`captain_proton`	`because it was dicting on the texture object..`
`23:12.52`	`scanline`	`indeed.. so lots of very tiny rendering passes`
`23:13.07`	`scanline`	`yaknow, that probably screwed up the nested display list optimization I tried to do earlier`
`23:13.08`	`CIA`	`03micahjd * 12pybzflag/BZFlag/UI (2 files): Hook up the texture cache`
`23:13.40`	`scanline`	`also, the radar is still really slow, since it uses no display lists at all`
`23:13.44`	`captain_proton`	`woooo`
`23:13.48`	`captain_proton`	`anaglyph is pegged at 60fps`
`23:14.06`	`scanline`	`I wrote a little something in the TODO about how to fix that without messing up the enhanced radar, does it look reasonable?`
`23:14.08`	`scanline`	`hehe, cool`
`23:15.26`	`scanline`	`hmm, so you're still doing the eye separation in a way that won't be friendly to 1st person view`
`23:15.32`	`captain_proton`	`sure`
`23:15.36`	`captain_proton`	`display lists are cheap`
`23:15.44`	`captain_proton`	`eh`
`23:15.47`	`captain_proton`	`its 1st person friendly`
`23:15.53`	`captain_proton`	`just gotta move the camera focus`
`23:15.54`	`scanline`	`it would be really easy to do the separation properly of we added something like distance but for horizontal to the camera`
`23:16.13`	`scanline`	`hmm`
`23:16.17`	`scanline`	`guess that's one way`
`23:16.35`	`scanline`	`oh, I see what you're saying`
`23:16.36`	`scanline`	`right`
`23:17.03`	`scanline`	`so.. I still can't use alt-middle to make my view go up and down`
`23:17.13`	`scanline`	`might be my WM grabbing it, though it shouldn't be`
`23:17.42`	`scanline`	`then there's my whole moral opposition to keyboard modifiers being used with mouse buttons :)`
`23:18.57`	`scanline`	`hmm, this really needs a movie recorder =)`
`23:20.18`	`scanline`	`if there's an LZO module for python that might actaully be doable`
`23:22.00`	`scanline`	`ah, looks like you folks fixed the lighting?`
`23:23.32`	`captain_proton`	`indeed`
`23:23.38`	`Patlabor221`	`cap made it not suck`
`23:23.41`	`scanline`	`whee, we broke 9000 lines of code`
`23:23.56`	`captain_proton`	`disgusting =)`
`23:24.05`	`scanline`	`well, 1500 of it is optik =}`
`23:24.23`	`scanline`	`I think in python 2.3 optik is part of the standard lib`
`23:24.31`	`captain_proton`	`probably`
`23:24.38`	`captain_proton`	`hmm, their "magic ring" is damn cool`
`23:24.39`	`scanline`	`it had better be, it's so cool`
`23:24.47`	`scanline`	`captain_proton: magic ring?`
`23:25.28`	`captain_proton`	`http://www.caligari.com/products/trueSpace/ts65/Brochure/wmv/01DirectMani.wmv`
`23:26.29`	`scanline`	`wow, it sure loads a lot faster with the texture cache :)`
`23:30.00`	`scanline`	`cool interface`
`23:30.32`	`scanline`	`=)`
`23:30.40`	`scanline`	`guess you'll need picking next, eh?`
`23:30.56`	`captain_proton`	`thats one thing`
`23:31.04`	`captain_proton`	`i need to be able to push arbitrary drawables into the scene`
`23:31.44`	`scanline`	`should just be a matter of refactoring the code that adds world blocks a bit`
`23:32.46`	`scanline`	`hmm.. would be handy to have a drawable subclass that would wrap any other drawable and provide a transformation`
`23:33.10`	`captain_proton`	`and a group`
`23:33.15`	`scanline`	`ah, yes`
`23:33.18`	`captain_proton`	`transform [ group [ box box box box] ]`
`23:33.34`	`scanline`	`but that would only work for objects in the same texture?`
`23:34.41`	`captain_proton`	`hmm`
`23:35.18`	`captain_proton`	`so, for picking`
`23:35.24`	`captain_proton`	`i think the view should handle all the names`
`23:35.40`	`captain_proton`	`and just hand back the object (no matter how many drawables the object has)`
`23:35.51`	`scanline`	`that works`
`23:37.08`	`captain_proton`	`then the controller (?) can choose what to do with it depending on the type`
`23:37.31`	`scanline`	`hmm.. maybe picking should be a viewport thing?`
`23:37.53`	`scanline`	`you could register a dict mapping GL names to arbitrary objects with it, then the viewport would have an event that gets triggered on picking`
`23:38.09`	`captain_proton`	`eh`
`23:38.24`	`captain_proton`	`seems like it should be triggered by the controller`
`23:38.34`	`scanline`	`ok`
`23:38.37`	`captain_proton`	`since it requires a rendering pass that doesn't actually draw anythinhg`
`23:38.45`	`captain_proton`	`and its more a function of the view than the viewport`
`23:41.14`	`captain_proton`	`actually...`
`23:41.19`	`captain_proton`	`we can just loop through the objects dict`
`23:41.25`	`captain_proton`	`rather than the texture/passes dict`
`23:41.31`	`captain_proton`	`since we don't need to do textures or blending`
`23:50.30`	`captain_proton`	`how do you get the number of objects in a dictionary?`
`23:50.47`	`scanline`	`len(dict) works`
`23:54.12`	`scanline`	`hmm, did sf cvs just die again?`
`23:55.45`	`captain_proton`	`looks like it`

Generated by irclog2html.pl by Jeff Waugh - find it at freshmeat.net! Modified by Tim Riker to work with blootbot logs, split per channel, etc.