procedural.c

国外游戏开发者杂志1997年第九期配套代码

if(Num_Pix == 1)    {
	  *(screen_buffer) = screen_buffer[-1];
	   turbulenceTbl[0] =  screen_buffer[-1];
	   return;
  } 

alignPixNum = (Num_Pix + 3) & 0xfffffffC;

memset(turbulenceTbl,0,sizeof(__int16) * alignPixNum);

MMX_Octave(u_init,     v_init, 
	                  du,         dv,
					  (alignPixNum >> 2), turbulenceTbl
					  ,num_octaves);

turbulenceTbl[0] = turbulenceTbl[1];

if(LIGHT && shader_perturb_method) 
     memcpy(onlyTurb,turbulenceTbl,sizeof(__int16)*Num_Pix);

MMX_Marb(u_init,du,alignPixNum);

} 
/******************************************************************************/
/* 
 woodPassMMX - similar to the marble function, calcs turbulence
 and then call to MMX_wood.
*/
/******************************************************************************/

#include <stdio.h>
void woodPassMMX(unsigned long u_init,  unsigned long v_init, 
			         long  du,     long dv,
	                 long Num_Pix, 
					 unsigned __int16 *screen_buffer)
{
static unsigned __int16   alignPixNum;

if(Num_Pix == 1)    {
	  *(screen_buffer) = screen_buffer[-1];
	   return;
  }

alignPixNum = (Num_Pix + 3) & 0xfffffffC;

memset(turbulenceTbl,0,sizeof(__int16) * alignPixNum);

MMX_Octave(u_init,     v_init, 
	                  du,         dv,
					  (alignPixNum >> 2), turbulenceTbl,
					  num_octaves);

alignPixNum =  (Num_Pix + 1) & 0xfffffffE;

turbulenceTbl[0] = turbulenceTbl[1];

MMX_Wood(u_init, v_init, 
		            du, dv, 
		            alignPixNum); 

}

/******************************************************************************/

/*
turbulencePass - scalar (marble texture) implementation
*/
/******************************************************************************/
void turbulencePass(unsigned long u_init , unsigned long v_init, 
			                     signed long  du			         , signed long dv,
							     long Num_Pix, 
					             unsigned __int16 *screen_buffer)
{
static unsigned __int16   alignPixNum , index , u_16bit  , marb_index;

if(Num_Pix == 1)    {
	  *(screen_buffer) = screen_buffer[-1];
	   return;
  }
	
alignPixNum = (Num_Pix + 3) & 0xfffffffC;

memset(turbulenceTbl,0,sizeof(__int16) * alignPixNum);

MMX_Octave(u_init,     v_init, 
	                  du,         dv,
					  (alignPixNum >> 2), turbulenceTbl
					  ,num_octaves);

turbulenceTbl[0] = turbulenceTbl[1];

if(LIGHT && shader_perturb_method) 
     memcpy(onlyTurb,turbulenceTbl,sizeof(__int16)*Num_Pix);

      for(index = 0; index < Num_Pix; index++) {
         u_16bit					   = (unsigned __int16)(u_init >> 14); 
         marb_index			      =  (u_16bit    + (10 * turbulenceTbl[index]));     // marble(x) = sine(x + turbulence (x))
	     marb_index              -=  1500;
		 turbulenceTbl[index]    =  sinTable[marb_index];                      // get the marble from the table
	     u_init                          += du;
	}
}

