You can subscribe to this list here.
2000 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}
(390) 
_{Aug}
(767) 
_{Sep}
(940) 
_{Oct}
(964) 
_{Nov}
(819) 
_{Dec}
(762) 

2001 
_{Jan}
(680) 
_{Feb}
(1075) 
_{Mar}
(954) 
_{Apr}
(595) 
_{May}
(725) 
_{Jun}
(868) 
_{Jul}
(678) 
_{Aug}
(785) 
_{Sep}
(410) 
_{Oct}
(395) 
_{Nov}
(374) 
_{Dec}
(419) 
2002 
_{Jan}
(699) 
_{Feb}
(501) 
_{Mar}
(311) 
_{Apr}
(334) 
_{May}
(501) 
_{Jun}
(507) 
_{Jul}
(441) 
_{Aug}
(395) 
_{Sep}
(540) 
_{Oct}
(416) 
_{Nov}
(369) 
_{Dec}
(373) 
2003 
_{Jan}
(514) 
_{Feb}
(488) 
_{Mar}
(396) 
_{Apr}
(624) 
_{May}
(590) 
_{Jun}
(562) 
_{Jul}
(546) 
_{Aug}
(463) 
_{Sep}
(389) 
_{Oct}
(399) 
_{Nov}
(333) 
_{Dec}
(449) 
2004 
_{Jan}
(317) 
_{Feb}
(395) 
_{Mar}
(136) 
_{Apr}
(338) 
_{May}
(488) 
_{Jun}
(306) 
_{Jul}
(266) 
_{Aug}
(424) 
_{Sep}
(502) 
_{Oct}
(170) 
_{Nov}
(170) 
_{Dec}
(134) 
2005 
_{Jan}
(249) 
_{Feb}
(109) 
_{Mar}
(119) 
_{Apr}
(282) 
_{May}
(82) 
_{Jun}
(113) 
_{Jul}
(56) 
_{Aug}
(160) 
_{Sep}
(89) 
_{Oct}
(98) 
_{Nov}
(237) 
_{Dec}
(297) 
2006 
_{Jan}
(151) 
_{Feb}
(250) 
_{Mar}
(222) 
_{Apr}
(147) 
_{May}
(266) 
_{Jun}
(313) 
_{Jul}
(367) 
_{Aug}
(135) 
_{Sep}
(108) 
_{Oct}
(110) 
_{Nov}
(220) 
_{Dec}
(47) 
2007 
_{Jan}
(133) 
_{Feb}
(144) 
_{Mar}
(247) 
_{Apr}
(191) 
_{May}
(191) 
_{Jun}
(171) 
_{Jul}
(160) 
_{Aug}
(51) 
_{Sep}
(125) 
_{Oct}
(115) 
_{Nov}
(78) 
_{Dec}
(67) 
2008 
_{Jan}
(165) 
_{Feb}
(37) 
_{Mar}
(130) 
_{Apr}
(111) 
_{May}
(91) 
_{Jun}
(142) 
_{Jul}
(54) 
_{Aug}
(104) 
_{Sep}
(89) 
_{Oct}
(87) 
_{Nov}
(44) 
_{Dec}
(54) 
2009 
_{Jan}
(283) 
_{Feb}
(113) 
_{Mar}
(154) 
_{Apr}
(395) 
_{May}
(62) 
_{Jun}
(48) 
_{Jul}
(52) 
_{Aug}
(54) 
_{Sep}
(131) 
_{Oct}
(29) 
_{Nov}
(32) 
_{Dec}
(37) 
2010 
_{Jan}
(34) 
_{Feb}
(36) 
_{Mar}
(40) 
_{Apr}
(23) 
_{May}
(38) 
_{Jun}
(34) 
_{Jul}
(36) 
_{Aug}
(27) 
_{Sep}
(9) 
_{Oct}
(18) 
_{Nov}
(25) 
_{Dec}

2011 
_{Jan}
(1) 
_{Feb}
(14) 
_{Mar}
(1) 
_{Apr}
(5) 
_{May}
(1) 
_{Jun}

_{Jul}

_{Aug}
(37) 
_{Sep}
(6) 
_{Oct}
(2) 
_{Nov}

_{Dec}

2012 
_{Jan}

_{Feb}
(7) 
_{Mar}

_{Apr}
(4) 
_{May}

_{Jun}
(3) 
_{Jul}

_{Aug}

_{Sep}
(1) 
_{Oct}

_{Nov}

_{Dec}
(10) 
2013 
_{Jan}

_{Feb}
(1) 
_{Mar}
(7) 
_{Apr}
(2) 
_{May}

_{Jun}

