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}
(3) 
_{Dec}

2015 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}
(12) 
_{Nov}

_{Dec}
(1) 
2016 
_{Jan}

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

_{Jun}
(1) 
_{Jul}

_{Aug}
(1) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 




1
(44) 
2
(37) 
3
(50) 
4
(5) 
5
(7) 
6
(14) 
7
(34) 
8
(18) 
9
(43) 
10
(75) 
11
(7) 
12
(3) 
13
(43) 
14
(19) 
15
(29) 
16
(21) 
17
(54) 
18
(12) 
19

20
(36) 
21
(9) 
22
(18) 
23
(30) 
24
(29) 
25
(18) 
26
(18) 
27
(38) 
28
(23) 
29
(21) 
30
(11) 
31
(19) 

From: Jon Watte <hplus@mi...>  20010812 19:15:10

> > > The way Z buffers work, they're sensitive to the ratio > > > between near and far, > > > moreso than the absolute values. > > > > This is incorrect. znear/zfar = 0 is perfectly reasonable and works well > > (zfar = infinity). The precision of a zbuffer is almost > entirely dependent > > on znear, at least for typical game situations. > > > > I have written a rather detailed analysis of this, but I can't > find it in > > the archives. If you you really need that info I can probably dig it up. > > Gil Sorry for being sloppy; the ratio between where your objects' Z is and where your near Z plane is is a much better categorization. (Your object doesn't go beyond the far Z though, at least not and still staying visible :) I believe the gist of the suggestion: draw overlapping Z bands, from far to near, still is the correct suggestion. If you have a large outdoors and have to work on 16bit Z buffers, that's the only thing that'll really work right that I know of. Cheers, / h+ 
From: akbara <syedali011@ea...>  20010812 13:44:31

