SplitPat.h

Go to the documentation of this file.

// MH  22 Jan 2003

#define __SPLITPAT_H

#ifndef __VECTOR_H
#include "Vector.h"
#endif
#ifndef __VECTOR2_H
#include "Vector2.h"
#endif
#ifndef __EXPORTS_H
#include "Exports.h"
#endif

#define FLAT0               0x00000001
#define FLAT1               0x00000002
#define FLAT2               0x00000004
#define FLAT3               0x00000008
#define NOTFIRSTVERTICAL    0x00000010
#define NOTFIRSTHORIZONTAL  0x00000020
#define NEEDSFLAT0          0x00000040
#define NEEDSFLAT1          0x00000080
#define NEEDSFLAT2          0x00000100
#define NEEDSFLAT3          0x00000200
#define FIRSTFLATTESTVERTICAL   0x00000400
#define FIRSTFLATTESTHORIZONTAL 0x00000800

#define IsFlat0(a) (a&FLAT0)
#define IsFlat1(a) (a&FLAT1)
#define IsFlat2(a) (a&FLAT2)
#define IsFlat3(a) (a&FLAT3)

#define OnFlat0(a) (a|=FLAT0)
#define OnFlat1(a) (a|=FLAT1)
#define OnFlat2(a) (a|=FLAT2)
#define OnFlat3(a) (a|=FLAT3)

#define IsNeedsFlat0(a) (a&NEEDSFLAT0)
#define IsNeedsFlat1(a) (a&NEEDSFLAT1)
#define IsNeedsFlat2(a) (a&NEEDSFLAT2)
#define IsNeedsFlat3(a) (a&NEEDSFLAT3)

#define OnNeedsFlat0(a) (a|=NEEDSFLAT0)
#define OnNeedsFlat1(a) (a|=NEEDSFLAT1)
#define OnNeedsFlat2(a) (a|=NEEDSFLAT2)
#define OnNeedsFlat3(a) (a|=NEEDSFLAT3)

#define OffNeedsFlat0(a) (a&=~NEEDSFLAT0)
#define OffNeedsFlat1(a) (a&=~NEEDSFLAT1)
#define OffNeedsFlat2(a) (a&=~NEEDSFLAT2)
#define OffNeedsFlat3(a) (a&=~NEEDSFLAT3)

/*
SplitPatch vertex ordering

1 5  9 13
2 6 10 14
3 7 11 15
4 8 12 16

*/

class SplitPatch 
{
public:
   Vector  m_p1, m_p4, m_p16, m_p13,  // Four corners for poly, CCW
           m_p2, m_p3,  m_p5,  m_p8,  // Tangents
           m_p9, m_p12, m_p14, m_p15; // Tangents
   Vector  m_n[4];
   Vector2 m_uv[4];
   union {
      DWORD      m_flags;
      struct {
         DWORD   m_edge0isdiscontinuous      : 1, // used to average normals rather than compute, hides anomolies (Caused by 5 point patches, Hooks)
                 m_edge1isdiscontinuous      : 1, // used to average normals rather than compute, hides anomolies (Caused by 5 point patches, Hooks)
                 m_edge2isdiscontinuous      : 1, // used to average normals rather than compute, hides anomolies (Caused by 5 point patches, Hooks)
                 m_edge3isdiscontinuous      : 1, // used to average normals rather than compute, hides anomolies (Caused by 5 point patches, Hooks)
                 m_is3point                  : 1, // m_p1 == m_p13 or m_vertexid[0] == m_vertexid[3]
                 m_edge0forcesplit           : 2, // Forces edge 0 to be split because it is shared with a hook
                 m_edge1forcesplit           : 2, // Forces edge 1 to be split because it is shared with a hook
                 m_edge2forcesplit           : 2, // Forces edge 2 to be split because it is shared with a hook
                 m_edge3forcesplit           : 2; // Forces edge 3 to be split because it is shared with a hook
      };
   };

   SplitPatch() { m_flags = 0L;}
   void SetVertices(const Vector &v0, const Vector &v1, const Vector &v2, const Vector &v3,
    const Vector &t0, const Vector &t1, const Vector &t2, const Vector &t5,
    const Vector &t6, const Vector &t9, const Vector &t10, const Vector &t11);
   void SetNormals(const Vector &n0, const Vector &n1, const Vector &n2, const Vector &n3);
   void SetUVs(const Vector2 &uv0, const Vector2 &uv1, const Vector2 &uv2, const Vector2 &uv3);
   void SetEdge0ForceSplit() { m_edge0forcesplit = 2; }
   void SetEdge1ForceSplit() { m_edge1forcesplit = 2; }
   void SetEdge2ForceSplit() { m_edge2forcesplit = 2; }
   void SetEdge3ForceSplit() { m_edge3forcesplit = 2; }
};

inline void SplitPatch::SetVertices(const Vector &v0, const Vector &v1, const Vector &v2, const Vector &v3,
    const Vector &t0, const Vector &t1, const Vector &t2, const Vector &t5,
    const Vector &t6, const Vector &t9, const Vector &t10, const Vector &t11) {
   m_p1 = v0;
   m_p2 = t0;
   m_p3 = t1;
   m_p4 = v1;
   m_p5 = t2;
   m_p8 = t5;
   m_p9 = t6;
   m_p12 = t9;
   m_p13 = v3;
   m_p14 = t10;
   m_p15 = t11;
   m_p16 = v2;
};

inline void SplitPatch::SetNormals(const Vector &n0, const Vector &n1, const Vector &n2, const Vector &n3) 
{
   m_n[0] = n0;
   m_n[1] = n1;
   m_n[2] = n2;
   m_n[3] = n3;
};