_{Jul}
(9) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

2014 
_{Jan}
(14) 
_{Feb}

_{Mar}
(2) 
_{Apr}

_{May}
(10) 
_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 







1
(4) 
2
(3) 
3
(3) 
4
(4) 
5
(19) 
6
(22) 
7
(13) 
8
(3) 
9
(4) 
10
(21) 
11
(3) 
12
(14) 
13
(10) 
14
(26) 
15
(17) 
16
(5) 
17
(34) 
18
(7) 
19
(19) 
20
(40) 
21
(34) 
22
(8) 
23
(3) 
24
(19) 
25
(6) 
26
(18) 
27
(32) 
28
(6) 
29

30
(13) 






From: Lars Wilke <lars@ch...>  20010906 20:39:06

David, If you want to ignore the "UP" problem for the moment, it is easy to find the quaternion that aligns two vectors  in this case the camera look vector with the camera position to object vector. Lars Wilke Credo Interactive Inc. http://www.charactermotion.com quaternion align( const vector3& v0, const vector3& v1 ) { /* From Chris Welman * * Purpose: * This routine will calculate the quaternion which, when applied * to the normalized vector v0, will yield the vector v1. * Note that this operation is inherently illdefined since twist * is not considered at all, but this routine is still useful * * * Take the normalized bisector of the two vectors. * The angle of rotation is the dot product of this * with the original vector v0. * The axis of rotation is the cross product of * the bisector and v0 * * Why the bisector, you ask? Remember that the * quaternion that rotates by N degrees is a * function of N/2. Using the bisector avoids * having to do an inverse trig function, dividing * by 2, and calling another trig function! */ v0.normalize(); // Skip if known to be unit length v1.normalize(); // Skip if known to be unit length vector3 bisector = v0 + v1; bisector.normalize(); float w = bisector DOT v0; /* * Watch for the special case where v0 and v1 * are opposite vectors. In this case a * rotation of 180 in any direction will * perform the desired alignment. */ vector3 c; if ( w != 0 ) { c = v0 CROSS bisector; } else { /* * Pick any direction other than v0 or v1. * We can do this by exchanging the elements * of v1. */ vector3 anydir( v1.z, v1.x, v1.y ); c = v0 CROSS anydir; c.normalize(); } quaternion q( w, v.x, v.y, v.z ); return q; }; > Original Message > From: gdalgorithmslistadmin@... > [mailto:gdalgorithmslistadmin@...]On Behalf Of David > 'Mythomania' Zaadstra > Sent: Wednesday, September 05, 2001 12:07 PM > To: GDAlgorithmslist@... > Subject: [Algorithms] lookat with quaternion > > > hi, > > in my engine i use quaternions to represent orientations of objects. now i > want to do a lookat function for the camera. how should i do that? > of course i can just use the standard lookat function, but that only gives > me the matrix. is there a way to do a special quaternion lookat? > or should i just convert from matrix to quaternion? > > thanks in advance, > David > > > 
From: Jay Stelly <J<ay@va...>  20010906 19:40:57

> (The two matrix are almost a transpose  have to negate the > signs on the > nondiagonals.) Not exactly. The difference between the two forms is the sign of w. Which one you use depends on the conventions you've adopted for your coordinate axes and the quaternion coordinates. A lefthanded coordinate system has CrossProduct(yaxis,xaxis) == zaxis. A righthanded coordinate system has CrossProduct(xaxis,yaxis) == zaxis. Jay 
From: Michael Pohoreski <MP<ohoreski@cy...>  20010906 19:13:11

