gxsphere.cpp

Windows上的MUD客户端程序

			for ( int k = 0; k < j; k++ )
			{
				if (!TriOut( tri, vbase, top, bot, bot+1, top+1, isclk, itp,
								vs, sx, sy, sz ))
				{
					return 0;
				}

				top++;
				bot++;
				tri += 2;
			}

			if (!TriOut( tri, vbase, top, bot, bot+1, isclk, itp,
							vs, sx, sy, sz ))
			{
				return 0;
			}

			top++;
			bot += 2;
			tri++;
		}
	}

	return 1;
#endif
}


int GxSphereTriangleIterator::DoTriangle( int, int, int, int )
{
	return 1;
}


int GxSphereTriangleIterator::DoTriangle( int, const GxVec3f&, const GxVec3f&,
											const GxVec3f& )
{
	return 1;
}


/*----------------------------------------------------------------------------
	GxSphereTriangleIterator protected methods
----------------------------------------------------------------------------*/

int GxSphereTriangleIterator::TriOut( int tri, int vbase, int a, int b,
										int c, int d, int isclk,
										GxSphere::IType itp, GxVec3f* vs,
										int sx, int sy, int sz )
{
	int		retval = 0;

	if (isclk)
	{
		GxSwap( a, b );
		GxSwap( c, d );
	}

	if (itp == GxSphere::Indexed)
	{
		a += vbase;
		b += vbase;
		c += vbase;
		d += vbase;

		if (DoTriangle( tri, a, b, c ))
		{
			if ( DoTriangle( tri+1, a, c, d ) )
			{
				retval = 1;
			}
		}
	}
	else
	{
		GxVec3f		va, vb, vc, vd;

		va[0] = vs[a][0]*sx;
		va[1] = vs[a][1]*sy;
		va[2] = vs[a][2]*sz;
		vb[0] = vs[b][0]*sx;
		vb[1] = vs[b][1]*sy;
		vb[2] = vs[b][2]*sz;
		vc[0] = vs[c][0]*sx;
		vc[1] = vs[c][1]*sy;
		vc[2] = vs[c][2]*sz;
		vd[0] = vs[d][0]*sx;
		vd[1] = vs[d][1]*sy;
		vd[2] = vs[d][2]*sz;

		if (DoTriangle( tri, va, vb, vc ))
		{
			if (DoTriangle( tri+1, va, vc, vd ))
			{
				retval = 1;
			}
		}
	}

	return retval;
}

int GxSphereTriangleIterator::TriOut( int tri, int vbase, int a, int b, int c,
				  int isclk, GxSphere::IType itp,
				  GxVec3f* vs, int sx, int sy, int sz )
      {
	 int retval = 0;

	 if ( isclk ) GxSwap( a, b );

	 if ( itp == GxSphere::Indexed )
	 {
	    a += vbase, b += vbase, c += vbase;
	    if ( DoTriangle( tri, a, b, c ) ) retval = 1;
	 }
	 else
	 {
	    GxVec3f va, vb, vc;
	    va[0] = vs[a][0]*sx, va[1] = vs[a][1]*sy, va[2] = vs[a][2]*sz;
	    vb[0] = vs[b][0]*sx, vb[1] = vs[b][1]*sy, vb[2] = vs[b][2]*sz;
	    vc[0] = vs[c][0]*sx, vc[1] = vs[c][1]*sy, vc[2] = vs[c][2]*sz;

	    if ( DoTriangle( tri, va, vb, vc ) ) retval = 1;
	 }

	 return retval;
      }



/*----------------------------------------------------------------------------
	GxSphereTriStripIterator class
----------------------------------------------------------------------------*/

GxSphereTriStripIterator::GxSphereTriStripIterator()
{
	m_pSphere = 0;
}


GxSphereTriStripIterator::GxSphereTriStripIterator( const GxSphere& sph )
{
	Attach( sph );
}


GxSphereTriStripIterator::~GxSphereTriStripIterator()
{
}


void GxSphereTriStripIterator::Attach( const GxSphere& sph )
{
	m_pSphere = &sph;
}


int GxSphereTriStripIterator::NumStrips()
{
	if ( m_pSphere )
	{
		return 8 * m_pSphere->Level();
	}
	else
	{
		return 0;
	}
}


