--- libgender/view.C	2004/10/06 16:19:14	1.30
+++ libgender/view.C	2004/11/05 16:02:34	1.72
@@ -1,13 +1,49 @@
 #include <cmath>
 
-#include <GL/gl.h>
-#include <GL/glext.h>
+#include "opengl.h"
 
-#include "oct.h"
 #include "view.h"
+#include "oct.h"
+
+using namespace gl;
+
+pass pass_depth (0);
+
+vector<GLuint> occ_query_objects;
+
+static GLuint begin_occ_query ()
+{
+  GLuint id;
+
+  if (occ_query_objects.size ())
+    {
+      id = *(occ_query_objects.end () - 1);
+      occ_query_objects.pop_back ();
+    }
+  else
+    glGenQueries (1, &id);
+
+  glBeginQuery (GL_SAMPLES_PASSED, id);
+  return id;
+}
+
+inline void end_occ_query ()
+{
+  glEndQuery (GL_SAMPLES_PASSED);
+}
+
+static GLuint occ_query_result (GLuint id)
+{
+  GLuint count;
+
+  glGetQueryObjectuiv (id, GL_QUERY_RESULT, &count);
+  occ_query_objects.push_back (id);
+
+  return count;
+}
 
 view::view ()
-: gamma(1.0)
+: gamma(1.0), nz_near (1.F), nz_far (2.F)
 {
 }
 
@@ -15,7 +51,17 @@
 {
 }
 
-bool view::may_draw (entity_base *e)
+void view::begin_occ_query (recv_occ_query &recv, void *id)
+{
+  occ_queries.push_back (oq_data (&recv, ::begin_occ_query (), id));
+}
+
+void view::end_occ_query ()
+{
+  ::end_occ_query ();
+}
+
+bool view::may_draw (const entity *e)
 {
   if (drawn.find (e) != drawn.end ())
     return false;
@@ -24,6 +70,32 @@
   return true;
 }
 
