influenc.h

Go to the documentation of this file.

// Dan  5/26/2004  \iMac115\Include\influenc.h

#define __INFLUENC_H

#ifndef __ROBJECT_H
#include "RObject.h"
#endif
#ifndef __VECTOR_H
#include "Vector.h"
#endif
#ifndef __MATRIX34_H
#include "Matrix34.h"
#endif
#ifndef __MACROS_H
#include "Macros.h"
#endif

class QuadObject : public RObject {
public:
   float                smin, smax, tmin, tmax;

   void                 *operator new( size_t );

   BOOL                 IsPatch() { return TRUE;}
   int                  GetType() { return QUADRANGLE; }

   virtual void         Intersect( const Vector &, const Vector &, ThreadInfo * ) = 0;
   virtual void         Collision( ThreadInfo *, Vector &min, Vector &max ) = 0;
   virtual void         Normal( Hit &, Vector &, Vector & ) = 0;
};

class Quadrangle : public QuadObject {
public:
   Quadrangle::Quadrangle( Vector &p1, Vector &p2, Vector &p3,
    Vector &p4, float u1, float u2, float v1, float v4, int polyid );

   Vector       p[4];
   int          polyid;

   void         Intersect( const Vector &, const Vector &, ThreadInfo * );
   void         Bounds( Vector &min, Vector &max );
   void         Collision( ThreadInfo *, Vector &min, Vector &max );
   void         Normal( Hit &, Vector &, Vector & );
};

class FractalQuadrangle : public Quadrangle {
public:
   Vector               n1, n2, n3, n4;

//   FractalQuadrangle::FractalQuadrangle() {}
   FractalQuadrangle::FractalQuadrangle( Vector &, Vector &, Vector &,
    Vector &, float, float, float, float,
    Vector &, Vector &, Vector &, Vector &, int polyid );

   void                 Normal( Hit &, Vector &, Vector & );
};   

class PropQuadrangle : public QuadObject {
public:
   int                  m_vertexid[4], m_normalid[4];

   void                 Bounds( Vector *vertexlist, Vector &min, Vector &max );
   void                 Intersect( const Vector &, const Vector &, ThreadInfo * );
   void                 Collision( ThreadInfo *, Vector &min, Vector &max );

   virtual void         Normal( Hit &, Vector &, Vector & );
   int                  GetType() { return PROPQUADRANGLE; }
};   

class DisplaceQuadrangle : public FractalQuadrangle {
public:
   DisplaceQuadrangle( Vector &p1, Vector &p2, Vector &p3,
    Vector &p4, float smin, float smax, float tmin, float tmax,
    Vector &pn1, Vector &pn2, Vector &pn3, Vector &pn4, int polyid )
   : FractalQuadrangle( p1, p2, p3, p4, smin, smax, tmin, tmax, 
    pn1, pn2, pn3, pn4, polyid ) {}
    
   void                 Normal( Hit &, Vector &, Vector & );
};   

class Bone;

class InfluenceShape : public RObject {
public:
   Bone *bone;
   Matrix34 worldmatrix, worldinverse, screenmatrix, screeninverse, steadyscreenmatrix;
   float m_k0, m_k2, m_k1;

   void SetMatrices();

   InfluenceShape() {
     SetAttenuation(1.0f);
   }
   
   float GetAttenuation( float d )                  
   {                                                
      if ( d > 1.0f )                               
         return 1.0f / ( m_k0 + m_k1*d + m_k2*d*d );
      d = 6.0f - 5.0f * d;                          
      return -0.2f / ( m_k0 + m_k1*d + m_k2*d*d ) + 1.2f; 
   }                                                      

   void SetAttenuation( float attenuation ) 
   {
      m_k0 = (attenuation < 0.5f) ? 1.0f - attenuation * 2.0f : 0.0f;
      m_k2 = (attenuation > 0.5f) ? attenuation * 2.0f - 1.0f : 0.0f;
      m_k1 = 1.0f - MAX(m_k0, m_k2);
   }

   virtual float  Falloff( Vector ) = 0;
   virtual Vector Attract( Vector, float ) = 0;
   virtual Vector Vortex( Vector, Vector, float ) = 0;
   virtual Vector Friction( Vector, Vector, float ) = 0;
   virtual float  Lighting( const Vector &, Vector &, float & ) = 0;
   virtual float  LightingNoCap( const Vector &p ) {return 1.0f;}
   virtual void   Transform() = 0;
   virtual BOOL   IsInside( Vector p ) = 0;
   virtual void   FindBounds( Vector &min, Vector &max ) = 0;
};


