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}

S  M  T  W  T  F  S 






1
(12) 
2
(4) 
3

4
(21) 
5
(3) 
6
(27) 
7
(31) 
8
(21) 
9
(2) 
10
(2) 
11
(14) 
12
(19) 
13
(24) 
14
(17) 
15
(27) 
16

17
(2) 
18
(2) 
19
(6) 
20
(1) 
21
(17) 
22
(12) 
23
(1) 
24
(1) 
25
(4) 
26
(16) 
27
(17) 
28
(7) 
29

30

31
(1) 






From: Idahosa Edokpayi <idahosae@sw...>  20020331 11:18:20

Here is the new code for my triangle class incorporating most of the recommendations Jackie Chan and Angel Popov made. What I would still like to know is: What happens to triangles that are "on"? They do not intersect, they are not above, and not below yet they are in the BSP and not rejected. This somehow seems like it would be bad thing just waiting to bite an unsuspecting coder in the butt. Also, I want to know, what are the ramifications if I actually do write triangle intersection code using separating axis theorem or whatever I am convinced is the fastest way to do it and I substitute that for my current triangle intersection code? The code I have now detects PLANE intersection. By using strict triangle intersection would I be jacking up the semantics of my BSP system? #ifndef TRIANGLE_H #define TRIANGLE_H #include "mathcore.h" template <class vector, class matrix, class plane > class triangle { private: vector m_vVertices[3]; plane m_Plane; // speed up BSP comparisons static scalar m_Epsilon; public: triangle(){} triangle( const vector& v1, const vector& v2, const vector& v3 ) { m_vVertices[0] = v1; m_vVertices[1] = v2; m_vVertices[2] = v3; PlaneFromPoints( m_Plane, m_vVertices[0], m_vVertices[1], m_vVertices[2] ); } triangle( const vector* pvVertices ) { m_vVertices[0] = pvVertices[0]; m_vVertices[1] = pvVertices[1]; m_vVertices[2] = pvVertices[2]; PlaneFromPoints( m_Plane, m_vVertices[0], m_vVertices[1], m_vVertices[2] ); } ~triangle(){} // modifier void setVertex( const vector& v, const unsigned int index ) { m_vVertices[index%3] = v; PlaneFromPoints( m_Plane, m_vVertices[0], m_vVertices[1], m_vVertices[2] ); } // operators // assignment triangle& operator=( const triangle& tri ) { m_vVertices[0] = tri .m_vVertices[0]; m_vVertices[1] = tri .m_vVertices[1]; m_vVertices[2] = tri .m_vVertices[2]; PlaneFromPoints( m_Plane, m_vVertices[0], m_vVertices[1], m_vVertices[2] ); } // array operator const vector& operator[]( const unsigned int index ) const { return m_vVertices[index%3]; } // comparison for BSP partitioning bool operator < ( const triangle& tri ) const { if( SignedDistanceToPoint( m_Plane, tri[0] ) < triangle::m_Epsilon && SignedDistanceToPoint( m_Plane, tri[1] ) < triangle::m_Epsilon && SignedDistanceToPoint( m_Plane, tri[2] ) < triangle::m_Epsilon ) return true; return false; } bool operator > ( const triangle& tri ) const { if( SignedDistanceToPoint( m_Plane, tri[0] ) > triangle::m_Epsilon && SignedDistanceToPoint( m_Plane, tri[1] ) > triangle::m_Epsilon && SignedDistanceToPoint( m_Plane, tri[2] ) > triangle::m_Epsilon ) return true; return false; } // plane intersection bool operator == ( const triangle& tri ) const { return ( !(*this < tri) && !(*this > tri) ); } enum cmp { ABOVE, BELOW, ON, INTERSECTING }; // test point comparison cmp Compare( const vector& v ) { // above or below scalar sTest = SignedDistanceToPoint( m_Plane, v ); if( sTest > triangle::m_Epsilon ) return ABOVE; else if( sTest < triangle::m_Epsilon ) return BELOW; return ON; } cmp Compare( const triangle& tri ) { // use separating axis fool! return ABOVE; } }; #endif Idahosa Edokpayi 