In "Advanced Animation and Rendering Techniques", Watt and Watt, Page 362 they give the quat>matrix rotation xform as: LHCS 2 2 =20 [ 1  2y  2z 2xy  2wz 2xz + 2wy ] [ 2 2 ] [ 2xy + 2wz 1  2x  2z 2yz  2wx ] [ 2 2 ] [ 2xz  2wy 2yz + 2wx 1  2x  2y ] But in "3D Game Engine Design", Page 17, Section 2.3.5, Eqn 2.13, and also in "Rotating Objects Using Quaterions", Game Developer Feb 98, Nick Bobick, Page 37, (using the Corrected matrix), both present this xform: RHCS 2 2 =20 [ 1  2y  2z 2xy + 2wz 2xz  2wy ] [ 2 2 ] [ 2xy  2wz 1  2x  2z 2yz + 2wx ]=20 [ 2 2 ] [ 2xz + 2wy 2yz  2wx 1  2x  2y ] (The two matrix are almost a transpose  have to negate the signs on the nondiagonals.) Are there 2 xforms because the matrix rotations can represent rotations in either a LHCS or a RHCS ? If not, could someone explain the similiarity? To reiterate what Ron mentioned, I snagged this post when I was implementing our quat<>matrix code. (I'm sure Ron will correct if any of it is wrong.) Comment by: Ben Ginsberg (bgins@...) Subject: Re: Need help with Quaternions=20 Newsgroups: alt.games.programming, comp.games.development.programming.misc, comp.graphics.algorithms Date: 20001015 14:07:48 PST=20 Converting from a rotation matrix to a quaternion,=20 involves finding the eigenvector corresponding to the eigenvalue of +1. It is a linear algebra problem. In math terminology, we are looking for a certain type of decomposition of elements of the Orthogonal group. But there is no unique solution to this particular decomposition (of a 3D rotation matrix into three Euler angles), since different triples of Euler angles are possible. So this a problem that is "illdefined", or "not welldefined" i.e. there is no UNIQUE solution. When there are many solutions, one would hope that there is a CANONICAL solution, according to some a priori principle, like picking a known subset of the complete solution space. The inverse trig functions or the complex log function are some good examples. Here, for example, we could require that, say, Qx be calculated first, then Qy, and then Qz; this might be analagous to the GrahmSchmidt method of finding an orthonormal basis. 
From: David 'Mythomania' Zaadstra <mythomania@gm...>  20010906 19:07:25

> > I never give up the matrix. Whether I store a quaternion in addition > depends on the particular application. The matrix is more generally > useful than the quaternion. With the abundance of memory we have > these days, the space saved in storing only the quaternion is not an > important factor. > well, maybe on consoles...depending on the number of objects... but i don't work on a console anyway, so i'll maybe add the rotation matrix to my objects and only convert to quaternion if necessary... thanks for your help 
From: Ron Levine <ron@do...>  20010906 18:22:24

I wrote >The problem of getting the rotation from the matrix is a little more difficult >than getting the matrix from the lookat/up vectors... A slip. Should read "The problem of getting the quaternion from the matrix is a little more difficult....." Could also read "The problem of getting the axis of rotation from the matrix is a little more difficult...." 
From: Ron Levine <ron@do...>  20010906 18:14:49

On Thu, 6 Sep 2001 19:34:56 +0200, you wrote: >yes, crystalclear ;) >i knew already (just about) how a lookat matrix is created. i just wanted to >know if there was a kind of "trick" to do it with quaternions. >so obviously there isnt. The reason that it should be obvious that there isn't is that having the lookat and up vectors is the same as having the matrix so if there were such a trick then it would also serve as a trick for getting the quaternion from the matrix. The problem of getting the rotation from the matrix is a little more difficult than getting the matrix from the lookat/up vectors, because it involves solving an eigenvector problem. >so the only possibilities to get a quaternion are > by taking an axis and a rotation angle and creating one from there This begs the question. You don't need "an" axis and "a" rotation angle, but rather "the" axis and rotation angle for the rotation that is specified by the lookat and up vectors. Having this axis and angle is is TRIVIALLY THE SAME as having the quaternion, just as having the lookat and up vectors is TRIVIALLY THE SAME as having the rotation matrix. That axis that you seek IS the eigenspace of the matrix. > by converting a matrix to a quaternion Exactly, the only way. Except that I object to your language.. You don't convert a matrix to a quaternion, rather you find a quaternion that represents the same rotation as does the matrix (and remember there are always two such quaternions). All algorithms for finding that quaternion are essentially codifications of the solution to the eigenvector problem. >and is it a good idea to store only a quaternion for each object in my >engine? how do you do it? I never give up the matrix. Whether I store a quaternion in addition depends on the particular application. The matrix is more generally useful than the quaternion. With the abundance of memory we have these days, the space saved in storing only the quaternion is not an important factor. > > Original Message  >From: "Ron Levine" <ron@...> >To: <GDAlgorithmslist@...> >Sent: Thursday, September 06, 2001 12:39 AM >Subject: Re: [Algorithms] lookat with quaternion > > >> David 'Mythomania' Zaadstra wrote: >> >> >hi, >> > >> >in my engine i use quaternions to represent orientations of objects. now >i >> >want to do a lookat function for the camera. how should i do that? >> >of course i can just use the standard lookat function, but that only >gives >> >me the matrix. is there a way to do a special quaternion lookat? >> >or should i just convert from matrix to quaternion? >> > >> >> You have just run into one of the great advantages of the matrix >> representation of rotations over the quaternion representation, >> especially relevant to cameras and other moving objects with >> interesting cartesian symmetries. Namely, the lookat vector is >> exactly one of the columns of the rotation matrix (or one of the rows, >> depending on your matrix convention). Another one of the columns (or >> rows) is the up vector, and the third is the right or left vector, >> depending on your handedness convention. >> >> Note that in order to define a rotation, and so to define a unit >> quaternion, you need to supply more than a lookat vector. You have to >> supply at least one other independent vector, typically an up vector. >> So what you are asking is how to determine the unit quaternion from >> given lookat vector and up vector, just as what you call a lookat >> function produces a rotation matrix from a given lookat vector and up >> vector. >> >> Now note that this matrixvalued lookat funtion is pretty simple to >> write. Because once you have a lookat vector and an up vector >> perpendicular to it, you already HAVE two rows of the matrix and the >> third must be their cross product. If the supplied up vector is not >> perpendicular to the supplied lookat vector, then it is one simple >> application of the GramSchmidt algorithm to get a unique up vector >> that is perpendicular, lies in the same plane as the lookat vector and >> the supplied up vector, and points, in that plane, to the same side of >> the supplied lookat vector as the supplied up vector points. Which is >> exactly what the standard lookat functions do. >> >> Now this should make it clear that the problem of finding the unit >> quaternions defined by a supplied lookat vector and supplied up vector >> is essentially the same as finding the quaternions corresponding to a >> given rotation matrix. >> >> Does that answer your question? >> >> _______________________________________________ >> GDAlgorithmslist mailing list >> GDAlgorithmslist@... >> https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist >> > > >_______________________________________________ >GDAlgorithmslist mailing list >GDAlgorithmslist@... >https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist 
From: Pete Warden <pete@le...>  20010906 18:05:42