#define K      .8
#define M      1.2
#define ALPHA  2

class RSphere : public InfluenceShape {
public:
   Vector   center;
   float    radius, radiussqr, falloffdistance, falloffdistancesqr,
             softfalloffdistance, falloffdistancedelta,
             S, beta, L; // variables for attenuation falloff

   RSphere() {}
   RSphere( float, float, float );

   void Init( float, float, float );

   void  Intersect( const Vector &, const Vector &, ThreadInfo * );
   BOOL  Intersect( const Vector &, const Vector &, Vector &, Vector & );
   void  Normal( Hit &, Vector &, Vector & );
   int   GetType() { return RSPHERE; }
   float Falloff( Vector );
   Vector Attract( Vector, float );
   Vector Vortex( Vector, Vector, float );
   Vector Friction( Vector, Vector, float );
   float Lighting( const Vector &, Vector &, float & );
   void  Transform();
   BOOL  IsInside( Vector p );
   void  FindBounds( Vector &min, Vector &max );
};

class Cone : public InfluenceShape {
public:
   Vector      base, axis, capbase;
   float       angle, halfangle, tanangle, tananglesqr, radius, endradius,
               deltaangle, cap, length, lengthsqr, costotalangle,
               softness, cossoftangle, falloffdistance, falloffdistancedelta,
               S, beta, L; // variables for attenuation falloff

   Cone( float, float, float, float, float );

   void Init( float, float, float, float, float );

   void  Intersect( const Vector &, const Vector &, ThreadInfo * );
   BOOL  Intersect( const Vector &, const Vector &, Vector &, Vector & );
   void  Normal( Hit &, Vector &, Vector & );
   int   GetType() { return RCONE; }
   float Falloff( Vector );
   Vector Attract( Vector, float );
   Vector Vortex( Vector, Vector, float );
   Vector Friction( Vector, Vector, float );
   float Lighting( const Vector &, Vector &, float & );
   float LightingNoCap( const Vector &p );
   void Transform();
   void Transform( const Matrix34 &screenmatrix );
   BOOL IsVisible( Vector, const Matrix34 &, float, float, float (*GetVolumetricZ)(int,int));
   BOOL  IsInside( Vector p );
   void  FindBounds( Vector &min, Vector &max );
};

class Cylinder : public InfluenceShape {
public:
   Vector               base, axis;
   float                radius, radiussqr, length, lengthsqr, radiusfalloffdistance,
                        softfalloffdistance, falloffdistancedelta, radiusfalloffdistancedelta,
                        S, beta, L; // variables for attenuation falloff

   Cylinder() {}
   Cylinder( float, float, float, float );

   void Init( float, float, float, float );

   void  Intersect( const Vector &, const Vector &, ThreadInfo * );
   BOOL  Intersect( const Vector &, const Vector &, Vector &, Vector & );
   void  Normal( Hit &, Vector &, Vector & );
   int   GetType() { return RCYLINDER; }
   float Falloff( Vector );
   Vector Attract( Vector, float );
   Vector Vortex( Vector, Vector, float );
   Vector Friction( Vector, Vector, float );
   float Lighting( const Vector &, Vector &, float & );
   void Transform();
   BOOL  IsInside( Vector p );
   void  FindBounds( Vector &min, Vector &max );
};

class Slab : public InfluenceShape {
public:
   Vector center, axis;
   float length, softlength, lengthdelta, halfwidth, softhalfwidth, halfwidthdelta;
   
   Slab() {}
   Slab( float, float, float, float );

   void Init( float, float, float, float );

   void  Intersect( const Vector &, const Vector &, ThreadInfo * );
   BOOL  Intersect( const Vector &, const Vector &, Vector &, Vector & );
   void  Normal( Hit &, Vector &, Vector & );
   int   GetType() { return RBOX; }
   float Falloff( Vector );
   Vector Attract( Vector, float );
   Vector Vortex( Vector, Vector, float );
   Vector Friction( Vector, Vector, float );
   float Lighting( const Vector &, Vector &, float & );
   void ComputeSides( Vector &, float, float, float );
   void Transform();
   BOOL  IsInside( Vector p );
   void  FindBounds( Vector &min, Vector &max );
};

BOOL IntersectEndCap( const Vector &eye, const Vector &d, const Vector &base,
 float radius, Vector &n, float &t, Vector &hitp );

---