yeah of course :) the first thing imho before you learn something new is finding out what's been done before. or you might waste your time on things that people have already done and probably implemented better then you. esp from an application perspective. where you have deadlines and are required to hit certaing perf rates. laterz, akbar A. On Sun, 12 Aug 2001 10:22:34 +0100 "Keith Harrison" <Keithhar@...> wrote: > Why reinvent the wheel? Download Mesa; they have an OpenGL 1.2 *compliant* > SW renderer, and lot's of SIMD code to munch the verts for you. > > I've successfully used the Mesa SW renderer in a project for one of my > clients who needed SW rendering. I just tweaked the inner loop of the > specific hook function that I needed. My client then had an opengl32.dll > file that did SW rendering, hence needed only to use noremal GL commands. > [ OK, I'm a Mesa driver writer so I'm biased :) ] > > http://www.mesa3d.org > > Disclaimer: While Mesa is not a licensed OpenGL implementation it does pass > the 1.2 conformance tests. > Note: OpenGL is a trademark of Silicon Graphics Incorporated. > > Regards, > Keith Harrison. > >  Original Message  > From: Warrick Buchanan > To: gdalgorithmslist@... > Sent: Wednesday, August 08, 2001 5:50 PM > Subject: [Algorithms] Polygon scan conversion accuracy... > > > Hi there, > > It's been a (very) long while since I've had to write a polygon scan > conversion routine  3d graphic cards make you lazy you know  and I think > I'm suffering from slightly inaccurate results. I've gone through the usual > books in an effort to reengage those scan conversion grey cells of a few > years ago and I'm still not sure where exactly I'm going slightly wrong. I > can tell it's slightly off by comparing it to the line (drawn using bog old > bresenham) outline of the subject polygon. > > Your help would be greatly appreciated.... > > here's the snippets of relevant code: > (btw it's currently all floating point not fixed point  I know that's evil > but it doesn't have to be fast and it is still possible to get it accurate!) > > struct Vertex > { > float x; > float y; > } > > > void rightSection(const Vertex *vertex, > const unsigned long vertices, > float &x, > unsigned long &v0, unsigned long &v1, > unsigned long &height, float &dxdy ) > { > do > { > v0 = v1; > v1 = (v1 == vertices  1) ? 0 : v1 + 1; > > height = ceil(vertex[v1].y)  ceil(vertex[v0].y); > } > while(!height); > > dxdy = (vertex[v1].x  vertex[v0].x)/(vertex[v1].y  vertex[v0].y); > x = vertex[v0].x + (ceil(vertex[v0].y)  vertex[v0].y)*dxdy; > } > > > void leftSection(const Vertex *vertex, > const unsigned long vertices, > float &x, > unsigned long &v0, unsigned long &v1, > unsigned long &height, float &dxdy ) > { > do > { > v0 = v1; > v1 = v1 ? v1  1 : vertices  1; > > height = ceil(vertex[v1].y)  ceil(vertex[v0].y); > } > while(!height); > > dxdy = (vertex[v1].x  vertex[v0].x)/(vertex[v1].y  vertex[v0].y); > x = vertex[v0].x + (ceil(vertex[v0].y)  vertex[v0].y)*dxdy; > } > > // Obviously not optimised yet! > void fill(Image_ARGB8 &image, const float lx, const float rx, const unsigned > long y, const Pixel_ARGB8 &colour) > { > Pixel_ARGB8 *data = image.data + long(ceil(lx)) + y*image.width; > unsigned long pixels = ceil(rx)  ceil(lx); > > if(pixels) > while(pixels) *data++ = colour; > } > > // Assumes polygon is convex and of the correct winding! > void polygon(Image_ARGB8 &image, const Vertex *vertex, const unsigned long > vertices, const Pixel_ARGB8 &colour) > { > unsigned long ymax = 0; > unsigned long ymin = 0; > > // Find ymin and ymax vertices > for(unsigned long v = 1; v < vertices; v++) > { > if(vertex[v].y > vertex[ymax].y) ymax = v; > if(vertex[v].y < vertex[ymin].y) ymin = v; > } > > unsigned long l0 = ymin; > unsigned long l1 = ymin ? ymin  1 : vertices  1; > unsigned long r0 = ymin; > unsigned long r1 = (ymin == vertices  1) ? 0 : ymin + 1; > > unsigned long rows = ceil(vertex[ymax].y)  ceil(vertex[ymin].y); > unsigned long y = ceil(vertex[ymin].y); > unsigned long lheight, rheight; > float ldxdy, rdxdy; > float lx, rx; > > if(!rows) return; > > > lheight = ceil(vertex[l1].y)  ceil(vertex[l0].y); > > if(lheight) > { > ldxdy = (vertex[l1].x  vertex[l0].x)/(vertex[l1].y  vertex[l0].y); > lx = vertex[l0].x + (ceil(vertex[l0].y)  vertex[l0].y)*ldxdy; > } > else leftSection(vertex, vertices, lx, l0, l1, lheight, ldxdy); > > > rheight = ceil(vertex[r1].y)  ceil(vertex[r0].y); > > if(rheight) > { > rdxdy = (vertex[r1].x  vertex[r0].x)/(vertex[r1].y  vertex[r0].y); > rx = vertex[r0].x + (ceil(vertex[r0].y)  vertex[r0].y)*rdxdy; > } > else rightSection(vertex, vertices, rx, r0, r1, rheight, rdxdy); > > > while(rows) > { > if(rheight == 0) rightSection(vertex, vertices, rx, r0, r1, rheight, > rdxdy); > if(lheight == 0) leftSection(vertex, vertices, lx, l0, l1, lheight, > ldxdy); > > if(lx < rx) fill(image, lx, rx, y, colour); > > rx += rdxdy; > lx += ldxdy; > > y++; > } > } > > Thanks, > > Warrick. > > > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > http://lists.sourceforge.net/lists/listinfo/gdalgorithmslist  "it's called Mario Twins, and I WANT TO PLAY IT" http://vertexabuse.cjb.net 
From: Keith Harrison <Keithhar@bt...>  20010812 11:06:28

