source: trunk/VUT/GtpVisibilityPreprocessor/src/VssRay.h @ 463

#ifndef __VSS_RAY_H
#define __VSS_RAY_H

#include <vector>
using namespace std;
#include "Vector3.h"
#include "Ray.h"

class AxisAlignedBox3;
class Intersectable;

class VssRay {
public:
  // various flags
  enum {
    FPosDirX = 1,  // the direction of ray in X-axis is positive
    FPosDirY = 2,  // the direction of ray in Y-axis is positive
    FPosDirZ = 4   // the direction of ray in Z-axis is positive
  };

  static int mailID;
  int mMailbox;
        
  // side of the ray - used for the ray classification
  //  char mSide;
        
  // computed t
  //  float mT;

  // inverse of the ray size
  float mInvSize;
  
  // counter of references to this ray
  short mRefCount;
  
  // various flags
  char mFlags;
        
  Vector3 mOrigin;
  Vector3 mTermination;
        
  /// Termination object for the ray
  /// only the termination object is actually used
  Intersectable *mOriginObject;
  Intersectable *mTerminationObject;
        
  //////////////////////////////
  VssRay(const Vector3 &origin,
                 const Vector3 &termination,
                 Intersectable *originObject,
                 Intersectable *terminationObject):
        mMailbox(-1),
    mOrigin(origin),
    mTermination(termination),
        mOriginObject(originObject),
        mTerminationObject(terminationObject),
        mRefCount(0),
    mFlags(0)
        //      mT(1.0f)
  {
    Precompute();
  }
        
  VssRay(const Ray &ray):
        mRefCount(0),
        mFlags(0),
        mMailbox(-1),
        mOriginObject(ray.sourceObject.mObject)
        //      mT(1.0f)
        {
                if (ray.sourceObject.mObject)
                        mOrigin = ray.Extrap(ray.sourceObject.mT);
                else
                        mOrigin = ray.GetLoc(); 

                //Debug << "origin: " << mOrigin << endl;
                if (!ray.intersections.empty())
                {
                        mTermination = ray.Extrap(ray.intersections[0].mT);
                        mTerminationObject = ray.intersections[0].mObject;
                }
                else
                {
                        mTermination = ray.Extrap(1e6);//TODO: should be Limits::Infinity
                        mTerminationObject = NULL;
                }

                Precompute();
  }

  void Precompute() {
    mFlags = 0;
        Vector3 dir = GetDir();

#define BIDIRECTIONAL_RAY 0
#if BIDIRECTIONAL_RAY
        if (dir.y < 0) {
          // swap objects and poits     
          swap(mOriginObject, mTerminationObject);
          swap(mOrigin, mTermination);
          dir = -dir;
        }
#endif
        if (dir.x > 0.0f) mFlags |= FPosDirX;
    if (dir.y > 0.0f) mFlags |= FPosDirY;
    if (dir.z > 0.0f) mFlags |= FPosDirZ;

    mInvSize = 1.0f/Magnitude(GetDir());
  }

  void Mail() { mMailbox = mailID; }
  static void NewMail() { mailID++; }
  bool Mailed() const { return mMailbox == mailID; }

  bool Mailed(const int mail) {
    return mMailbox >= mailID + mail;
  }

  int HitCount() const {
#if BIDIRECTIONAL_RAY
        if (mOriginObject && mTerminationObject)
          return 2;
        if (mOriginObject || mTerminationObject)
          return 1;
        return 0;
#else
        return (mTerminationObject) ? 1 : 0;
#endif
  }
        
  Vector3 GetOrigin() const { return mOrigin; }
  Vector3 GetTermination() const { return mTermination; }
  Vector3 GetDir() const { return mTermination - mOrigin; }
  //  Vector3 GetNormalizedDir() const { return Normalize(termination - mOrigin); }
  Vector3 GetNormalizedDir() const { return (mTermination - mOrigin)*mInvSize; }

  float Length() const { return Distance(mOrigin, mTermination); }

  Vector3 Extrap(const float t) const {
        return GetOrigin() + t * GetDir();
  }
        
  float GetDirParametrization(const int axis) const;

  static float VssRay::GetDirParam(const int axis, const Vector3 dir);

  float GetSize() const { return  1.0f/mInvSize; }
  float GetInvSize() const { return  mInvSize; }
  float GetOrigin(const int axis) const { return mOrigin[axis]; }
  float GetTermination(const int axis) const { return mTermination[axis]; }
  float GetDir(const int axis) const { return mTermination[axis] - mOrigin[axis]; }
  float GetNormalizedDir(const int axis) const {
    return (mTermination[axis] - mOrigin[axis])*mInvSize;
  }
        
  bool
  ComputeMinMaxT(const AxisAlignedBox3 &box,
                                 float &tmin,
                                 float &tmax) const;
        
  bool
  Intersects(const AxisAlignedBox3 &box,
                         float &tmin,
                         float &tmax) const;
        
  bool
  IntersectsSphere(const Vector3 &center,
                                   const float sqrRadius,
                                   Vector3 &point,
                                   float &t) const;
        
  void
  Translate(const Vector3 &translation) {
    mOrigin += translation;
    mTermination += translation;
  }

  void SetupEndPoints(const Vector3 &origin,
                                          const Vector3 &termination)
  {
        mOrigin = origin;
        mTermination = termination;
        Precompute();
  }
                                                                                        
  bool HasPosDir(const int axis) const { return mFlags & (1<<axis); }

  char Flags() const { return mFlags;}
  void SetFlags(char orFlag) { mFlags |= orFlag;}
  
  bool IsActive() const { return mRefCount>0; }
        
  // reference counting for leaf nodes
  int RefCount() const { return mRefCount; }
  int Ref() { return mRefCount++; }
        
  void ScheduleForRemoval() { if (mRefCount>0) mRefCount = -mRefCount; }
  bool ScheduledForRemoval() const { return mRefCount<0; }
  void Unref() {
    if (mRefCount > 0)
      mRefCount--;
    else
      if (mRefCount < 0)
                mRefCount++;
      else {
                cerr<<"Trying to unref already deleted ray!"<<endl;
                exit(1);
      }
  }

  static Vector3
  GetDirection(const float a, const float b) {
        return Vector3(sin(a), sin(b), cos(a));
  }

};

void
GenerateExtendedConvexCombinationWeights(float &w1,
                                                                                 float &w2,
                                                                                 float &w3,
                                                                                 const float overlap
                                                                                 );

// --------------------------------------------------------------
// For sorting rays
// --------------------------------------------------------------
struct  SortableEntry
{
  enum EType {
    ERayMin,
    ERayMax
  };

  int type;
  float value;
  void *data;
  
  SortableEntry() {}
  SortableEntry(const int t, const float v, void *d):type(t),
                                                                                                         value(v),
                                                                                                         data(d) {}
        
  friend bool operator<(const SortableEntry &a, const SortableEntry &b) {
    return a.value < b.value;
  }
};

typedef  vector<VssRay *> VssRayContainer;



#endif