Andrew Jones wrote: > ...we are looking at a very, very console specific hack to try and get full > scene blurring in there. I can't really say anymore I'm afraid... You could tell us, but then you'd have to kill us? ;) Is it a console NDA problem? If so, any chance of posting it onto the appropriate manufacturers forums? I'm only on Nintendo's ngs now, but I'm sure there'd be some interested people on the Sony groups if it's for the PS2. Thanks to everyone for the responses, I'll let you know how my implementation goes. I've got the feeling I'll go for a very cutdown version of the technique mentioned in the Gamasutra article, with just a single blurred plane rendered at midground, and a very contrived camera setup, since this has to be implemented in our free time as we prepare for beta! One thought on the artefacts you get if you have, for example a ground plane, going through several of the blurred billboards; would rerendering the plane with trilinear filtering between the blur level textures help? It seems to be crying out for some use of trilinear anyway, even if I'm not quite sure what... thanks, Pete 
From: Lionel Fumery <lifml@mi...>  20010906 17:42:26

How to make a replyDon't record only the inputs, but also the time increments between each frames and also the random value (I you use some of them) When playing back, use the recorded times as the time increment, and also use the same random values than those recorded. We use those kind of record to record a realtime play by a tester, and then playing back the game and recording each frame into an AVI stream (direct slow DivX compression). Recording the delta times was crucial. Lionel.  Original Message  From: Iker@... To: gdalgorithmslist@... Sent: Wednesday, September 05, 2001 12:59 PM Subject: [Algorithms] How to make a reply Hi there! We are facing the problem of replying some parts of the action of our game and before implementing our own ideas, we would like to know some of the usual technics for this kind of situations. One question that comes out is how the hell coders can make a reply of a whole car race using the memory limitations that consoles have (our game is a third person simulation/adventure like game). We know this is a problem that has a particular solution acording to each game engine and logic, but like in camera following probs there could be a "generic" implementation (or at least very common). Thanx in advance. 
From: David 'Mythomania' Zaadstra <mythomania@gm...>  20010906 17:34:27