+visibility_base *visible::get_visibility (view &ctx)
+{
+  view::visibility_map::iterator i = ctx.vismap.find (this);
+  visibility_base *vs;
+
+  if (i == ctx.vismap.end ())
+    {
+      vs = new_visibility ();
+      ctx.vismap.insert (view::visibility_map::value_type (this, vs));
+    }
+  else
+    {
+      vs = i->second;
+
+      if (vs->generation != ctx.generation)
+        {
+          if (vs->generation + 1 != ctx.generation)
+            clear_visibility (vs);
+
+          vs->generation = ctx.generation;
+        }
+    }
+
+  return vs;
+}
+
 void view::reset_projection ()
 {
   renormalize (orig, p);
@@ -34,27 +106,54 @@
   glLoadIdentity ();
 
   GLdouble aspect = (GLdouble)w/h;
-  GLdouble zNear = 0.1;
-  GLdouble zFar = 50.;
+  GLdouble ftan = tan (fov * (.5 * M_PI / 180.));
+  GLdouble ymax = z_near * ftan;
+  GLdouble xmax = ymax * aspect;
 
-  GLdouble ymax = zNear * tan (fov * (M_PI / 360.0));
-  glFrustum (-ymax * aspect, ymax * aspect, -ymax, ymax, zNear, zFar);
+  matrix perspective;
+#if 0
+  {
+    matrix &m = perspective;
+    m(0,0) = rx.x; m(0,1) = rx.y; m(0,2) = rx.z; m(0,3) = 0;
+    m(1,0) = ry.x; m(1,1) = ry.y; m(1,2) = ry.z; m(1,3) = 0;
+    m(2,0) = rz.x; m(2,1) = rz.y; m(2,2) = rz.z; m(2,3) = 0;
+    m(3,0) =    0; m(3,1) =    0; m(3,2) =    0; m(3,3) = 1;
+
+    LoadMatrixf (perspective);
+  }
+#else
+  glFrustum (-xmax, xmax, -ymax, ymax, z_near, z_far);
+#endif
+
+  glGetFloatv (GL_PROJECTION_MATRIX, perspective);
+
+  perspfact = z_near / ymax * 0.5F * h;
+
+  glMatrixMode (GL_MODELVIEW);
+  glLoadIdentity ();
+  matrix &m = projection;
 
   d = normalize (d);//D
   u = normalize (u);//D
+
   vec3 rz = -d;
   vec3 rx = cross (u, rz);
   vec3 ry = cross (rz, rx);
 
-  matrix &m = projection;
   m(0,0) = rx.x; m(0,1) = rx.y; m(0,2) = rx.z; m(0,3) = 0;
   m(1,0) = ry.x; m(1,1) = ry.y; m(1,2) = ry.z; m(1,3) = 0;
   m(2,0) = rz.x; m(2,1) = rz.y; m(2,2) = rz.z; m(2,3) = 0;
   m(3,0) =    0; m(3,1) =    0; m(3,2) =    0; m(3,3) = 1;
 
-  glMultMatrixf ((GLfloat *)m.data);
+  diagfact = abs (rz.x) + abs (rz.y) + abs (rz.z);
+  //printf ("diagfact = %f\n", diagfact);
+  diagfact = sqrtf (3.);//D WHY???
 
-  glGetFloatv (GL_PROJECTION_MATRIX, (GLfloat *)&m);
+  glMultMatrixf (m);
+  
+  glGetFloatv (GL_MODELVIEW_MATRIX, m);
+
+  m = perspective * m;
 
   frustum.l = plane ( m(3,0) + m(0,0), m(3,1) + m(0,1), m(3,2) + m(0,2), m(3,3) + m(0,3) );
   frustum.r = plane ( m(3,0) - m(0,0), m(3,1) - m(0,1), m(3,2) - m(0,2), m(3,3) - m(0,3) );
@@ -63,104 +162,165 @@
   frustum.n = plane ( m(3,0) + m(2,0), m(3,1) + m(2,1), m(3,2) + m(2,2), m(3,3) + m(2,3) );
   frustum.f = plane ( m(3,0) - m(2,0), m(3,1) - m(2,1), m(3,2) - m(2,2), m(3,3) - m(2,3) );
 
-  glMatrixMode (GL_MODELVIEW);
-  glLoadIdentity ();
+  {
+    GLdouble frustlen = z_far - z_near;
+    GLdouble fheight  = frustlen * ftan;
+    GLdouble fwidth   = fheight * w / h;
+    point half (0, 0, z_near + frustlen * .5);
+    point corner (fwidth, fheight, frustlen);
+    
+    frustum.s = sphere (p + d * (.5 * frustlen), length (corner - half));
+  }
+
+  {
+    GLdouble depth = h / ftan;
+
+    frustum.c = cone (p, d, atan (sqrt (GLdouble (w * w + h * h)) * ftan / h));
+  }
+
   glTranslatef (-p.x, -p.y, -p.z);
 }
 
 void view::begin ()
 {
-  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-  glDepthRange (0, 1. - (1. / pow (2., 16.)));
+  generation++;
 
-  vismap.clear ();
   vislist.clear ();
 
-  generation++;
+  z_near = max (nz_near, 1.F);
+  z_far = max (nz_far, z_near * 2.F);
+  c_far = nc_far;
 
   reset_projection ();
 
-  // check occlusion queries here
-#if 0
-  for (vector<octant *>::iterator i = checklist.begin (); i != checklist.end (); ++i)
-    //printf ("%p %d\n", *i, occ_query_result ((*i)->occ_query));
-    occ_query_result ((*i)->occ_query);
-
-  checklist.clear ();
-#endif
-
-  world.detect_visibility (*this);
+  nz_near = 100.;
+  nc_far = nz_far = 1.F;
 }
 
 void view::end ()
 {
-  vismap.clear ();
+  vislist.clear ();
 }
 