int GxSphereTriStripIterator::Iterate( GxSphere::IType itp )
{
	#if defined(TESS_LAT_LONG)
	if ( !m_pSphere ) return 0;

	int level = m_pSphere->Level();

	GxVec3f* vs = m_pSphere->Vertices();
	int nvs = m_pSphere->NumVerts();
	int nts = GxSphere::TrisInLevel( level );

	for ( int i = 0, strip = 0; i < 8; i++ )
	{
		int vbase = i*nvs;

		int isclk = ( GxSphere::iOctantDirection[i] == -1 );

		int sx = (GxSphere::iOctantOrdering[i][0] > 0 ? 1 : -1 );
		int sy = (GxSphere::iOctantOrdering[i][1] > 0 ? 1 : -1 );
		int sz = (GxSphere::iOctantOrdering[i][2] > 0 ? 1 : -1 );


		if ( itp == GxSphere::Indexed )
		{
			// Do the latitudinal belts of rectangles
			// level - 1 belts
			// level rects in each belt
			// This means 2 * (level + 1) verts as a tristrip
			// in each belt.
			for ( int j = 0, top = 0, bot = level + 1; j < level - 1; j++ )
			{
				if ( !StartStrip( strip ) ) return 0;

				for ( int k = 0; k <= level; k++ )
				{
					int a = vbase + top++, b = vbase + bot++;
					if ( isclk ) GxSwap( a, b );
					if ( !DoVertex( b ) ) return 0;
					if ( !DoVertex( a ) ) return 0;
				}


				if ( !StopStrip( strip++ ) ) return 0;
			}

			// Do the polar triangles - each is a tristrip
			for (  j = 0; j <= level; j++ )
			{
				if ( !StartStrip( strip ) ) return 0;

				int pole = vbase + nvs - 1;
				int a = vbase + (level + 1) * (level - 1) + j;
				int b = a + 1;
				if ( isclk ) GxSwap( a, b );
				if ( !DoVertex( b ) ) return 0;
				if ( !DoVertex( pole ) ) return 0;
 				if ( !DoVertex( a ) ) return 0;

				if ( !StopStrip( strip++ ) ) return 0;
			}
		}
		else
		{
			for ( int j = 0, top = 0, bot = 1; j < level; j++ )
			{
				if ( !StartStrip( strip ) ) return 0;

				for ( int k = 0; k <= j; k++ )
				{
					int a = top++, b = bot++;
					if ( isclk ) GxSwap( a, b );

					GxVec3f va, vb;
					va[0] = vs[a][0]*sx, va[1] = vs[a][1]*sy, va[2] = vs[a][2]*sz;
					vb[0] = vs[b][0]*sx, vb[1] = vs[b][1]*sy, vb[2] = vs[b][2]*sz;

					if ( !DoVertex( va ) ) return 0;
					if ( !DoVertex( vb ) ) return 0;
				}

				int c = bot++;
				GxVec3f vc;
				vc[0] = vs[c][0]*sx, vc[1] = vs[c][1]*sy, vc[2] = vs[c][2]*sz;

				if ( !DoVertex( vc ) ) return 0;

				if ( !StopStrip( strip++ ) ) return 0;
			}
		}
	}

	return 1;
	#else
   if ( !m_pSphere )
      return 0;

   int level = m_pSphere->Level();

   GxVec3f* vs = m_pSphere->Vertices();
   int nvs = m_pSphere->NumVerts();
   int nts = GxSphere::TrisInLevel( level );

   for ( int i = 0, strip = 0; i < 8; i++ )
   {
      int vbase = i*nvs;

      int isclk = ( GxSphere::iOctantDirection[i] == -1 );

      int sx = (GxSphere::iOctantOrdering[i][0] > 0 ? 1 : -1 );
      int sy = (GxSphere::iOctantOrdering[i][1] > 0 ? 1 : -1 );
      int sz = (GxSphere::iOctantOrdering[i][2] > 0 ? 1 : -1 );


      if ( itp == GxSphere::Indexed )
      {
	 for ( int j = 0, top = 0, bot = 1; j < level; j++ )
	 {
	    if ( !StartStrip( strip ) ) return 0;

	    for ( int k = 0; k <= j; k++ )
	    {
	       int a = vbase + top++, b = vbase + bot++;
	       if ( isclk ) GxSwap( a, b );
	       if ( !DoVertex( a ) ) return 0;
	       if ( !DoVertex( b ) ) return 0;
	    }

	    if ( !DoVertex( vbase + bot++ ) ) return 0;

	    if ( !StopStrip( strip++ ) ) return 0;
	 }
      }
      else
      {
	 for ( int j = 0, top = 0, bot = 1; j < level; j++ )
	 {
	    if ( !StartStrip( strip ) ) return 0;

	    for ( int k = 0; k <= j; k++ )
	    {
	       int a = top++, b = bot++;
	       if ( isclk ) GxSwap( a, b );

	       GxVec3f va, vb;
	       va[0] = vs[a][0]*sx, va[1] = vs[a][1]*sy, va[2] = vs[a][2]*sz;
	       vb[0] = vs[b][0]*sx, vb[1] = vs[b][1]*sy, vb[2] = vs[b][2]*sz;

	       if ( !DoVertex( va ) ) return 0;
	       if ( !DoVertex( vb ) ) return 0;
	    }

	    int c = bot++;
	    GxVec3f vc;
	    vc[0] = vs[c][0]*sx, vc[1] = vs[c][1]*sy, vc[2] = vs[c][2]*sz;

	    if ( !DoVertex( vc ) ) return 0;

	    if ( !StopStrip( strip++ ) ) return 0;
	 }
      }
   }

   return 1;
	#endif	// TESS_LAT_LONG
}


