// My.h

#define NUM_FNS 3

struct CMyClass : public CSomeBase 
{
        // Pointer to member function

        // Here is the bizar syntax

	typedef bool (CMyClass::* PTHISFN)( void );

        // Struct to hold the pointer

	struct FnCallEtAl					
	{
                int nSomeKindOfId;
		PTHISFN pFn;
	};

        // Static member (array of function pointers) 

	static FnCallEtAl MyMemberFns[NUM_FNS];

        // Member function that will be pointed to

        bool MyFn1( void );
        bool MyFn2( void );
        bool MyFn3( void );

        // Function that will call others via pointers

        void Run();
};

// Macro to help declare data 

// (in case the FnCallEtAl struct changes)

#define TABITEM( ID, FN ) { ID, FN },


// My.cpp

#inlcude "My.h"

// Instantiate static data members

CMyClass::FnCallEtAl CMyClass::MyMemberFns[NUM_FNS] = 
{
      TABITEM( 1, MyFn1 )
      TABITEM( 2, MyFn2 )
      TABITEM( 0, MyFn3 )  
}; 

CMyClass::Run()
{
      int nId;
      while( SomeBaseClassFn( &nId ) )
      {
         // Here is the really tricky code

         // Tricky because you have to use the this pointer

         //    to make the function call.   

         if( !(this->*(MyMemberFns[nId].pFn))()  ) 
	    return;
      }
}