inline void SplitPatch::SetUVs(const Vector2 &uv0, const Vector2 &uv1, const Vector2 &uv2, const Vector2 &uv3) 
{
   m_uv[0] = uv0;
   m_uv[1] = uv1;
   m_uv[2] = uv2;
   m_uv[3] = uv3;
};

class PATCHEXPORT PatchSplitter
{
public:
   union { 
      DWORD  m_flags;
      struct {
         DWORD m_isuvs            : 1, // compute new UV
               m_isnormals        : 1, // compute normals
               m_0or1uvs          : 1, // UV range from 0 to 1, settings this will speed up UV calculations
               m_isvariable       : 1, // variable versus fixed sub
               m_is3point         : 1, // patch is 3 point patch, must set this ahead of time V0 == V3
               m_iscullbackfacing : 1; // CULL backfacing polys

      };
   };
   float m_straight,   // subdivision tolerance when variable patch splitting
         m_zoom,       // zoom projection, used to determine how large patch is to test flatness
         m_viewplane,  // -focallength for perspective
         m_hither;     // used for perspective flatness testing to determine zoomfactor
   int   m_maxlevel;   // levels to fix subdivide the patch, a value of 2 will 
                       // split a patch both Horiz and Vert giving 4 polys.

   PatchSplitter() { 
      m_flags = 0;
      m_maxlevel = 0; 
      m_isnormals = TRUE;
      m_straight = 6.0f;
      m_zoom = 1.0f;
      m_isvariable = TRUE;
      m_viewplane = 0;
      m_hither = -1.0f;
      m_iscullbackfacing = TRUE;
   }

   void Subdivide( SplitPatch &splitpatch, DWORD flatflags = 0 ) { SplitSubPatch( splitpatch, 0, flatflags ); }
   virtual void SubdivideCallback(SplitPatch &patch)=0;
   float Flatness( Vector &p0, Vector &p1, Vector &p2, Vector &p3 );
   float FlatnessFirst( Vector &p0, Vector &p1, Vector &p2, Vector &p3);

private:
   void SplitSubPatch( SplitPatch &patch, int level, LONG flatflags );
   void SubSplitHorizontal( SplitPatch &patch, int level, LONG flatflags );
   void SubSplitVertical( SplitPatch &patch, int level, LONG flatflags );
};

inline void CalcTangent( Vector &p0, Vector &p1, Vector &p2, Vector &p3, Vector &t )
{
   t = .75 * (-p0 - p1 + p2 + p3);
}

inline float PatchSplitter::Flatness( Vector &p0, Vector &p1, Vector &p2, Vector &p3 )
{
   float screenzoom;
   if (m_viewplane) {
      float closesz = min(m_hither, max(p0.z, max(p1.z, max(p2.z, p3.z))));
      screenzoom = m_zoom * m_viewplane/closesz;
   }
   else
      screenzoom = m_zoom;

   Vector height;
   height.x = 3*(p0.x - p1.x - p2.x + p3.x);
   height.y = 3*(p0.y - p1.y - p2.y + p3.y);
   height.z = 3*(p0.z - p1.z - p2.z + p3.z);

   return height.Norm() * screenzoom;
}

inline float PatchSplitter::FlatnessFirst( Vector &p0, Vector &p1, Vector &p2, Vector &p3)
{
   float screenzoom;
   if (m_viewplane) {
      float closesz = min(m_hither, max(p0.z, max(p1.z, max(p2.z, p3.z))));
      screenzoom = m_zoom * m_viewplane/closesz;
   }
   else
      screenzoom = m_zoom;

   Vector temp;
   temp.x = 4*p0.x - 6*p1.x + 2*p3.x; // at 1/3
   temp.y = 4*p0.y - 6*p1.y + 2*p3.y; // at 1/3
   temp.z = 4*p0.z - 6*p1.z + 2*p3.z; // at 1/3

   float height;
   if ((height = temp.Norm() * screenzoom) > m_straight)
      return height;

   temp.x = 2*p0.x - 6*p2.x + 4*p3.x; // at 2/3
   temp.y = 2*p0.y - 6*p2.y + 4*p3.y; // at 2/3
   temp.z = 2*p0.z - 6*p2.z + 4*p3.z; // at 2/3
   return temp.Norm() * screenzoom;
}

inline void MakeFlat( Vector &p0, Vector &p1, Vector &p2, Vector &p3 )
{
   float length;

   Vector delta = p3;
   delta -= p0;
   
   if ((length = delta.Norm()) == 0) {
      p1 = p0;
      p2 = p3;
      return;
   }
   delta /= length;
   p1 -= p0;
   p2 -= p3;
   p1 = p0+ delta * p1.Norm();
   p2 = p3+ delta * -p2.Norm();
}

inline void MakeFlat5( Vector &p0, Vector &p1, Vector &p2, Vector &p3, Vector &p4, Vector &p5, Vector &p6, Vector &p7)
{
   float length;

   Vector delta = p7;
   delta -= p0;
   
   if ((length = delta.Norm()) == 0) {
      p1 = p0;
      p2 = p0;
      p3 = p0;
      p4 = p3;
      p5 = p7;
      p6 = p7;
      return;
   }
   delta /= length;
   p1 -= p0;
   p2 -= p0;
   p3 -= p0;

   p5 -= p7;
   p6 -= p7;
   p1 = p0 + delta * p1.Norm();
   p2 = p0 + delta * p2.Norm();
   p3 = p0 + delta * p3.Norm();
   p4 = p3;
   p5 = p7 + delta * -p5.Norm();
   p6 = p7 + delta * -p6.Norm();
}

---