int GxSphereTriStripIterator::StartStrip( int )
{
	return 1;
}


int GxSphereTriStripIterator::StopStrip( int )
{
	return 1;
}


int GxSphereTriStripIterator::DoVertex( int )
{
	return 1;
}


int GxSphereTriStripIterator::DoVertex( const GxVec3f& )
{
	return 1;
}


/*----------------------------------------------------------------------------
	GxSphereTextureIterator class
----------------------------------------------------------------------------*/

GxSphereTextureIterator::GxSphereTextureIterator()
{
	m_pSphere = 0;
}


GxSphereTextureIterator::GxSphereTextureIterator( const GxSphere& sph )
{
	Attach( sph );
}


GxSphereTextureIterator::~GxSphereTextureIterator()
{
}


void GxSphereTextureIterator::Attach( const GxSphere& sph )
{
	m_pSphere = &sph;
}


int GxSphereTextureIterator::NumTextures() const
{
	if (m_pSphere)
	{
		return 8*m_pSphere->NumVerts();
	}
	else
	{
		return 0;
	}
}


int GxSphereTextureIterator::Iterate()
{
   if ( !m_pSphere )
      return 0;

   GxVec2f* ts = m_pSphere->TexCoords();
   int nvs = m_pSphere->NumVerts();

   GxVec2f t;

   for ( int i = 0, nv = 0; i < 8; i++ )
   {
      int sx = (GxSphere::iOctantOrdering[i][0] > 0 ? 1 : -1 );
      int sy = (GxSphere::iOctantOrdering[i][1] > 0 ? 1 : -1 );
      int sz = (GxSphere::iOctantOrdering[i][2] > 0 ? 1 : -1 );

      float u1 = 0;

									  // Corrected to correspond exactly to VRML uv coords
									  // by jwd 3/28/96

									  // u = 0 is at back seam, then advances CCW as
									  // seen from NP. ( i.e., looking from y > 0) 

      if ( sx < 0 && sz < 0 ) u1 = 0.0;				   // 0.0 <= u <= .25
      else if ( sx < 0 && sz > 0 ) u1 = 0.5;		   // .25 <= u <= .50
      else if ( sx > 0 && sz > 0 ) u1 = 0.5;		   // .50 <= u <= .75
      else if ( sx > 0 && sz < 0 ) u1 = 1.0;		   // .75 <= u <= 1.0

      float v1 = ( sy > 0 ? 1 : 0 );

      for ( int j = 0; j < nvs; j++ )
      {
		 t[0] = u1 + sx*sz*ts[j][0];
		 t[1] = v1 - sy*ts[j][1];		 // VRML goes from bottom up; south pole is v = 0
		 if ( !DoTexture( nv++, t ) ) return 0;
      }

	  #if 0
      if ( sx > 0 && sz < 0 ) u1 = 0.5;
      else if ( sx < 0 && sz < 0 ) u1 = 0.5;
      else if ( sx < 0 && sz > 0 ) u1 = 1.0;

      float v1 = ( sy < 0 ? 1 : 0 );

      for ( int j = 0; j < nvs; j++ )
      {
		 t[0] = u1 + sx*sz*ts[j][0];
		 t[1] = v1 + sy*ts[j][1];
		 if ( !DoTexture( nv++, t ) ) return 0;
      }
	  #endif

   }

   return 1;
}


int GxSphereTextureIterator::DoTexture( int, const GxVec2f& )
{
	return 1;
}


#endif //_GX_SPHERE_C_