yes, crystalclear ;) i knew already (just about) how a lookat matrix is created. i just wanted to know if there was a kind of "trick" to do it with quaternions. so obviously there isnt. so the only possibilities to get a quaternion are  by taking an axis and a rotation angle and creating one from there  by converting a matrix to a quaternion  (and of course by multiplying any previously created quaternions) am i right there? and is it a good idea to store only a quaternion for each object in my engine? how do you do it?  Original Message  From: "Ron Levine" <ron@...> To: <GDAlgorithmslist@...> Sent: Thursday, September 06, 2001 12:39 AM Subject: Re: [Algorithms] lookat with quaternion > David 'Mythomania' Zaadstra wrote: > > >hi, > > > >in my engine i use quaternions to represent orientations of objects. now i > >want to do a lookat function for the camera. how should i do that? > >of course i can just use the standard lookat function, but that only gives > >me the matrix. is there a way to do a special quaternion lookat? > >or should i just convert from matrix to quaternion? > > > > You have just run into one of the great advantages of the matrix > representation of rotations over the quaternion representation, > especially relevant to cameras and other moving objects with > interesting cartesian symmetries. Namely, the lookat vector is > exactly one of the columns of the rotation matrix (or one of the rows, > depending on your matrix convention). Another one of the columns (or > rows) is the up vector, and the third is the right or left vector, > depending on your handedness convention. > > Note that in order to define a rotation, and so to define a unit > quaternion, you need to supply more than a lookat vector. You have to > supply at least one other independent vector, typically an up vector. > So what you are asking is how to determine the unit quaternion from > given lookat vector and up vector, just as what you call a lookat > function produces a rotation matrix from a given lookat vector and up > vector. > > Now note that this matrixvalued lookat funtion is pretty simple to > write. Because once you have a lookat vector and an up vector > perpendicular to it, you already HAVE two rows of the matrix and the > third must be their cross product. If the supplied up vector is not > perpendicular to the supplied lookat vector, then it is one simple > application of the GramSchmidt algorithm to get a unique up vector > that is perpendicular, lies in the same plane as the lookat vector and > the supplied up vector, and points, in that plane, to the same side of > the supplied lookat vector as the supplied up vector points. Which is > exactly what the standard lookat functions do. > > Now this should make it clear that the problem of finding the unit > quaternions defined by a supplied lookat vector and supplied up vector > is essentially the same as finding the quaternions corresponding to a > given rotation matrix. > > Does that answer your question? > > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist > 
From: Andrew Jones <andrew@em...>  20010906 17:30:54

> The technique described blurs the textures, but won't you still have > hard > edges on the objects? Perhaps overlaying semitransparent geometry over > objects would help blur objects into the background. Or maybe you could > jitter the verts the further they are from the eye. > Dave is a colleague of mine but is out of the office right now. The technique he is talking about does only blur textures if you use it as is, but we are looking at a very, very console specific hack to try and get full scene blurring in there. I can't really say anymore I'm afraid, and you're right that in general this is a texture blurring, rather than fullscene blurring effect. Andrew Jones 
From: Peter Giokaris <petergi@mi...>  20010906 17:13:17

The technique described blurs the textures, but won't you still have hard=20 edges on the objects? Perhaps overlaying semitransparent geometry over=20 objects would help blur objects into the background. Or maybe you could=20 jitter the verts the further they are from the eye. Original Message From: Martin Fuller [mailto:mfuller@...] Sent: Thursday, September 06, 2001 8:57 AM To: 'gdalgorithmslist@...' Subject: RE: [Algorithms] Depth of Field Or precomposite the two texture to some work area in VRAM before you render your polygons. ;) Original Message From: Paul Firth [mailto:pfirth@...] Sent: Thursday, September 06, 2001 4:19 PM To: gdalgorithmslist@... Subject: Re: [Algorithms] Depth of Field Josiah Manson wrote: > That is a really cool idea. If my understanding is right, that is basically > what is done with JPEG compression, right? Toss out some color detail, and > keep the contrast. The only thing is you need to use up a multitexture stage or for PS2 you have to render things twice... Cheers, Paul. _______________________________________________ GDAlgorithmslist mailing list GDAlgorithmslist@... https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist _______________________________________________ GDAlgorithmslist mailing list GDAlgorithmslist@... https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist 
From: Martin Fuller <mfuller@ac...>  20010906 15:57:15

Or precomposite the two texture to some work area in VRAM before you render your polygons. ;) Original Message From: Paul Firth [mailto:pfirth@...] Sent: Thursday, September 06, 2001 4:19 PM To: gdalgorithmslist@... Subject: Re: [Algorithms] Depth of Field Josiah Manson wrote: > That is a really cool idea. If my understanding is right, that is basically > what is done with JPEG compression, right? Toss out some color detail, and > keep the contrast. The only thing is you need to use up a multitexture stage or for PS2 you have to render things twice... Cheers, Paul. _______________________________________________ GDAlgorithmslist mailing list GDAlgorithmslist@... https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist 
From: Conor Stokes <cstokes@tp...>  20010906 15:38:14

Closer to wavelet compression actually :) Conor Stokes > That is a really cool idea. If my understanding is right, that is basically > what is done with JPEG compression, right? Toss out some color detail, and > keep the contrast. > > >1/ Take your original full quality texture (say 64x64) > >2/ Filter it down to at least 1/4 the size (32x32). > >3/ Make a second alpha only detail texture at the original resolution > >(64x64) to be overlayed on the blurry 32x32 texture  you can do this as > >low > >as 4 bits per pixel if the hardware does it. (3/8th compression on a 32 bit > >texture). > > > _________________________________________________________________ > Get your FREE download of MSN Explorer at http://explorer.msn.com/intl.asp > > > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist > 
From: Paul Firth <pfirth@at...>  20010906 15:18:02