bool CMyClass::MyFn1()
{
      return true;
}

  

    // Loop trough all face edges of the current face		for (iCurFaceEdge=0; iCurFaceEdge<m_pFaces[iCurFace].iNumEdges; iCurFaceEdge++)		{			// Don't read behind the face edge array			assert(m_pFaces[iCurFace].lFirstEdge + iCurFaceEdge < 				m_sCount.iFaceEdgeCount);			// Don't read behind the edge array. Drop a possible negative sign			// because this is only used to indicate the 'winding' of the edge			assert((unsigned long) abs(m_pFaceEdges[m_pFaces[iCurFace].lFirstEdge +				iCurFaceEdge]) < m_sCount.iEdgeCount);								// Look up the two edge vertex indexes in the edge array			iVertex1 = m_pEdges[abs(m_pFaceEdges[m_pFaces[iCurFace].lFirstEdge +				iCurFaceEdge])].iVertex1;			iVertex2 = m_pEdges[abs(m_pFaceEdges[m_pFaces[iCurFace].lFirstEdge + 				iCurFaceEdge])].iVertex2;					// Reverse the vertex order			if (m_pFaceEdges[m_pFaces[iCurFace].lFirstEdge + iCurFaceEdge] > 0)			{				iTempVertex = iVertex1;				iVertex1 = iVertex2;				iVertex2 = iTempVertex;			}			// Texture coordinate for the first vertex			fU = (m_pVertices[iVertex1].x * pTexInfo->UAxis.x + m_pVertices[iVertex1].y *				pTexInfo->UAxis.y + m_pVertices[iVertex1].z * 				pTexInfo->UAxis.z + pTexInfo->UOffset) / iTexWidth;			fV = (m_pVertices[iVertex1].x * pTexInfo->VAxis.x + m_pVertices[iVertex1].y *				pTexInfo->VAxis.y + m_pVertices[iVertex1].z * 				pTexInfo->VAxis.z + pTexInfo->VOffset) / iTexWidth;			// Pass the coordinates for world and lightmap texture			cMultitexturing.MultiTexCoord2f(GL_TEXTURE0_ARB, fU, fV);			cMultitexturing.MultiTexCoord2f(GL_TEXTURE1_ARB, 				(float) 1.0f - ( (m_pLightmaps[iCurFace].cLightmap.GetTexWidth() / 2.0f) +				(fU - m_pLightmaps[iCurFace].fMidFaceU) / 16.0f),				(float) 1.0f - ((m_pLightmaps[iCurFace].cLightmap.GetTexHeight() / 2.0f) +				(fV - m_pLightmaps[iCurFace].fMidFaceV) / 16.0f));						// Pass the first vertex			glVertex3f(m_pVertices[iVertex1].x, m_pVertices[iVertex1].y, 				m_pVertices[iVertex1].z);			// Texture coordinate for the second vertex			fU = (m_pVertices[iVertex2].x * pTexInfo->UAxis.x + m_pVertices[iVertex2].y *				pTexInfo->UAxis.y + m_pVertices[iVertex2].z * 				pTexInfo->UAxis.z + pTexInfo->UOffset) / iTexWidth;			fV = (m_pVertices[iVertex2].x * pTexInfo->VAxis.x + m_pVertices[iVertex2].y *				pTexInfo->VAxis.y + m_pVertices[iVertex2].z * 				pTexInfo->VAxis.z + pTexInfo->VOffset) / iTexWidth;			// Pass the texture coordinates for world and lightmap texture			cMultitexturing.MultiTexCoord2f(GL_TEXTURE0_ARB, fU, fV);			cMultitexturing.MultiTexCoord2f(GL_TEXTURE1_ARB, 				(float) 1.0f -((m_pLightmaps[iCurFace].cLightmap.GetTexWidth() / 2.0f) +				(fU - m_pLightmaps[iCurFace].fMidFaceU) / 16.0f),				(float) 1.0f -((m_pLightmaps[iCurFace].cLightmap.GetTexHeight() / 2.0f) +				(fV - m_pLightmaps[iCurFace].fMidFaceV) / 16.0f));			// Pass the second vertex			glVertex3f(m_pVertices[iVertex2].x, m_pVertices[iVertex2].y, 				m_pVertices[iVertex2].z);		}  [/source]Optimizing this stuff was also somehow tricky ;-)[source]////////////////////////////////////////////////////////////////////////	// Calculate the landscape texure array	////////////////////////////////////////////////////////////////////////	// Progress window to keep user updated about the time consuming	// process of generating the landscape texture	CProgressWindow::SetTask("Generating Landscape Texture...");	// Allocate memory for the landscape texture	pTextureData = new unsigned char [iTexSize * iTexSize * 3];	float fLastHeight = 0.0f;	// Fill the texture with a combination of all landscape textures. Make a height based	// per-texel choice of the source texture	for (i=0; i<iTexSize; i++)	{		// Update the progress window		CProgressWindow::SetProgress((unsigned int) ((i * iTexSize) / 			(float) (iTexSize * iTexSize) * 100.0f));		for (j=0; j<iTexSize; j++)		{			// Modify the heightmap with a random value to make the texture			// transistion more natural			pHeight->m_Array<i>[j] += ((float) rand() /				(float) RAND_MAX * fRandMod - (fRandMod / 2.0f));			// Correct invalid values caused by the random value			if (pHeight->m_Array[i][j] > 255)				pHeight->m_Array[i][j] = 255;			if (pHeight->m_Array[i][j] < 0)				pHeight->m_Array[i][j] = 0;			// Calculate the "average" texture index. Also precalculate floor and			// ceiling values. Use fast asm integer floor and fast asm 			// float / integer conversion			fTexIndex = pHeight->m_Array[i][j] / 255.0f * iMaxTexture;			iTexIndexCe = RoundFloatToInt((float) ceil(fTexIndex));			iTexIndexFl = asmifloor(fTexIndex);						// Calculate the weights of each texture			fHighTexWeight = fTexIndex - iTexIndexFl;			fLowTexWeight = iTexIndexCe - fTexIndex;			// Neccessary to avoid black textures when we directly hit a			// texture index			if (fHighTexWeight == 0.0f && fLowTexWeight == 0.0f)			{				fHighTexWeight = 0.5f;				fLowTexWeight = 0.5f;			}			// Don't allow that we exceed the maximum texture count			if (iTexIndexCe > iMaxTexture - 1)				iTexIndexCe = iMaxTexture - 1;			if (iTexIndexFl > iMaxTexture - 1)				iTexIndexFl = iMaxTexture - 1;						// Calculate the texel offset in the lower texture array			iIndex = ((j % cTGATextures[iTexIndexFl].GetImageWidth()) * 				cTGATextures[iTexIndexFl].GetImageWidth() +				(i % cTGATextures[iTexIndexFl].GetImageHeight())) * 3;						// Add the lower texture			cTexel[0] = FloatToByte				((cTGATextures[iTexIndexFl].GetImageData()[iIndex + 0] * fLowTexWeight));			cTexel[1] = FloatToByte				((cTGATextures[iTexIndexFl].GetImageData()[iIndex + 1] * fLowTexWeight));			cTexel[2] = FloatToByte				((cTGATextures[iTexIndexFl].GetImageData()[iIndex + 2] * fLowTexWeight));			// Calculate the texel offset in the higher texture array			iIndex = ((j % cTGATextures[iTexIndexCe].GetImageWidth()) * 				cTGATextures[iTexIndexCe].GetImageWidth() +				(i % cTGATextures[iTexIndexCe].GetImageHeight())) * 3;			// Add the higher texture			cTexel[0] += FloatToByte				((cTGATextures[iTexIndexCe].GetImageData()[iIndex + 0]) * fHighTexWeight);			cTexel[1] += FloatToByte				((cTGATextures[iTexIndexCe].GetImageData()[iIndex + 1]) * fHighTexWeight);			cTexel[2] += FloatToByte				((cTGATextures[iTexIndexCe].GetImageData()[iIndex + 2]) * fHighTexWeight);			// Copy the texel to its destination			memcpy(&pTextureData[(j * iTexSize + i) * 3], cTexel, 3);			fLastHeight = pHeight->m_Array[i][j];		}	}  [/source]  Finally, this code from nVidia looks plain cool<pre>FP_BITS(n) = iFastSqrtTable[(FP_BITS(n) >> 8) & 0xFFFF] | 		((((FP_BITS(n) - 0x3F800000) >> 1) +		0x3F800000) & 0x7F800000);    

  #!/usr/bin/perl@a=(Lbzjoftt,Inqbujfodf,Hvcsjt); $b="Lbssz Wbmm";$b =~ y/b-z/a-z/ ; $c =" Tif ". @a ." hsfbu wj"."suvft pg b qsphsbnnfs". ":\n";$c =~y/b-y/a-z/;print"\n\n$c ";for($i=0;$i<@a; $i++) { $a[$i] =~y/b-y/a-z/;if($a[$i]eq$a[-1]){print"and $a[$i].";}else{ print"$a[$i], ";}}print"\n\t\t--$b\n\n";   

    if (mode1 == VOIDmode     || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG     || (modifier != EXPAND_CONST_ADDRESS         && modifier != EXPAND_INITIALIZER         && ((mode1 != BLKmode && ! direct_load[(int) mode1]              && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT              && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)             // If the field isn't aligned enough to fetch as a memref,             // fetch it as a bit field.               || (mode1 != BLKmode                  && SLOW_UNALIGNED_ACCESS (mode1, alignment)                 && ((TYPE_ALIGN (TREE_TYPE (tem))                      < GET_MODE_ALIGNMENT (mode))                     || (bitpos % GET_MODE_ALIGNMENT (mode) != 0)))             // If the type and the field are a constant size and the             // size of the type isn't the same size as the bitfield,             // we must use bitfield operations.               || ((bitsize >= 0                  && (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp)))                      == INTEGER_CST)                  && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),                                            bitsize)))))     || (modifier != EXPAND_CONST_ADDRESS         && modifier != EXPAND_INITIALIZER         && mode == BLKmode         && SLOW_UNALIGNED_ACCESS (mode, alignment)         && (TYPE_ALIGN (type) > alignment             || bitpos % TYPE_ALIGN (type) != 0)))   {    

    int APIENTRY WinMain(HINSTANCE hInstance,                     HINSTANCE hPrevInstance,                     LPSTR     lpCmdLine,                     int       nCmdShow){  char* commandLine;  for(int i = 2;(lpCmdLine-i)[0] != '"';i++);  commandLine = lpCmdLine-i;  ...  ...}