Workspace.h

#ifndef WORKSPACE_H
#define WORKSPACE_H

/* The workspace models the physical obstacles in the world. */
/* This particular workspace is 3D and polygonal. */

#include <vector>
#include <list>

#include "prefix.h"
#include "bsp.h"
#include "io.h"
#include "camera.h"
#include "file.h"
#include <stdio.h>
#include "opengl.h"


#define DEFAULT_OPACITY 0.6


/* instead of including */
class ConStruct;
class Simulation;

class Workspace
{
public:
  /* construction from a configuration structure */
  Workspace (const ConStruct &cfg);

  /* destructor */
  ~Workspace ();

  /*************** stuff for graphic/IO **************/

  static void render_normal(BSP::Node *n);
  static void render_wireframe(BSP::Node *n);
  
  /* renders the workspace */
  void Render (const Simulation *settings);

  //add a point of interest in the workspace
  //to be rendered
  static void AddDebugPoint(const Vector& pt, const double red, const double green, const double blue);

  //since workspace has several cameras, get active one
  const Camera* GetActiveCamera() const;

  /* handles key presses, mouse movement, etc */
  void KeyPress (IO_Window *win, const IO_Key &k);
  void Update (IO_Window *win, Simulation* sim);

  /****************** intersections ********************/

  /* intersection testing... */
  void PillIntersection
   (Intersection *ir, LineContext *lc_array, const Vector &p1, const Vector &p2, double radius) const
    {
      bsp->PillIntersection (ir, lc_array, p1, p2, radius);
    }
  void SphereIntersection
   (Intersection *ir, PointContext *pc_array, const Vector &p, double radius) const
    {
      bsp->SphereIntersection (ir, pc_array, p, radius);
    }
  void RayIntersection
   (Intersection *ir, const Vector& p, const Vector& direction) const
    {
      bsp->RayIntersection (ir, p, direction);
    }
  void InvRayIntersection
   (Intersection *ir, const Vector& p, const Vector& direction) const
    {
      bsp->InvRayIntersection (ir, p, direction);
    }
  void LineIntersection
   (Intersection *ir, const Vector& p1, const Vector& p2) const
    {
      bsp->LineIntersection (ir, p1, p2);
    }
  void InvLineIntersection
   (Intersection *ir, const Vector& p1, const Vector& p2) const
    {
      bsp->InvLineIntersection (ir, p1, p2);
    }
  void PointIntersection
   (Intersection *ir, const Vector& p) const
    {
      bsp->PointIntersection (ir, p);
    }
  /* builds a list of obstacles that a ray intersects, sorted by distance
     (the first element in the list is closest) */
  void AllRayIntersections
   (std::list<const ObstacleSet::Solid *> *obs, const Vector& p, const Vector& direction) const
    {
      bsp->AllRayIntersections (obs, p, direction);
    }
  /* distance testing... */
  void PointDistance
   (PointContext **pc, PointContext *pc_array, const Vector& p) const
    {
      bsp->PointDistance (pc, pc_array, p);
    }
  void LineDistance
   (LineContext **lc, LineContext *lc_array, const Vector& p1, 
    const Vector& p2) const
    {
      bsp->LineDistance (lc, lc_array, p1, p2);
    }

  /* The following functions access the workspace according to
     individual obstacles... */
  /* The BSP needs to use this stuff, but you shouldn't... */

  /* Get the number of obstacles in the workspace.  */
  inline int NumSolids (void) const { return obset->num_solids(); };

  /* Individual obstacles in the world can be accessed by indices, so
     you can use these functions to do distance and intersection
     testing against individual obstacles.  */
  void ObstaclePillIntersection
   (Intersection* ir, const Vector &p1, const Vector& p2, double radius,
    LineContext* lc) const;
  void ObstacleSphereIntersection
   (Intersection* ir, const Vector &p, double radius, PointContext* c) const;

  /* gravity accessor */
  const Vector& getGravity() { return gravity; }

  void ToggleVisibility(ObstacleSet::Solid* solid){
    solid->toggle_visibility();
  }

  /* obstacles */
  ObstacleSet* obset;

private:
  /* the file handle for this workspace */
  File file;

  /* the direction and magnitude of gravity */
  Vector gravity;

  /* Binary Space Partitioning tree */
  BSP* bsp;

  /**** camera stuff ****/

  /* write camera presets to file */
  void write_cameras (void);

  /* associated camera */
  Camera camera;

  /* preset camera positions */
  struct preset_camera
  {
    Vector p, f, u;
  };
  std::vector<preset_camera> cameras;
  int active_camera;

  /**** some extra junk for debugging and graphics ****/

  /* OpenGL texture environment */
  std::vector <Texture> textures;

  /* which object is highlighted */
  const ObstacleSet::Solid* highlighted;
  
  struct DebugPoint{
    Vector pt;
    double color[3];
  };
    
  static std::vector<DebugPoint> debug_pts;
};
#endif

---