Josiah Manson wrote: > That is a really cool idea. If my understanding is right, that is basically > what is done with JPEG compression, right? Toss out some color detail, and > keep the contrast. The only thing is you need to use up a multitexture stage or for PS2 you have to render things twice... Cheers, Paul. 
From: Josiah Manson <josiahmanson@ho...>  20010906 14:49:31

That is a really cool idea. If my understanding is right, that is basically what is done with JPEG compression, right? Toss out some color detail, and keep the contrast. >1/ Take your original full quality texture (say 64x64) >2/ Filter it down to at least 1/4 the size (32x32). >3/ Make a second alpha only detail texture at the original resolution >(64x64) to be overlayed on the blurry 32x32 texture  you can do this as >low >as 4 bits per pixel if the hardware does it. (3/8th compression on a 32 bit >texture). _________________________________________________________________ Get your FREE download of MSN Explorer at http://explorer.msn.com/intl.asp 
From: David Hunt <david@hu...>  20010906 12:37:32

> But doesn't this look more like fading between a low resolution image and > a high one? Yes...! > Also, isn't this almost exactly the same as the mipmapped frame buffer effect? No! Imagine an effect that would allow you put frosted glass in your windows that blurred anything you could see through them;) David 
From: Paul Firth <pfirth@at...>  20010906 12:22:27

David Hunt wrote: > Here's an interesting technique I heard at a Sony conference which was > intended as a simple texture compression but would work very well as a focus > effect. > > In a preprocess stage > 1/ Take your original full quality texture (say 64x64) > 2/ Filter it down to at least 1/4 the size (32x32). > 3/ Make a second alpha only detail texture at the original resolution > (64x64) to be overlayed on the blurry 32x32 texture  you can do this as low > as 4 bits per pixel if the hardware does it. (3/8th compression on a 32 bit > texture). > > If you multipass with the blurry texture then the detail texture overlaid it > is nearly impossible to tell the difference between the compressed and > original images. > > The interesting thing was that as you fade up the global alpha level of the > detail texture the image went very smoothly from being out of focus to > sharply in focus. But doesn't this look more like fading between a low resolution image and a high one? Also, isn't this almost exactly the same as the mipmapped frame buffer effect? Cheers, Paul. 
From: David Hunt <david@hu...>  20010906 11:57:22

> Wouldn't that kind of give the same effect as using excessively blurred > mipmapping, but without having to do a second pass? Except that mipmaps are quite discrete  the jumps in "focus" would be quite obviously quantised, the technique I described produces a very smooth transition from in to out of focus. Also with traditional mipping the transitions aren't governed completely by z distance. >Are there any > screenshots > displaying the technique you described? If you have access to any of the PS2 dev sites look you could look in the 2001 SCEE devcon section  unfortunately I can't remember the name of the presentation and can't read .ppt files which is what they're stored as  though I suspect it might be the one on AA? David P.S. While chatting about this here we've come up with an even better cheaper way of doing it smoothly completely for free on consoles  I won't discuss here yet as it might not work as its a complete hack and I guess its probably a trade secret if it does or something;) > >  Willem > > Original Message > From: David Hunt [mailto:david@...] > Sent: 06 September 2001 11:41 > To: gdalgorithmslist@... > Subject: Re: [Algorithms] Depth of Field > > > Here's an interesting technique I heard at a Sony conference which was > intended as a simple texture compression but would work very well as a focus > effect. > > In a preprocess stage > 1/ Take your original full quality texture (say 64x64) > 2/ Filter it down to at least 1/4 the size (32x32). > 3/ Make a second alpha only detail texture at the original resolution > (64x64) to be overlayed on the blurry 32x32 texture  you can do this as low > as 4 bits per pixel if the hardware does it. (3/8th compression on a 32 bit > texture). > > If you multipass with the blurry texture then the detail texture overlaid it > is nearly impossible to tell the difference between the compressed and > original images. > > The interesting thing was that as you fade up the global alpha level of the > detail texture the image went very smoothly from being out of focus to > sharply in focus. > If you did this for every poly in the scene and calculated that alpha > modulation level on a per object basis depending on how near it was to the > centre of your FOV or even generically on a per vertex level in your vpu? > then you'd have a pretty cool non quantised DOF. > The main issues with the technique are that, > 1/ Its only a texture focus effect  doesn't do edges (silhouettes). > 2/ I suspect the alpha pass on every poly in the world is going to hurt on a > PC unless you make sure it happens in multitexture. > > > David > >  Original Message  > From: Pete Warden <pete@...> > To: algorithms <GDAlgorithmslist@...> > Sent: Thursday, September 06, 2001 12:40 AM > Subject: [Algorithms] Depth of Field > > > > > > Has anybody had any experiences implementing realtime DoF effects that > > they'd like to share? > > > > I'm thinking of either constraining things so I know what's foreground, > and > > what's background, making sure there's no midground, and just blurring > the > > background, or using the zbuffer (nonPC game) to postprocess the image > > with variable blur depending on the depth. > > > > Here's some links from a quick search: > > > > An artpackage equivalent of my first hacky method: > > > http://www.caligari.com/help/tuts_books/Marco_Bucci/lensfoucal/focalblur1.ht > > m > > > > Some less hacky methods: > > http://www.stereopsis.com/dof.html > > http://www.bbc.co.uk/rd/projects/virtual/depth.html > > > > And a more correct way to do it: > > > http://reality.sgi.com/blythe/sig99/advanced99/course_slides/effects/tsld035 > > .htm > > > > What I'm really interested in is the practical pitfalls of trying to fake > > DoF in a game, animation often seems to be mentioned as problematic, any > > idea what sort of visual problems using any of the hackier methods with > > animation would cause? > > > > Pete Warden > > > > > > ps, hi to all at VS, _finally_ made it over! > > > > > > _______________________________________________ > > GDAlgorithmslist mailing list > > GDAlgorithmslist@... > > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist > > > > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist > > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist 
From: Willem H. de Boer <W<illem@mu...>  20010906 11:05:33