Why reinvent the wheel? Download Mesa; they have an OpenGL 1.2 *compliant* SW renderer, and lot's of SIMD code to munch the verts for you. I've successfully used the Mesa SW renderer in a project for one of my clients who needed SW rendering. I just tweaked the inner loop of the specific hook function that I needed. My client then had an opengl32.dll file that did SW rendering, hence needed only to use noremal GL commands. [ OK, I'm a Mesa driver writer so I'm biased :) ] http://www.mesa3d.org Disclaimer: While Mesa is not a licensed OpenGL implementation it does pass the 1.2 conformance tests. Note: OpenGL is a trademark of Silicon Graphics Incorporated. Regards, Keith Harrison.  Original Message  From: Warrick Buchanan To: gdalgorithmslist@... Sent: Wednesday, August 08, 2001 5:50 PM Subject: [Algorithms] Polygon scan conversion accuracy... Hi there, It's been a (very) long while since I've had to write a polygon scan conversion routine  3d graphic cards make you lazy you know  and I think I'm suffering from slightly inaccurate results. I've gone through the usual books in an effort to reengage those scan conversion grey cells of a few years ago and I'm still not sure where exactly I'm going slightly wrong. I can tell it's slightly off by comparing it to the line (drawn using bog old bresenham) outline of the subject polygon. Your help would be greatly appreciated.... here's the snippets of relevant code: (btw it's currently all floating point not fixed point  I know that's evil but it doesn't have to be fast and it is still possible to get it accurate!) struct Vertex { float x; float y; } void rightSection(const Vertex *vertex, const unsigned long vertices, float &x, unsigned long &v0, unsigned long &v1, unsigned long &height, float &dxdy ) { do { v0 = v1; v1 = (v1 == vertices  1) ? 0 : v1 + 1; height = ceil(vertex[v1].y)  ceil(vertex[v0].y); } while(!height); dxdy = (vertex[v1].x  vertex[v0].x)/(vertex[v1].y  vertex[v0].y); x = vertex[v0].x + (ceil(vertex[v0].y)  vertex[v0].y)*dxdy; } void leftSection(const Vertex *vertex, const unsigned long vertices, float &x, unsigned long &v0, unsigned long &v1, unsigned long &height, float &dxdy ) { do { v0 = v1; v1 = v1 ? v1  1 : vertices  1; height = ceil(vertex[v1].y)  ceil(vertex[v0].y); } while(!height); dxdy = (vertex[v1].x  vertex[v0].x)/(vertex[v1].y  vertex[v0].y); x = vertex[v0].x + (ceil(vertex[v0].y)  vertex[v0].y)*dxdy; } // Obviously not optimised yet! void fill(Image_ARGB8 &image, const float lx, const float rx, const unsigned long y, const Pixel_ARGB8 &colour) { Pixel_ARGB8 *data = image.data + long(ceil(lx)) + y*image.width; unsigned long pixels = ceil(rx)  ceil(lx); if(pixels) while(pixels) *data++ = colour; } // Assumes polygon is convex and of the correct winding! void polygon(Image_ARGB8 &image, const Vertex *vertex, const unsigned long vertices, const Pixel_ARGB8 &colour) { unsigned long ymax = 0; unsigned long ymin = 0; // Find ymin and ymax vertices for(unsigned long v = 1; v < vertices; v++) { if(vertex[v].y > vertex[ymax].y) ymax = v; if(vertex[v].y < vertex[ymin].y) ymin = v; } unsigned long l0 = ymin; unsigned long l1 = ymin ? ymin  1 : vertices  1; unsigned long r0 = ymin; unsigned long r1 = (ymin == vertices  1) ? 0 : ymin + 1; unsigned long rows = ceil(vertex[ymax].y)  ceil(vertex[ymin].y); unsigned long y = ceil(vertex[ymin].y); unsigned long lheight, rheight; float ldxdy, rdxdy; float lx, rx; if(!rows) return; lheight = ceil(vertex[l1].y)  ceil(vertex[l0].y); if(lheight) { ldxdy = (vertex[l1].x  vertex[l0].x)/(vertex[l1].y  vertex[l0].y); lx = vertex[l0].x + (ceil(vertex[l0].y)  vertex[l0].y)*ldxdy; } else leftSection(vertex, vertices, lx, l0, l1, lheight, ldxdy); rheight = ceil(vertex[r1].y)  ceil(vertex[r0].y); if(rheight) { rdxdy = (vertex[r1].x  vertex[r0].x)/(vertex[r1].y  vertex[r0].y); rx = vertex[r0].x + (ceil(vertex[r0].y)  vertex[r0].y)*rdxdy; } else rightSection(vertex, vertices, rx, r0, r1, rheight, rdxdy); while(rows) { if(rheight == 0) rightSection(vertex, vertices, rx, r0, r1, rheight, rdxdy); if(lheight == 0) leftSection(vertex, vertices, lx, l0, l1, lheight, ldxdy); if(lx < rx) fill(image, lx, rx, y, colour); rx += rdxdy; lx += ldxdy; y++; } } Thanks, Warrick. 