-void view::pass (enum mode m)
-{
-  mode = m;
+#define DEPTH_OFFSET (1. / (GLdouble)(1L << 16))
 
-  glDisable (GL_ALPHA_TEST);
-  glDisable (GL_BLEND);
+void view::render (enum pass_type p, pass &data)
+{
+  pass_type = p;
+  pass_data = &data;
 
-  if (mode == view::DEPTH)
-    {
-      glEnable (GL_POLYGON_OFFSET_FILL);
-      glPolygonOffset (0, 1);
-      glDepthFunc (GL_LESS);
-      glDisable (GL_LIGHTING);
-      glColorMask (0, 0, 0, 0);
-      cgGLEnableProfile (vsh_profile);// z-fighting??
-      cgGLDisableProfile (fsh_profile);
-    }
-  else
+  switch (pass_type)
     {
-      glEnable (GL_MINMAX);
-      glDisable (GL_POLYGON_OFFSET_FILL);
-      glDepthFunc (GL_LESS);
-      glDepthMask (0);
-      cgGLEnableProfile (vsh_profile);
-      cgGLEnableProfile (fsh_profile);
+      case DEPTH:
+        glColorMask (1, 1, 1, 1);
+        glDepthMask (1);
+
+        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+        //glEnable (GL_STENCIL_TEST); // for depth-passes
+        //glStencilOp (GL_KEEP, GL_KEEP, GL_REPLACE);
+        //glStencilFunc (GL_LESS, 1, 255);
+
+        //glEnable (GL_POLYGON_OFFSET_FILL);
+        //glPolygonOffset (0, 5);
+        glDisable (GL_MINMAX);
+        glDepthRange (DEPTH_OFFSET, 1.);
+        glDepthFunc (GL_LESS);
+        glEnable (GL_DEPTH_TEST);
+        glColorMask (0, 0, 0, 0);
+        glDisable (GL_DEPTH_CLAMP_NV);
+
+        world.detect_visibility (*this);
+
+        break;
+
+      case POSTDEPTH:
+        glDepthRange (0., 1. - DEPTH_OFFSET);
+        glDepthFunc (GL_LESS);
+        glColorMask (0, 0, 0, 0);
+        glDepthMask (0);
+        glEnable (GL_DEPTH_CLAMP_NV);
+        glDisable (GL_STENCIL_TEST);
+       
+        // check occlusion queries
+        for (vector<oq_data>::iterator i = occ_queries.begin (); i != occ_queries.end (); ++i)
+          {
+            occ_query oq(*this, i->data, ::occ_query_result (i->id));
+            i->recv->event (oq);
+          }
+
+        occ_queries.clear ();
+
+        break;
+
+      case LIGHTED:
+        glClear (GL_STENCIL_BUFFER_BIT);
+        //glEnable (GL_STENCIL_TEST);
+        glEnable (GL_MINMAX);
+        glDepthRange (0., 1. - DEPTH_OFFSET);
+        glDepthFunc (GL_LESS);
+        glColorMask (1, 1, 1, 1);
+        glDepthMask (0);
+        glDisable (GL_DEPTH_CLAMP_NV);
+
+        break;
     }
   
   for (vector<octant *>::iterator i = vislist.begin (); i != vislist.end (); ++i)
     (*i)->display (*this);
 
+  if (pass_type == DEPTH)
+    printf ("fps %f NF %f:%f vis %d CAM (%d,%d,%d)\n", timer.fps, z_near, z_far, drawn.size (), orig.x, orig.y, orig.z);//D
+
   drawn.clear ();
 
-  if (mode == view::LIGHTED)
+#if 0
+  if (pass == view::DEPTH)
     {
       glEnable (GL_DEPTH_CLAMP_NV);
+      glDepthMask (0);
       glDepthFunc (GL_LESS);
-      glEnable (GL_COLOR_MATERIAL);
-      glDisable (GL_LIGHTING);
-#if 1
-      cgGLDisableProfile (vsh_profile);
-      cgGLDisableProfile (fsh_profile);
-#endif
-      glShadeModel (GL_FLAT);
 
-      static int count; count++;
-      if (farlist.size ())
-        printf ("%d: size %d\n", count, farlist.size ());
-
-     for (vector<octant *>::iterator i = farlist.begin (); i != farlist.end (); ++i)
-       {
-        glColor3f (1 / (GLfloat)(i - farlist.begin()), 1, 1 / (GLfloat)(i - farlist.begin()));
-        (*i)->draw_bbox (*this);
+      for (vector<octant *>::iterator i = farlist.begin (); i != farlist.end (); ++i)
+        {
+          begin_occ_query (**i);
+          (*i)->draw_bbox (*this);
+          end_occ_query ();
        }
 
-      farlist.clear ();
-
-      glEnable (GL_DEPTH_TEST);
       glDisable (GL_DEPTH_CLAMP_NV);
-      glShadeModel (GL_SMOOTH);
     }
+#endif
+}
+
+void light::enable ()
+{
+  lightpos->set (p);
+}
+
+void light::disable ()
+{
+}
+
+static shader::varying_1f camdist;
+static shader::varying_3f lightvec;
+
+void linear_light::vsh ()
+{
+  using namespace shader::compile;
+
+  lightvec = xyz (lightpos - model_view_matrix * vin.vertex);
+  camdist = max (1 - length (lightvec) / radius, 0);
+}
+
+shader::temp_3f linear_light::operator ()()
+{
+  using namespace shader::compile;
 
-  glColorMask (1, 1, 1, 0);
-  glDepthMask (1);
+  temp_3f res;
+  res = float3 (c.r / 255.F, c.g / 255.F, c.b / 255.F) * (min (intensity * camdist * 0.6F + 0.9F, 1.F));
 
+  return res;
 }