Wouldn't that kind of give the same effect as using excessively blurred mipmapping, but without having to do a second pass? Are there any screenshots displaying the technique you described?  Willem Original Message From: David Hunt [mailto:david@...] Sent: 06 September 2001 11:41 To: gdalgorithmslist@... Subject: Re: [Algorithms] Depth of Field Here's an interesting technique I heard at a Sony conference which was intended as a simple texture compression but would work very well as a focus effect. In a preprocess stage 1/ Take your original full quality texture (say 64x64) 2/ Filter it down to at least 1/4 the size (32x32). 3/ Make a second alpha only detail texture at the original resolution (64x64) to be overlayed on the blurry 32x32 texture  you can do this as low as 4 bits per pixel if the hardware does it. (3/8th compression on a 32 bit texture). If you multipass with the blurry texture then the detail texture overlaid it is nearly impossible to tell the difference between the compressed and original images. The interesting thing was that as you fade up the global alpha level of the detail texture the image went very smoothly from being out of focus to sharply in focus. If you did this for every poly in the scene and calculated that alpha modulation level on a per object basis depending on how near it was to the centre of your FOV or even generically on a per vertex level in your vpu? then you'd have a pretty cool non quantised DOF. The main issues with the technique are that, 1/ Its only a texture focus effect  doesn't do edges (silhouettes). 2/ I suspect the alpha pass on every poly in the world is going to hurt on a PC unless you make sure it happens in multitexture. David  Original Message  From: Pete Warden <pete@...> To: algorithms <GDAlgorithmslist@...> Sent: Thursday, September 06, 2001 12:40 AM Subject: [Algorithms] Depth of Field > > Has anybody had any experiences implementing realtime DoF effects that > they'd like to share? > > I'm thinking of either constraining things so I know what's foreground, and > what's background, making sure there's no midground, and just blurring the > background, or using the zbuffer (nonPC game) to postprocess the image > with variable blur depending on the depth. > > Here's some links from a quick search: > > An artpackage equivalent of my first hacky method: > http://www.caligari.com/help/tuts_books/Marco_Bucci/lensfoucal/focalblur1.ht > m > > Some less hacky methods: > http://www.stereopsis.com/dof.html > http://www.bbc.co.uk/rd/projects/virtual/depth.html > > And a more correct way to do it: > http://reality.sgi.com/blythe/sig99/advanced99/course_slides/effects/tsld035 > .htm > > What I'm really interested in is the practical pitfalls of trying to fake > DoF in a game, animation often seems to be mentioned as problematic, any > idea what sort of visual problems using any of the hackier methods with > animation would cause? > > Pete Warden > > > ps, hi to all at VS, _finally_ made it over! > > > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist _______________________________________________ GDAlgorithmslist mailing list GDAlgorithmslist@... https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist 
From: David Hunt <david@hu...>  20010906 10:30:21