void turbulencePass1(unsigned long u_init , unsigned long v_init, 
			                     signed long  du			         , signed long dv,
							     long Num_Pix, 
					             unsigned __int16 *screen_buffer)
{
static unsigned __int16   alignPixNum , index , u_16bit  , marb_index;

if(Num_Pix == 1)    {
	  *(screen_buffer) = screen_buffer[-1];
	   return;
  }
	
alignPixNum = (Num_Pix + 3) & 0xfffffffC;

memset(turbulenceTbl,0,sizeof(__int16) * alignPixNum);

MMX_Octave(u_init,     v_init, 
	                  du,         dv,
					  (alignPixNum >> 2), turbulenceTbl
					  ,num_octaves);

turbulenceTbl[0] = turbulenceTbl[1];

if(LIGHT && shader_perturb_method) 
     memcpy(onlyTurb,turbulenceTbl,sizeof(__int16)*Num_Pix);

u_init >>= 14;
du      >>=    14;

  
  for(index = 0; index < Num_Pix; index++) {
         u_16bit					   = (unsigned __int16)u_init; 
         marb_index			      =  (u_16bit    + (10 * turbulenceTbl[index]));     // marble(x) = sine(x + turbulence (x))
	     marb_index              -=  1500;
		 if(marb_index >=  4999) marb_index = 4999;
		 turbulenceTbl[index]    =  sinTable[marb_index];                      // get the marble from the table
	     u_init                          += du;
	}
}

/************************************************************************************/
/* 
    Here is the wood implemented by C code,noise is still calculated by mmx.
    To use it, just replace the call in render.c for woodPathMMX
	to be woodPassMmxAndC.
*/
/************************************************************************************/
static unsigned __int16 sqrtRes;
void  sqrtApprox(unsigned long n);
/************************************************************************************/
void woodPass(unsigned long u_init,  unsigned long v_init, 
									   signed long  du,     signed long dv,
									   long Num_Pix, 
									   unsigned __int16 *screen_buffer)
{
static int index;
static unsigned long uu,vv,res;
static unsigned __int16 alignPixNum, u_16bit, v_16bit;

if(Num_Pix == 1)    {
	  *(screen_buffer) = screen_buffer[-1];
	   return;
  }

alignPixNum = (Num_Pix + 3) & 0xfffffffC;

memset(turbulenceTbl,0,sizeof(__int16) * alignPixNum);

MMX_Octave(u_init,     v_init, 
	                  du,         dv,
					  (alignPixNum >> 2), turbulenceTbl,
					  num_octaves);

turbulenceTbl[0] = turbulenceTbl[1];

for(index = 0; index < Num_Pix; index++)
  {

 u_16bit = (unsigned __int16)(u_init >> 14); 
 v_16bit = (unsigned __int16)(v_init >> 14); 
 
 uu		    = u_16bit * u_16bit;
 vv		    = v_16bit * v_16bit;
 res		= uu + vv;                   // r^2 = u^2 + v^2

 res	    = (res >> 10);
 if(res > 8191) res = 8191;
 sqrtRes      = sqrtTable[res];    // get the sqrt of r^2 from the table
 
 sqrtRes     *= 10;
 sqrtRes     += 15 * turbulenceTbl[index] ;   // weight the Radius by 10 and add turbulence
																	 //  wood = 10 * r + 15 * turbulence 
 
 sqrtRes    >>= 2;     
 sqrtRes      = sqrtRes - 735;
 if(sqrtRes >= 6000) sqrtRes = 5999;
 turbulenceTbl[index] =  woodTable[sqrtRes];     // get the wood from the table
 
 u_init += du;  
 v_init += dv;
}

}


/************************************************************************************/
static float smoothstep(float a, float b, float x)
{
    if (x < a)
        return (float)0;
    if (x >= b)
        return (float)1;
    x = (x - a)/(b - a); /* normalize to [0:1] */
    return (x*x * (3 - 2*x));
}
/************************************************************************************/
static void  sqrtApprox(unsigned long n)
{
static unsigned long Si;
Si = (n >> 1);
do {
	  sqrtRes = (unsigned __int16)Si;
	  Si  = (Si + (n/Si) ) >> 1; 
	} while (Si < sqrtRes);
}
/************************************************************************************/

/*
// sqrtRes   = (unsigned __int16)floor(sqrt(res));
// sqrtApprox(res);
res		     = res >> 10;
sqrtRes      = sqrtTable[res];  
sqrtRes     *= 10;
sqrtRes    += 15 * turbulenceTbl[index] ;
sqrtRes  >>= 2;
sqrtRes      = sqrtRes - 735;
if(sqrtRes >= 6000) sqrtRes = 5999;
turbulenceTbl[index] =  woodTable[sqrtRes];
// *(screen_buffer++) =   woodTable[sqrtRes];
*/