Here's an interesting technique I heard at a Sony conference which was intended as a simple texture compression but would work very well as a focus effect. In a preprocess stage 1/ Take your original full quality texture (say 64x64) 2/ Filter it down to at least 1/4 the size (32x32). 3/ Make a second alpha only detail texture at the original resolution (64x64) to be overlayed on the blurry 32x32 texture  you can do this as low as 4 bits per pixel if the hardware does it. (3/8th compression on a 32 bit texture). If you multipass with the blurry texture then the detail texture overlaid it is nearly impossible to tell the difference between the compressed and original images. The interesting thing was that as you fade up the global alpha level of the detail texture the image went very smoothly from being out of focus to sharply in focus. If you did this for every poly in the scene and calculated that alpha modulation level on a per object basis depending on how near it was to the centre of your FOV or even generically on a per vertex level in your vpu? then you'd have a pretty cool non quantised DOF. The main issues with the technique are that, 1/ Its only a texture focus effect  doesn't do edges (silhouettes). 2/ I suspect the alpha pass on every poly in the world is going to hurt on a PC unless you make sure it happens in multitexture. David  Original Message  From: Pete Warden <pete@...> To: algorithms <GDAlgorithmslist@...> Sent: Thursday, September 06, 2001 12:40 AM Subject: [Algorithms] Depth of Field > > Has anybody had any experiences implementing realtime DoF effects that > they'd like to share? > > I'm thinking of either constraining things so I know what's foreground, and > what's background, making sure there's no midground, and just blurring the > background, or using the zbuffer (nonPC game) to postprocess the image > with variable blur depending on the depth. > > Here's some links from a quick search: > > An artpackage equivalent of my first hacky method: > http://www.caligari.com/help/tuts_books/Marco_Bucci/lensfoucal/focalblur1.ht > m > > Some less hacky methods: > http://www.stereopsis.com/dof.html > http://www.bbc.co.uk/rd/projects/virtual/depth.html > > And a more correct way to do it: > http://reality.sgi.com/blythe/sig99/advanced99/course_slides/effects/tsld035 > .htm > > What I'm really interested in is the practical pitfalls of trying to fake > DoF in a game, animation often seems to be mentioned as problematic, any > idea what sort of visual problems using any of the hackier methods with > animation would cause? > > Pete Warden > > > ps, hi to all at VS, _finally_ made it over! > > > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist 
From: Mark Collins <m.collins@co...>  20010906 10:19:36

How to make a replyBut, if you do it properly, it can make debugging so = much easier (record the game, and replicate any bugs you find....) Mark 'Nurgle' Collins Developer Support  Codeplay Ltd. http://www.codeplay.com  Original Message =20 From: Jamie Fowlston=20 To: Iker@... ; gdalgorithmslist@...=20 Sent: Wednesday, September 05, 2001 1:45 PM Subject: RE: [Algorithms] How to make a reply Make sure game is deterministic. Store a complete game state. Then = record user input. Simple, but an absolute nightmare to debug, as the slightest error can = make the whole thing go wrong. Jamie 
From: Bruce Woodard <bwoodard@in...>  20010906 00:09:21

There's a Gamasutra article you'll want to check out that does something similar to your 1st method, but keeps things in the backend (no CPU postprocessing). Of course there are transitional artifacts, fillrate issues, yadda yadda yadda. In a nutshell... 1) render scene 2) create mipmaps of your framebuffer 3) render each mip level (Ztest, no Zwrite) over framebuffer at different depths http://www.gamasutra.com/features/20010209/evans_03.htm bruce Original Message From: Pete Warden [mailto:pete@...] Sent: Wednesday, September 05, 2001 5:40 PM To: algorithms Subject: [Algorithms] Depth of Field Has anybody had any experiences implementing realtime DoF effects that they'd like to share? I'm thinking of either constraining things so I know what's foreground, and what's background, making sure there's no midground, and just blurring the background, or using the zbuffer (nonPC game) to postprocess the image with variable blur depending on the depth. Here's some links from a quick search: An artpackage equivalent of my first hacky method: http://www.caligari.com/help/tuts_books/Marco_Bucci/lensfoucal/focalblur1.ht m Some less hacky methods: http://www.stereopsis.com/dof.html http://www.bbc.co.uk/rd/projects/virtual/depth.html And a more correct way to do it: http://reality.sgi.com/blythe/sig99/advanced99/course_slides/effects/tsld035 .htm What I'm really interested in is the practical pitfalls of trying to fake DoF in a game, animation often seems to be mentioned as problematic, any idea what sort of visual problems using any of the hackier methods with animation would cause? Pete Warden ps, hi to all at VS, _finally_ made it over! _______________________________________________ GDAlgorithmslist mailing list GDAlgorithmslist@... https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist 